The graph is the architecture — integrity and concurrency for agentic systems

The morning the verifiers agreed on a draft no one wrote

Path A self-verify mode looked like the elegant case. Run the Generator on the gold-standard path, let the verifier panel score the Generator against itself, ship the consensus. Three engineers signed off on the topology in a whiteboard session. The first production run produced clean 4-of-5 consensus on a draft the Generator had not actually written during the run.

What happened: the Generator node hit its three-strike timeout on a long context. The orchestrator followed its fallback rule and used the last cached draft. The verifier panel, already pulling from the shared work table, started scoring the stale draft against the new gold-standard. Consensus was real. The artifact under consensus was a ghost.

The bug was not in the Generator. The bug was not in the verifiers. The bug lived in an edge: an unannotated fallback transition valid in Path B and catastrophically wrong in Path A.

An agentic system as a relay race

Think of an agentic system as a relay race. Each runner is a node — a model call, a tool, a verifier. The baton is the data. The track — the order of handoffs, who waits for whom, what happens when a runner trips — is the graph.

Most teams obsess over runner quality. They argue about which model is fastest, which prompt is sharpest. They almost never draw the track. And then one day a runner trips, the baton gets handed off twice, and three judges declare a winner who never actually ran. The race was lost on the track design, not on any single leg.

Nodes, edges, and the contracts between them

A graph-constrained agentic system is a directed graph $G = (V, E)$ where $V$ is the set of computational units (LLM calls, tools, retrievers, validators) and $E$ encodes both control flow and data dependencies. Execution is a traversal protocol over $G$ with explicit semantics for:

• Node contracts: input schema, output schema, timeout, retry policy, idempotency guarantees.
• Edge semantics: conditional routing predicates (ifElse, switch), fan-out/fan-in cardinality, ordering constraints.
• State scope: node-local state, graph-shared state, and cross-run persisted state.
• Failure topology: which edges fire on timeout, on schema-violation, on downstream rejection.

When teams say “agent,” they usually mean an implicit graph: a chain of prompts and tool calls whose topology requires code reading to reconstruct. Graph-constrained execution makes the topology a first-class artifact: serialized, version-controlled, diffable, and, critically, the unit of review when something fails.

Where this comes from — workflow nets and Petri-nets

The formal frame is workflow nets and Petri-net concurrency theory, with a more recent lineage through computational graphs (TensorFlow’s static graph era), dataflow languages, and the BPMN tradition for business process orchestration. The contemporary agentic systems literature — see Wu et al.’s AutoGen (2023) and the LangGraph design notes — explicitly reaches back to this body of work because the failure modes rhyme: token-flow integrity in a Petri net is structurally the same problem as message-passing integrity in a multi-agent verifier panel.

In Petri-net notation, a transition $t$ gains enabled status in marking $M$ when every input place $p$ in the preset $\bullet t$ holds at least the required number of tokens, and firing $t$ updates the marking by

$M'(p) = M(p) - W(p, t) + W(t, p)$

for every place $p$, where $W$ is the weight function on arcs. The agentic-system analog: a node fires when its input edges have all delivered the required state, and firing the node updates the shared state along its output edges. The same theorems about reachability, liveness, and boundedness carry over — and so do the same failure modes when the firing rule is left implicit.

The interesting frontier is partial determinism: graphs where some nodes are stochastic (LLM calls) but the topology and the gating predicates are not. Soundness proofs over such hybrid graphs remain an open research area. Practical takeaway: more system behavior inside the deterministic skeleton means less surface where stochastic behavior can corrupt invariants.

Friction is the point

Explicit graphs give up flexibility. A graph is harder to change on a whim. No new step can slip into a chain at 11pm because someone had a clever idea on Slack; the topology has to change, get versioned, and pass the verification panel again. The friction is the point. It is the same friction a type system imposes, and for the same reason.

Explicit graphs also give up a certain kind of emergence. Implicit-graph fans often describe agent magic as self-directed control flow. True, and also exactly the property to avoid in accountable systems. Emergence and integrity sit on opposite ends of the determinism ladder. Pick the rung deliberately. The decision lever: every explicit edge turns one 4am race condition into a design-time debugging obligation.

Path A Fix

The Path A incident cost six hours of confused triage because every node passed its unit test. The Generator node correctly timed out and correctly fell back. The verifier panel correctly reached consensus on the input it received. The orchestrator correctly logged each transition. Every component was innocent. The system was guilty.

The fix was small and humbling. An ifElse now sits at the entry to the Generator node: when target_path == gold_standard_path, bypass the Generator entirely and route the gold-standard directly to the verifier panel. Fifteen lines of topology change.

An invariant now backs the topology too: verifiers must receive a payload with a generated_at timestamp from the current run. The invariant lives as a hard edge predicate, not a soft check inside a node. The lesson on the whiteboard afterward still holds: edges fail silently; make them speak.

Try this in an afternoon

In an afternoon: take any two-step LLM pipeline — say, a generator and a critic — and rewrite it twice. First, draw the graph by hand on paper, including every fallback, timeout edge, and retry. Second, implement it in LangGraph or a hand-rolled state machine where the topology is a serializable artifact. Now inject a timeout into the generator. Watch the edges. Note every unpredicted behavior. The gap is the real architecture.

Where orchestration earns its keep on the ladder

The determinism ladder is a discipline of pushing work down the stack. Graph-constrained execution is the rung where orchestration earns its keep. Below it, the model does only model-shaped work. Above it, skills and agents trust the topology to hold. When the graph is explicit, every node above can assume integrity without re-verifying it. The bargain of architecture: someone took the race condition seriously before the incident required it.