Deterministic agentic orchestration

Agentic orchestration is the layer that decides which agent runs next, what it sees, and how its output becomes input for the next step. In most frameworks today, that layer is implicit: agents read each other's natural-language messages from a growing transcript, and a router LLM picks who speaks next.

This works for demos. It collapses in production for two reasons: cost grows quadratically with agent count, and decisions are unauditable — you can't replay why a swarm reached a conclusion because the inputs were prose, not data.

When agents communicate by appending to a shared transcript, every agent's full output becomes part of every other agent's input on every subsequent turn. With N agents over T turns, the token cost of coordination grows like O(N²·T). The model spends most of its budget re-reading restated conclusions, not doing new work.

You can't prompt-engineer your way out of this. Summarisation helps constant factors but doesn't change the exponent. The wire format itself is the bottleneck.

The first architectural change: agents stop emitting prose. They emit typed packets — small, schema-checked structures with a claim, supporting evidence, confidence, and a provenance trail. Think of it as moving from email to a database write.

A packet might say { claim: "price_drop", asset: "X", confidence: 0.82, sources: ["agent_3", "agent_7"] } instead of three paragraphs explaining the same thing in English. Packets are tiny, composable, and machine-mergeable.

The second change: a deterministic state reducer merges packets into a shared state. Same packets in, same state out — always. No LLM call in the merge path. The reducer de-duplicates correlated claims, weights independent sources higher, and surfaces conflicts instead of silently averaging them away.

On each turn, an agent reads a compact, bounded view of state — the facts it needs, not the full transcript. Coordination cost flattens from O(N²·T) toward O(N·T). The same swarm becomes tractable at 10× the agent count.

Because the reducer is deterministic, every decision in the system is replayable. Given the same set of packets, you get the same state, and the same downstream action. That's the property auditors, compliance teams, and incident responders actually need — not "the model said so," but "here is the packet, here is the source agent, here is the reducer step that promoted it."

Natural-language orchestration can't offer this. Two runs of the same prompt give different prose; you can't diff prose with the precision a regulator expects.

• Agents stay model-agnostic. GPT, Claude, Gemini, local — doesn't matter. They just emit packets.
• The reducer is plain code. Deterministic, fast, testable, no inference cost.
• State is the source of truth. The transcript becomes a debug log, not the wire format.
• Independence weighting stops fake consensus: 300 agents echoing one source count as one voice, not 300.
• Conflicts are first-class events, not noise to be averaged away.

If you're running one or two agents in a clean handoff, keep your current setup. The architecture pays off when:

• You have 4+ agents sharing work, and token bills are growing faster than throughput.
• You need to defend decisions in an audit.
• You suspect silent agreement is hiding silent disagreement.
• You want to scale agent count without scaling the LLM bill.