Flow and agent frameworks
This page compares classes of architecture, not named products. Agent frameworks change fast, and a comparison pinned to one library’s current release goes stale within a few versions. Check which library best represents each class on the day you read this:
- Graph orchestrators. The agent is nodes and edges in a graph, written in the framework’s own Python or TypeScript DSL. The framework walks the graph and checkpoints state at each node.
- Conversational multi-agent frameworks. Agents are participants in a conversation, and the framework manages turn-taking and message passing between them.
- Flow. The agent is a capability dispatched from a BPMN process or a CMMN case, run by the same host as every other task in the system.
Execution model
Section titled “Execution model”A graph orchestrator’s DSL and a conversational framework’s message protocol exist because that framework needs them, and the people who read them are the people who learned that framework. Flow’s model is BPMN and CMMN, OMG standards for processes and case management that predate agentic AI. A BPMN diagram is legible to a business analyst or an auditor, which matters as soon as someone other than the engineer who wrote the agent needs to know what it does.
Durability and crash recovery
Section titled “Durability and crash recovery”Most agent frameworks offer persistence for agents specifically: an agent run opts in, state is saved at defined points, and the team wires resume logic around it. Flow’s agent loop has no persistence layer of its own. It runs on the host that runs every other capability: as a reducer on the broker, as journaled steps on DBOS. The crash-recovery behaviour of a payment task or a document approval applies unchanged to a multi-turn agent loop, so no agent has a separate question of whether its run resumes.
Human approval and governance
Section titled “Human approval and governance”A graph orchestrator models “ask a person” as an interrupt node wired into the graph. A conversational framework models it as a participant a person plays. Both are code an engineer adds, reviews and maintains for each agent.
In Flow an approval is spec configuration (approvalNamespaces) or,
in case mode, CMMN model data: a
manualActivationRule on the tool’s discretionary item. Adding a gate,
or changing who may authorise what, is then an edit to the case model
that its owner reviews.
Tool integration
Section titled “Tool integration”Every framework in this space has a way to declare tools. The difference
is whether a tool is its own vocabulary or something the system already
has. Flow has no separate tool registry. The capability.Registry a
service task resolves against is the tool registry, and the schema
derived from a connector’s input struct builds both its task panel and
its tool parameters. A connector written once is a process step and a
tool.
Summary
Section titled “Summary”| Graph orchestrators | Conversational multi-agent | Flow | |
|---|---|---|---|
| Execution model | The framework’s graph DSL | The framework’s message protocol | BPMN and CMMN |
| Durability | Opt-in checkpointing for agents | Varies; often none built in | The host every other task runs on |
| Human approval | Interrupt nodes, in code | A participant a person plays, in code | Spec configuration, or case model data |
| Tools | The framework’s tool registry | The framework’s tool registry | The registry service tasks use |
| Who can read the model | Engineers who know the DSL | Engineers who know the configuration | Anyone who reads BPMN or CMMN |
| Record | The framework’s run logs | Conversation transcripts | The case history, which replays against the definition |
When a framework fits better
Section titled “When a framework fits better”A graph orchestrator or a conversational framework is the better choice for some problems:
- No surrounding process. A standalone research bot, or a prototype with no case, no approval chain and no need to sit beside other process models, gains nothing from BPMN or CMMN structure and pays for it.
- The newest agent pattern, now. Research-led frameworks ship new prompting and coordination techniques before a standards-based tool adopts them. Where being first matters more than governance or durability, that is a fair trade.
- A team that will not model. The legibility and governance above assume someone models the process. A team that wants to stay in imperative code will feel BPMN and CMMN as friction.
Flow fits when an agent’s actions need the same governance, record and durability as the rest of a business process, and when the question “what may this agent do right now, and who approved it” needs an answer someone can point to in a model.