People keep asking me why I built a workflow runtime on Petri nets when n8n already exists. Fair question, and it deserves an honest answer rather than a takedown. The short version: they answer different questions, and once your automation starts to think, the difference stops being academic. Here are the ten reasons, with real numbers where I have them, and a section at the end on where n8n genuinely wins.
Two Different Questions
n8n answers the question: when X happens, do Y and then Z. A trigger fires, data flows left to right through a chain of nodes, and the run ends. That is a genuinely useful shape, and n8n executes it well.
Agentic-Nets answers a different question: how do I run a process that never ends? Work arrives and waits somewhere. Several things happen at once. Humans and AI agents both touch the same state. And afterwards you need to prove exactly what happened and why. That is not a bigger workflow. It is a different abstraction: a live Petri net, where places hold persistent state, tokens are the work items, and transitions act on them, forever.
The Ten Reasons
1. A process, not a run
An Agentic-Net is a live concurrent state machine with formal Petri-net semantics. Joins, forks, work-in-progress limits and capacity gates are native concepts, not IF-node workarounds. That formality pays off when things go wrong: I once diagnosed a pipeline that had been frozen for days by walking the net and finding a capacity limit four stages downstream that cascaded backwards through six lanes. You can reason about liveness and deadlock in a net. There is no equivalent conversation to have with a DAG runner.
2. State lives in the net
In n8n, keeping state between runs means bolting on a database or abusing static workflow data. In an Agentic-Net, the tokens are the state. A backlog place holding 40 stories is the system of record: queryable, capacity-bounded, and it survives restarts because of reason 3. Nothing needs to be rehydrated, because nothing was ever thrown away.
3. Every change is an event
The persistence engine is event-sourced: every mutation is an immutable event, and the read models are projections that can be rebuilt from history. You get a complete audit trail for free, and questions like “what was the event trail for this transition in the last ten minutes” are first-class queries. n8n gives you execution logs of runs. It cannot replay its way back to a state.
4. Agents are governed, not just called
Both platforms can call an LLM. The difference is what happens around the call. Agent transitions in an Agentic-Net carry capability flags (read, write, execute, http, logs and more), which filter the tool catalog the agent even gets to see. Iteration caps bound the loop. And every fire writes its cost back into the net: tokens burned, turns taken, dollars spent, sitting in a place where the next transition can read them and react. An agent here is a governed citizen of the process, not an API call with a prompt.
5. The cost curve is designed to bend to zero
This one is the philosophical core. The architecture assumes AI reasoning is scaffolding: an agent handles the novel work first, and once the lane’s behavior is understood, you crystallize it into deterministic transitions (http, map, pass) with the same contract. On a real reporting lane, the agent version burned 821,000 tokens per fire. The crystallized replacement does the same job with an O(1) batch endpoint and two map templates: zero LLM tokens, forever. n8n has no concept of a workflow that learns itself into determinism.
6. Routing is a query, not spaghetti
Token selection is declarative. A transition states what it consumes with ArcQL, a small query language over the persistent state:
FROM $ WHERE $.status=="active" AND $.retries < 3 LIMIT 1
Guards, complement pairs and joins are expressed as queries over what is actually sitting in the places, not as per-node expressions that can only see the current run’s payload. When two transitions race for the same work, the query plus token reservation decides it atomically.
7. Workers dial out, nothing dials in
Command execution is distributed by polling. Executors call out to the master through an OAuth2 gateway with a JWT that is scope-limited to the polling protocol, pick up work, and report back. No inbound ports, no webhooks to expose, no broker to operate. An executor can sit on a laptop behind a corporate firewall and serve the same net as one in a datacenter. Per-transition targeting picks which executor runs what, and first-token-wins reservation keeps it at-most-once.
8. MCP in both directions
The platform is an MCP server: Claude and other MCP clients use nets as working memory and as a workbench. And agents inside nets are MCP clients: a transition can declare external MCP servers, and the agent reaches exactly those, with credentials resolved from the vault. n8n added MCP support as a node. Here it is load-bearing architecture, in both directions, under the same governance as everything else.
9. Secrets never enter the workflow definition
Transitions reference a credentialKey. Resolution happens at fire time through a dedicated vault service backed by OpenBao. The inscription, the thing you version, share and publish, never contains a secret. You can hand someone a whole net without scrubbing it first.
10. You can see why nothing happened
OpenTelemetry traces, Prometheus metrics, Tempo and Loki are wired in by default, with trace IDs in every log line. But the part I use daily is different: per-transition diagnostics that explain why a transition did not fire. Empty preset, capacity block downstream, schedule not due, token reserved by someone else: the runtime tells you which. In a run-based tool, the hardest bug is always the run that never started. In a net, that is a query.
Where n8n Still Wins
Honesty section. n8n has hundreds of prebuilt SaaS integrations and a much larger community. If the job is “when a Typeform lands, post to Slack”, n8n is faster to click together, and choosing it is correct. Agentic-Nets talks to external systems through generic http transitions, commands and MCP servers, which is more flexible and less convenient.
The line I would draw: if your automation is short-lived, stateless and integration-shaped, use n8n. If it is long-running, stateful, concurrent or agentic, if teams of LLM agents do real work over days, under audit requirements, with a cost curve that must come down over time, then a DAG runner is the wrong abstraction. That gap is exactly what Agentic-Nets exists to fill.
Try It Yourself
The fastest path is the desktop app: one download, no Docker, no API key required. Grab the latest installer from the releases page. Or run the full stack:
git clone https://github.com/alexejsailer/agentic-nets.git
cd agentic-nets/deployment
cp .env.template .env
docker compose -f docker-compose.hub-only.yml up -d
# Studio on http://localhost:4200
The numbers in this article come from the production instance that builds, tests and ships this platform, including the 821k-token lane that crystallized to zero.
Related: The Software Team That Ships While You Sleep • Agentic-Nets for Any Domain • Watching the Meter • Your Agent Can Use Any MCP Server • One Download, No Docker, No API Key