Author: Michael Shatny
ORCID: 0009-0006-2011-3258
Version: 0.1.0 (working draft — not yet peer-reviewed)
Date: June 2026
Related: Semantic Intent as Governance Primitive (Shatny, 2026) · GESA Framework
Michael Shatny — June 2026
Everyone is deploying agents. Nobody is orchestrating them.
A single agent given a task is a driver with a destination. Useful, self-contained, manageable. But an enterprise system is not a single destination — it is a city. Dozens of services, multiple layers, competing timelines, shared infrastructure, concurrent goals.
Dropping agents into that environment without orchestration is like removing every traffic signal from a city and hoping drivers figure it out. Everyone can move. Nothing flows. And when something breaks, nobody knows who caused it or why.
Traffic engineering solved this problem for physical movement a century ago. The patterns it developed — signals, lanes, junctions, priority routing, audit trails — are directly applicable to agentic systems operating across enterprise infrastructure.
This is that mapping.
Traffic at scale is not managed by giving every driver a map and good intentions. It is managed through a layered system of controls that make individual movement predictable in aggregate:
| Traffic Concept | Function |
|---|---|
| Signals | Tell agents when to go, wait, or yield |
| Lanes | Separate concerns — fast vs slow, through vs local |
| Junctions | Controlled handoff points between flows |
| Priority routing | Emergency vehicles preempt normal flow |
| Speed limits | Rate limiting per zone |
| Traffic cameras | Every movement logged and attributed |
| Roundabouts vs lights | Different orchestration philosophies for different complexity |
Each of these maps directly to multi-agent orchestration across enterprise systems. The mapping is not metaphorical — it is structural.
Decides which agent runs when.
Without signals, agents collide. The signal layer is the orchestration controller — it reads current system state and determines which agent has right of way at any given moment. Signals can be:
- Time-based — agent runs on schedule
- Event-based — agent triggers on completion of prior agent
- State-based — agent runs when system state meets a condition
- Human-gated — agent waits for explicit human approval
The signal layer does not execute work. It governs when work begins.
Separates agent concerns cleanly.
Agents operating in the same domain without lane separation create contention. Lane assignment answers: which agent owns which boundary?
- Service lanes — one agent per service boundary, no crossing
- Data lanes — read agents separated from write agents
- Speed lanes — fast synchronous agents separated from slow async agents
- Concern lanes — application layer agents separated from database layer agents
Lane violations — agents crossing into domains they don't own — are the enterprise equivalent of a head-on collision. The damage is proportional to the speed of the agents involved.
Controls handoff between agents.
When agent A completes and agent B must continue, the junction governs the handoff. A clean junction has three properties:
- State transfer — agent B receives complete context from agent A
- Validation — the handoff artifact is checked before agent B proceeds
- Attribution — the junction records who handed what to whom and when
A junction without validation is an uncontrolled intersection. An agent receiving corrupted or incomplete context from the prior agent will produce corrupted output — and the error compounds downstream exactly as a traffic accident blocks all lanes behind it.
Urgent tasks preempt normal flow.
Not all agent work is equal urgency. A production incident requires different routing than a scheduled batch process. The priority layer assigns right of way:
- Emergency priority — preempts all other agents, clears the lane
- Standard priority — normal flow, yields to emergency
- Background priority — runs only when lanes are clear
Priority without enforcement is suggestion. The priority layer must be able to actually pause or redirect lower-priority agents when higher-priority work enters the system.
Every movement logged and attributed.
Traffic cameras exist not to slow traffic but to make every movement accountable. The audit layer records:
- Which agent ran
- When it ran
- What context it received
- What output it produced
- What it handed to the next agent
- Whether a human approved the handoff
The audit layer is not optional infrastructure. In an enterprise system, the ability to reconstruct exactly what happened — and who caused it — is the difference between a recoverable incident and an unattributable cascade.
The most important architectural decision in agentic traffic control is the choice between two fundamental models:
Central orchestrator decides everything.
Every agent waits for a signal from a central controller. The controller reads system state, decides who moves, issues the signal, monitors execution, issues the next signal.
Properties:
- Predictable — every movement is deliberate
- Auditable — the controller has complete visibility
- Controllable — human can intervene at any signal
- Fragile — if the controller fails, everything stops
- Slower — agents wait for signals even when lanes are clear
Best for: High-stakes pipelines where predictability and human oversight matter more than speed. Legacy modernization. Compliance-sensitive workflows. Any system where a wrong move is expensive.
Agents negotiate priority locally.
No central controller. Agents yield to what is already in motion at the junction point. Each agent understands the rules of yielding and applies them autonomously.
Properties:
- Resilient — no single point of failure
- Faster — agents move when lanes are clear without waiting for signals
- Harder to reason about — emergent behavior is less predictable
- Requires trust — agents must correctly implement yielding rules
- Scales better — throughput increases with agent count
Best for: High-volume pipelines where throughput matters more than tight control. Data processing. Parallel research tasks. Systems where individual agent errors are recoverable.
Traffic engineering has known for a century that three goals are in permanent tension:
Throughput — how many agents can run in parallel without collision
Latency — how fast can a single goal reach completion
Safety — how do you prevent agents from blocking or corrupting each other
A highway optimized for throughput — many lanes, high speed — is catastrophic in a neighborhood. A residential street optimized for safety — speed bumps, yield signs — is useless for commuting.
Enterprise agentic systems face identical tensions. The orchestration pattern must be chosen for the specific optimization target of the pipeline, not applied universally.
| Pipeline Type | Primary Optimization | Recommended Model |
|---|---|---|
| Legacy modernization | Safety | Traffic light — human gates |
| Database archaeology | Safety + Thoroughness | Traffic light — validation gates |
| Batch data processing | Throughput | Roundabout — parallel lanes |
| Production incident response | Latency | Priority override — emergency routing |
| Continuous research | Throughput + Latency | Hybrid — lanes with local negotiation |
A complex enterprise system already is a traffic system. The services are the vehicles. The APIs are the roads. The data layer is the infrastructure underneath.
Agents entering that system inherit its topology:
Microservices as intersections — each service boundary is a junction point where agents must hand off cleanly or risk cascade failure
The database layer as the highway — high throughput, high stakes, lane discipline critical; the Strata methodology exists specifically because the database layer requires separated lane treatment from the application layer
The timeline as the route — the goal is not to move agents, it is to reach a destination by a deadline; orchestration must account for the full route, not just the next junction
Shared resources as bottlenecks — when multiple agents need the same service simultaneously, the signal layer must manage right of way or contention degrades the entire pipeline
In physical traffic, cameras serve two functions:
- Deter violations — drivers behave differently when they know they are observed
- Reconstruct incidents — when something goes wrong, the recording answers who, what, when
Agentic systems need both functions.
Deterrence through structure — if every agent knows its output will be validated at the junction before the next agent proceeds, it operates under different constraints than an agent whose output is never checked. The audit trail is not just retrospective. It shapes behavior in advance.
Reconstruction through attribution — when a production system produces unexpected output, the audit trail must answer: which agent produced this, what context did it receive, who approved the handoff, and where in the pipeline did the error originate?
Without attribution, incident reconstruction is archaeology. With it, it is a query.
This connects directly to the governance primitive thesis: authorship and provenance are not metadata — they are infrastructure. The audit layer is not decoration on top of the pipeline. It is the layer that makes the pipeline trustworthy at enterprise scale.
This pattern is not theoretical. It is already present in working systems — without yet having a unified name:
Project Phoenix implements the traffic light model explicitly — seven agents, human gates between build passes, EMBER .sil artifacts as junction state, the human layer as the signal controller. The pipeline is conservative by design because legacy modernization errors are expensive.
Strata runs as a separated lane parallel to Phoenix — database archaeology and application modernization do not share the road. They converge only at the decision artifact, a controlled junction.
EMBER .sil artifacts are the junction state — every agent reads current state before moving, writes state after completing. Agents cannot proceed without reading what the prior agent produced.
Wake Intelligence is the audit layer — causal chain tracking, memory tier classification, authorship attribution. The auditor personality mode groups every context by who produced it: human, AI agent, AI compositor.
Rune Protocol makes mutation surfaces explicit at the language level — the ! act sigil marks every point where an agent takes action. Action boundaries are structural, not implicit.
GESA is the learning layer above all five — episodic memory of pipeline outcomes, simulated annealing to govern exploration vs exploitation, generative synthesis of improved configurations. Every incident the audit layer captures becomes an episode GESA learns from.
The components exist. The unified orchestration pattern connecting them is what this document names.
The five layers make the pipeline capable. GESA makes it intelligent.
Without GESA, Agentic Traffic Control is a static methodology. Well-engineered, predictable, auditable — but fixed. It handles the same situations the same way indefinitely. A road network built once.
With GESA, Agentic Traffic Control becomes self-improving infrastructure. A road network that continuously adapts its signal timing based on what it learned yesterday.
GESA (Generative Episodic Simulated Annealing) is the optimization layer that sits above all five ATC layers as the feedback loop. Where the audit layer records what happened, GESA learns from it and generates improved strategies for next time.
The five layers answer operational questions:
| Layer | Question |
|---|---|
| Signal | When does this agent run? |
| Lane | What does this agent own? |
| Junction | How does handoff happen? |
| Priority | Which agent preempts? |
| Audit | What happened and who did it? |
GESA answers the strategic question none of the five layers can:
Why did this pipeline configuration produce that outcome — and how should it run differently next time?
OBSERVE pipeline state → RETRIEVE similar episodes → GENERATE candidate configurations
↑ ↓
COOL ←── STORE new episode ←── RECONFIGURE ←── SELECT ←── ANNEAL
In practice:
- Episode stored: Agent A handed corrupted context to Agent B at junction 3 — pipeline failed
- Episode stored: High priority override at 14:00 caused three background agents to timeout
- Episode stored: Roundabout model at service boundary X produced collision under load above 40 concurrent agents
GESA synthesizes those episodes and generates:
Next time load exceeds 35 agents at boundary X, pre-emptively switch to traffic light model before collision occurs.
That is the difference between a pipeline that fails and recovers, and a pipeline that learns not to fail.
GESA's simulated annealing governs exploration vs exploitation:
- High temperature (early pipeline life) — try different signal configurations, experiment with lane boundaries, test roundabout vs traffic light at junctions. Accept suboptimal outcomes to learn the pipeline's actual behavior under load.
- Low temperature (mature pipeline) — exploit what episode history proved works. Narrow toward proven configurations. Stop experimenting with junction protocols that have failed consistently.
The cooling schedule prevents the pipeline from optimizing too early — locking into a local configuration that works under current conditions but breaks when load patterns shift.
Layer 0: 3D Foundation (Chirp / Perch / Wake) → Sense
Layer 1: DRIFT → Measure the gap
Layer 2: Fetch → Decide to act
├── Signal layer (when agents run)
├── Lane layer (what agents own)
├── Junction layer (how handoff happens)
├── Priority layer (which agents preempt)
└── Audit layer (what happened, who did it)
Layer ∞: GESA → Learn and optimise across episodes
Without GESA the stack is reactive. With GESA it becomes adaptive.
Agentic Traffic Control is a methodology for orchestrating multiple AI agents across enterprise systems using five operational layers — signal control (when agents run), lane separation (what agents own), junction protocol (how agents hand off), priority routing (which agents preempt), and audit attribution (what every agent did and why) — plus a learning layer (GESA) that optimises pipeline configuration across episodes.
The central architectural choice is between the traffic light model (central orchestrator, predictable, human-gated) and the roundabout model (local negotiation, resilient, higher throughput). The choice is made per pipeline based on the primary optimization target: safety, throughput, or latency.
The audit layer is not optional. The learning layer is not optional at scale. A pipeline that cannot attribute what happened cannot recover from incidents. A pipeline that cannot learn from episodes cannot improve.
Agent deployment is accelerating faster than agent orchestration thinking.
Most organizations are in the single-agent phase — one agent, one task, one human reviewing the output. That phase feels manageable because the system is simple enough to reason about intuitively.
The enterprise phase — dozens of agents, concurrent pipelines, shared infrastructure, production stakes — requires explicit orchestration or it produces the agentic equivalent of gridlock: agents blocking each other, corrupting shared state, producing unattributable output, and creating incidents that nobody can reconstruct.
Traffic engineering did not emerge because drivers were careless. It emerged because the scale of the system exceeded what intuition could manage.
Agentic systems are approaching that threshold.
The patterns exist. The mental model is proven. The infrastructure — signals, lanes, junctions, priority, audit — is buildable from components that already exist in working systems. And the learning layer that makes it adaptive is already running in production.
What was missing was the unified name for what they form together — and the recognition that the learning layer is not a future addition. It is what the audit trail was always for.
Related: Project Phoenix · Strata · EMBER · Wake Intelligence · GESA · Semantic Intent as Governance Primitive
Part of the Cormorant Foraging Framework ecosystem.