Today, we're launching New Agent.

Agent in Dify is now a standalone and independent app, or reusable resource of a workflow. Each agent has its own configuration and lifecycle. Build it once, refine it over time, and publish it as a web app, expose it through an API, or reuse it across multiple workflows.

AI agents are quickly moving from proof of concept (PoC) to real business use. McKinsey's 2025 State of AI survey found that 62% of respondents say their organizations are at least experimenting with AI agents. As adoption grows, new questions arise: Who maintains an Agent? Where is it being used? How can teams update it safely and understand what happens when a run goes wrong?

These questions led us to rethink what an agent should be in Dify. Then, the New Agent experience is our answer.

From an agent node to a New Agent

In March 2025, Dify introduced agent nodes and Agent Strategies, giving models greater autonomy to reason and use tools inside a workflow.

But each agent remained tied to the workflow where it was built. Reusing the same capability elsewhere meant rebuilding its Prompt, Tools and other settings.

New Agent changes that.

Each agent now has a single source of truth for its model, prompt, skills, files, tools settings. It can be maintained in one place and reused across different apps and workflows in just a few clicks.

Build, manage, and track agents in one place.

A reusable Agent needs more than a configuration page. Teams need a way to refine it through real task, apply it across different contexts, and learn from its behavior for improvements in production.

The New Agent experience is built around three things:

• Build: Turn real work into a reusable Agent capability, across business workflows with flexible configuration modes.
• Manage: Reduce duplication and maintenance with one Agent reused across multiple workflows.
• Track: Get full white-box observability via single-run tracing and long-term monitoring.

Build: Refine agents through real work

Good Agent are shaped by the work they actually do.

You may begin with a clear goal but still need to discover what tools, where its boundaries should be, and which methods are worth preserving.

Dify supports two ways to get started:

In Build mode, changes are saved to Build Draft and reflected in the configuration panel. You can see what changed in the configuration panel, keep the changes you want, or discard the ones you don't.

The Agent also maintains build_note.md, a running record that tracks its configuration changes and captures what it has configured and what still needs attention. Use Preview anytime to try the Agent as your users would. When everything looks good, publish your update.

An agent is more than a prompt

A prompt may be enough for a simple task. But it becomes harder to maintain when it also contains business rules, reference material, tool instructions, and detailed operating procedures.

To support this, Dify gives each capability a clear, manageable part within the new agent:

Each part can be maintained on its own. You can replace a tool or refine a skill without rewriting the entire prompt.

Three ways to extend an agent

Dify gives teams three ways to extend what an agent can do, from quick exploration to governed production use:

Tools for managed integrations

Power your New Agent with production-ready integrations. Teams can plug in Marketplace extensions, connect custom APIs or MCP servers, or wrap existing Workflows as Tools.

Tools are managed at the workspace level and shared across Agents. A charting tool, for example, only needs to be set up once. Different Agents can then use it to analyze data, create weekly reports, or build charts for internal dashboards.

For capabilities that need additional configuration, Advanced Settings keeps environment variables in one place and makes them available to the Agent in its Sandbox. When an endpoint, default value, or runtime setting changes, you can update it without tracking down every place it appears.

Skills for repeatable methods

A Skill packages instructions, reference material, and scripts that belong together.

For example, a growth analytics skill might include definitions for CTR, CPA, and ROAS, along with scripts that calculate them consistently. The Agent can reuse the same method across tasks without crowding its prompt or creating a separate Tool.

And there's more to come for Skills. We're working on Skill Management, which will make Skills shared resources across the workspace. Teams will be able to manage and version Skills in one place, then reuse them across different Agents.

As your processes evolve, the Skills behind them can evolve too, keeping Agents that rely on the same methods aligned.

CLI tools for temporary work

Some tasks only need a tool once. Instead of adding it to the Agent's permanent setup, the Agent can install and run CLI tools directly in its current Sandbox session.

Ask for an editable growth deck, for example, the Agent can install what it needs in the Sandbox and create the file for you. The same works for quick jobs like parsing logs, converting files, or working through a dataset.

If the same CLI setup starts showing up again and again, turn it into a Skill. And when that capability needs to work reliably across Agents, make it a shared Dify capability through an API, MCP server, plugin, or Workflow Tool.

Make every fix improve the next run

Publishing an Agent is not the end of the build process. Once it starts doing actual work, new runs will expose gaps: an unclear instruction, missing context, or a method that needs refinement.

The useful question is not simply:

"How do we fix this answer?"

It is:

"Where should the fix live?"

Take a product comparison Agent as an example. During testing, it mixed nutritional values from two different products. Adding another instruction to the prompt might have fixed that particular response, but it would not have addressed the underlying problem.

Instead, we separated each product's information into its own record and updated the Skill to retrieve products separately, verify the available evidence, and avoid inferring information that wasn't there.

On the next test, the Agent kept the two products separate and handled questions about allergens, inventory, refunds, and privacy with the right boundaries.

Instead of patching one answer, we improved the way the Agent handles the task. That improvement carries into every run that follows.

Manage: Build once, reuse anywhere

Copying an agent is easy. Keeping every copy up to date means repeating the same changes across each one.

Once the same prompt, skills, tools, and configs across multiple apps, every update has to be made again. Over time, teams lose track of which copy is current.

The new agent experience replaces those copies with one shared agent. The Agent page provides a central place to find and manage agents by status, creator, and update time. Each agent has its own name, description, configuration, and publication state.

One Agent, multiple access points

An agent can be published as a web app, exposed through an API, or reused across multiple workflows. The same agent can serve different contexts without duplicating its configuration.

Access Points shows where the agent is available and which workflows is using it. Before publishing shared changes, maintainers can understand the possible impact of a shared configuration change.

Define the task inside a workflow

The same agent takes on different responsibilities in different Workflows.

Workflow builders do not need to reconfigure the Agent’s Prompt, Skills, or Tools. Instead, they use Agent Task to define what the Agent should do in the current node, which upstream variables it can use, and what results it should produce. With declarative outputs, those results can be passed to downstream nodes in a predefined structure.

Let's look at an example. Say you've built a Growth Analytics Agent that can answer growth questions, calculate metrics, and create charts. You can use it on its own, or bring the same Agent into a Campaign Analysis Workflow and give it a more focused task. From there, the Workflow can handle quality checks, branching, and human review.

For temporary capabilities scoped to a single workflow, start from scratch with a blank agent node. If it proves useful in other contexts later, save it to Agents and manage it centrally.

Build once, then apply the same capability wherever it is needed. The shared capability stays consistent while task boundaries remain clear.

Track: See what happened

Once an agent is used across multiple access points and workflows, the final answer alone is not enough to locate a problem. To locate a problem, teams need to know which agent was involved, when and where it ran, and which access point or workflow triggered it.

Dify provides three levels of observability, from individual runs to long-term performance:

Single Runs: Logs and Tracing

Logs and tracing show what happened in each run, from the user's input to the final response. Each run includes its access point, helping teams determine whether an issue comes from a specific source or the shared agent configuration.

Workflow Nodes: Debug Agent Workflows with Precision

When an agent runs in a workflow, Last Run and Variable Inspect help teams inspect execution steps and data passed between nodes, making it easier to locate issues in the agent or the surrounding workflow.

System Trends: operational monitoring

Teams can track usage, quality, performance, and cost over time, and compare results across versions and contexts.

Dify also introduces Workflow log archives organize historical runs by month and let you download them for long-term investigation, operational analysis, and internal audits.

Log archives aren't available in the Community Edition. Details on retention and archives → docs

Built on Dify's core

The New Agent experience extends four things that have always been core to Dify:

• Model agnostic — Commercial or self-hosted models without vendor lock-in. Balance performance, cost, and compliance. and private models, without vendor lock-in. Balance performance, cost, and compliance.
• Visual building — Start from real tasks. Refine in Build mode. Combine natural-language exploration with transparent, structured configuration that business and technical teams can review together.
• Flexible composition — Use an agent standalone, connect via API, or embed in a Workflow alongside data processing, business rules, human approval. One capability, many contexts.
• Transparent control — Operate agents within visible, governed boundaries with logs, Tracing, Monitoring, version control, credential isolation, and Human Input. Agents stay within visible, governed boundaries.

For enterprises, the hard part is rarely building one agent. It is enabling that agent to be reused safely across the organization, maintained over time, and operated in production with clear observability and governance. Dify brings models, agents, Workflows, APIs, and runtime visibility together on one platform, giving teams a consistent way to build, deploy, and improve shared capabilities.

Start building

New Agent provide dynamic judgment; Workflows provide process structure and control. Together, they let enterprises start with a real use case instead of trying to anticipate every situation before launch, and then keep improving as the business evolves.

Start with one real business task. Refine the agent through actual runs, then reuse the proven capability across more of the organization. Learn how to configure an Agent in our doc.