AI Agents don't need to be Boxes and Lines
Adrien Simon
As companies rush to ship "AI agent building" products, we're seeing a familiar interface pattern emerge: visual workflow canvases with boxes, arrows, and conditional logic gates.
OpenAI announced their Agent Builder with node-based workflows. n8n positions AI agents as specialized nodes in automation flows. The industry consensus seems clear: if you want to build AI agents, you need to map out every step in a flowchart.
At Dust, we bet on a different future for agents.
Not because visual workflows are bad. They're excellent for what they were designed to do. But because AI agents aren't workflows, and forcing them into the same boxes-and-arrows paradigm limits what they can accomplish.
The difference comes down to this: workflow builders ask you to model your business process step by step. Agent builders ask you to describe your intent. That's a fundamentally different paradigm.
Why Workflows Break Down for AI Agents
Let's start with what workflows do well: they automate deterministic processes with known paths and predictable outcomes. If you can draw it in a flowchart, a workflow will execute it reliably.
The problem? Most valuable business work doesn't fit this pattern.
Workflows enforce rigid paths: A leads to B leads to C. But real work isn't linear. Sometimes you need to jump from C back to A when new information surfaces, or skip B entirely because the situation changed. Workflows can't do that without you pre-defining every possible jump.
Consider what happens when you build a workflow. It works for 2 weeks, and at one point the workflow breaks. You debug. You add more conditional branches. You account for the new edge case. Then another edge case appears. The workflow that started as five nodes becomes 50 nodes, and you're spending more time maintaining the automation than you would have spent doing the work manually.
This isn't an implementation problem. It's a mismatch between the tool and the task.
Why Production Agents Can't Be Workflows
As Stanislas Polu, our technical cofounder and former OpenAI researcher, puts it: "Simple thought experiment: think about coding. Would Cursor, Claude Code, or Manus be of any use if they were based on configurable workflows?"
The answer is obviously no.
Cursor works because it maintains conversation context across your coding session, suggests code in real-time (sub-100ms), learns from your accept/reject patterns, and dynamically routes between models based on task complexity.
Modern workflow platforms like n8n do have AI capabilities. You can build loops with AI nodes and tools. But production-grade interactive agents require infrastructure (low latency, stateful sessions, feedback loops, distributed caching). Here's what you'll quickly find yourself rebuilding:
- Conversation memory management across sessions
- Tool execution error handling and retries
- Prompt versioning and A/B testing
- Multi-turn reasoning and planning
- Security and access control for tools
You're not just building an agent, you're building agent infrastructure. And you're doing it inside a tool that was originally designed for something else. The same principle applies to all knowledge work. For tasks requiring reasoning and adaptation, workflows are the wrong paradigm.
Foundation Models Change Everything
Here's why natural language is now a viable approach: models have gotten good enough at following complex instructions, and they're improving every month.
GPT-5 and Claude 4.5 can understand nuanced business context, select the right tools for a task, reason through unexpected edge cases, and adapt when their first attempt doesn't work. They're not perfect. They still hallucinate, lose context in long sessions, and make confident mistakes. But for many tasks, they can follow detailed instructions reliably enough to be useful.
This changes the game completely. Instead of trying to anticipate every scenario and map every branch in a workflow, you can describe your goal in natural language and give the agent actual agency to figure out how to get there. As models improve, your agents get smarter without you changing a single line of configuration.
That's fundamentally different from workflow builders, where better models don't automatically make your automation smarter. You still have to redesign your workflow graph to take advantage of new capabilities.
How Natural Language Replaces Boxes and Lines
Dust's Agent Builder eliminates visual workflow canvases entirely. Instead, you define agent behavior through natural language instructions, the same way you'd brief a human colleague.
Instructions: Your Agent's Operating Manual
Rather than connecting nodes on a canvas, you write instructions like:
"You are a PR reviewer. Focus on code maintainability and security. Check for hardcoded credentials, SQL injection risks, and overly complex functions. Reference our coding standards from the engineering wiki. Keep feedback constructive and specific. If you're uncertain, ask clarifying questions instead of guessing."
That's it. No flowchart required.
The instructions act as your agent's code of conduct. Everything it should and shouldn't do. You can specify:
- Role and constraints: What persona should it adopt?
- Expertise requirements: What should it do differently from default behavior?
- Output format: Bullet points? Paragraph? Slack message?
- Boundaries: What should it avoid or flag for human review?
- Tools: Which integrations should it use, and when?
As you iterate, you refine the instructions based on real outputs. More like coaching a team member than debugging code.
A word of caution: natural language instructions can also accumulate complexity. "Do X, but not if Y, except when Z" is still modeling edge cases, just in prose instead of boxes. The difference is that the model handles interpolation between your examples rather than requiring you to enumerate every path. That's a real advantage, but it's not magic.
Triggers: Natural Language for Automation
Traditionally, triggers require either using complex UI for scheduling or writing conditional logic to filter webhook events. At Dust, we use LLMs to translate natural language descriptions into executable trigger configurations.
- For scheduling, you write: "Every Tuesday at 8:30 AM Pacific Time"
- For webhooks: "New pull requests on dust-tt/dust that have the 'bug' label"
No code required. Just describe what you want. The system understands both event structure and your intent. No need to debug conditional logic or learn a new query language.
When Workflows Are Still the Right Tool
To be clear: this isn't about workflows being bad. It's about using the right tool for the job.
Workflows excel when:
- You need guaranteed execution order with exact retry logic
- The automation is simple enough that visual representation adds clarity
Modern workflow tools support AI nodes for generation, branching, and tool use. You can handle some non-deterministic behavior. This can be a perfectly reasonable choice for many use cases.
But the structured, step-by-step nature that makes workflows powerful also becomes a constraint: the guardrails you add to handle edge cases accumulate quickly. As you try to cover a wider range of scenarios or tackle harder problems, the rigid framework starts working against you rather than for you.
For the messy, context-dependent, "it depends" work that makes up most knowledge work, that's where agents shine.
Many companies will use both: workflows for system integration and agents for intelligent decision-making. You might trigger a Dust agent from a Zapier workflow, or have an agent invoke n8n workflows as tools. The key is recognizing that trying to encode agentic behavior as a workflow graph hamstrings the agent's ability to reason.
Why This Matters Beyond "Ease of Use"
The natural language approach isn't just more accessible for non-technical users (though it is). It's fundamentally more powerful:
Scales with model improvements. As models get better at reasoning, your agents improve without configuration changes. Workflow-based approaches can't leverage these improvements without manual redesigns.
Reduces maintenance burden. Agents adapt to changing APIs, unexpected inputs, and edge cases. Workflows tend to break.
Matches how humans actually work. You don't think "if condition A, then step B, else step C" for every decision. You have goals, constraints, and judgment. Agents work the same way.
The Real Difference
This is what it comes down to: modeling a process requires you to anticipate every scenario, map every branch, and maintain that model as reality changes. It's brittle by design. Describing intent is how you'd explain the task to a smart colleague: "Here's what success looks like, here are the constraints, use your judgment for the rest."
Models are now good enough to handle the "use your judgment" part. Not perfectly, but well enough for many real tasks. That's the shift.
The best way to build an agent is the same way you'd onboard a new hire: tell them what you need, give them the tools, and let them figure it out.
Agents deserve agency. Give it to them.
We're hiring engineers, product designers, and go-to-market folks who want to build the infrastructure layer for AI-driven companies. If you're excited about agents that reason instead of workflows that break, come talk to us.