Why We Redesigned Dify's Agent?

From the beginning, building Dify has meant balancing two very different worlds: fast-moving language models and the stability companies expect from enterprise software.

We want users to benefit from the latest models while giving companies what they need to use them in production: private deployment, model choice, access controls, explainability, and auditability. Building for both has never been straightforward. This tension shapes not only how we build, but also what we choose not to build.

Earlier this year, OpenClaw took off and we could have rushed to build a Dify version. Instead, we paid closer attention to the broader consensus forming behind its popularity: the CLI-agent pattern was no longer just for coding, and it started to find a place in real business workflows.

That was the shift we wanted to build for. We redesigned Dify's Agent system so that apps and workflows built with Dify could hand off parts of complex tasks to CLI agents.

Where the New Agent Fits

Your team may already have a standard operating procedure and a collection of relevant skills. Part of this process is repetitive and time-consuming, and you can let the new Agent to take on that work without rebuilding the entire process.

Or perhaps part of the service you need isn't covered by Dify's plugin ecosystem yet, and now the new Agent can help bridge that integration gap because the Agent can work with CLI tools.

In other cases, the people who know what good work looks like, but they just don't want to learn prompts, tools, files, and runtime settings first.

Build Mode is designed for this, you can build the agent by chatting.

Instead of filling in every setting manually, they can walk the Agent through a few real tasks, much like onboarding a new colleague. They try to finish a task together, correct it, and try again. The skills, tools, and key instructions developed along the way are saved for future runs.

The Agent Loop Is Only the Starting Point

Build Mode makes an Agent easier to build, but ease of setup is no longer enough when an agent start running inside a workflow.

At its core, the system uses the same pattern you may know from Codex and Claude Code: a model-driven ReAct loop, Bash tools, and an isolated sandbox for getting the task done.

The loop is only the starting point. An Agent that runs repeatedly also needs to manage context across long tasks, move between models, maintain a stable runtime, and respond predictably when something fails.

To keep running reliably, an Agent also needs to switch between models, manage context across long tasks, maintain its runtime environment, and handle failures in a predictable way. Behind the scenes, we have invested heavily in these foundational capabilities. In current agent parlance, this is loop engineering, and Dify gives you a solid foundation for it out of the box.

For security and compliance, Dify Enterprise runs every session in a dedicated sandbox container, with process, file system, and network isolation. Administrators can define custom network policies and security contexts. Each sandbox is built from a hardened base image and runs without root privileges.

If Agents Are So Capable, Why Workflows Still Matter

We have heard this question a lot over the past six months, and the answer is:

Yes, because an Agent and a workflow do different jobs.

An Agent decides how to complete a task. A workflow decides when that task should happen, what comes before and after it, when a person needs to step in, and what to do if something goes wrong.

No matter how capable one person is, but complex work still requires calendars, messaging, approvals, and repeatable processes to keep everyone coordinated.

We see workflows as that coordination layer for agents and people, and they turn flexible Agent behaviors into a repeatable process that can be scheduled, monitored, and run stably over time. The more work agents can take on, the more important this coordination becomes.

From One-Off Work to Something That Keeps Running

This is where workflows become especially useful. Agents are good at improvisation. They can write a script, call a few tools, work with files, and solve a task that nobody planned for in advance.

That is impressive, but a single successful run is not a system.

A workflow makes that capability repeatable by giving the Agent clear boundaries: defined inputs and outputs, a schedule, permissions, failure handling, and monitoring. Within those boundaries, one-off improvisation becomes a process that can run reliably over time.

The result does not have to be a complete application. Often, it is simply a small piece of software that fills a gap in a product you already use. You can think of it as your own software patch.

A Small Example from My Meeting Booking

I use Calendly for meetings with customers and partners, often booked weeks in advance. By the time the meeting arrives, some attendees have forgotten about it. They either join unprepared or reschedule at the last minute, leaving an empty slot in my calendar.

Calendly's free plan does almost everything I need. The one missing feature is a same-day reminder.

I could ask a coding agent to connect Calendly MCP to an email client, write a reminder script, and deploy it as a scheduled GitHub Action. None of this is especially difficult, but for a non-developer, it sounds like a big project.

In Dify, the process is simpler. Install the Gmail plugin, configure Calendly MCP through Build Mode, do several tests, and add it to a scheduled workflow. About ten minutes later, it is checking my meetings and sending reminders automatically. It is not a new application, just the missing piece I needed.

What's Next: Agents. People. Same SOP

The Calendly example is small, but it shows what the new Agent makes possible today: bringing flexible agent work into a workflow that can keep running.

For here, we're exploring two directions: connecting Dify with more agent stacks, and improving how agents and people work together in the same process.

The goal isn't another standalone agent. It's a workflow that brings agents, existing systems, and people together, and this is just the beginning.

If you try the new Agent, tell us where it works, where it doesn't, and what you need next.