and the solutions hiding in plain sight
You deploy 12 agents on a production task. Three duplicate work. Two conflict. One loops forever.
The coordination cost is unknowable before you try and it might exceed the work done...
can you verify a solution faster than you can find one?
Optimal task routing is NP-hard in disguise: assigning the right agent requires knowing what you're assigning before you've assigned it. Every orchestration system hits this wall. The field's open question is whether good-enough heuristics exist — or whether the search space is irreducibly hard.
let's map the territory
Current agent orchestration fails because it treats a complex adaptive system as a linear pipeline. These problems are not independent bugs — they are emergent properties of the wrong metaphor.
Every solution creates the next problem.
Prompt in, completion out. Reasoning is hidden, compressed, or hallucinated-after-the-fact. Expressiveness at the cost of interpretability — compounding at every scale.
Wrap the black box in a framework. Add tools, memory, planning loops. Now it's a monolithic agent system — one large opaque process.
Deploy multiple monoliths. Orchestrate them. Distributed opacity. The causal graph is a hairball — each node itself opaque.
These problems share a root: wrong metaphor, wrong architecture.
Agents operate at different timescales. Planning is slow and deliberative. Execution is fast and procedural. Feedback arrives delayed and partial.
Pipeline orchestration forces synchronous handoffs between asynchronous processes. The planner waits. The executor can't adapt mid-stride.
Most frameworks enforce a single clock. But intelligent systems are polychronic — they run many clocks simultaneously.
Context windows as commons. File locks without territory. Agent A reads, Agent B mutates, Agent A acts on stale state. Not a queuing problem — a territorial problem.
Solution space grows exponentially. The path that looks best at step 3 dead-ends at step 30. Tree search is too expensive, greedy too myopic, random too wasteful.
Which agent handles it? Optimal assignment requires knowing what you're assigning before you've assigned it — NP-hard in disguise.
You build pipelines, guardrails, and kill switches. Control flows unidirectionally.
You build niches, feedback loops, and adaptive boundaries. Coordination is mutual.
Bad metaphors produce bad systems.
The field needs better metaphors before it needs better code.
Every negative prompt contains the thing it forbids. Control and danger travel in the same channel. The harness is self-defeating.
Attempt → fail → retry same approach → burn tokens with no forward progress. Evolution doesn't loop — it ratchets. Each cycle preserves what was learned.
Per-agent: context overflows, skills multiply, memory is unstructured. The agent spends more cycles managing itself than working.
Inter-agent: inert, reactive components. Coordination grows O(n²). Brooks's Law, generalized.
The model's output becomes its own input. Not retry — recursive self-modification. Each cycle's delta is the ratchet tooth. Compress what was learned, carry forward only the change log. Coordination that scales O(log n), not O(n²).
ComfyUI, LangGraph, n8n. Flat graphs — one level of abstraction. 200 nodes = spaghetti.
Grafana, LangSmith. Retrospective, not predictive. By the time you see it, it already happened.
One per agent. Human becomes the orchestrator — the most expensive, slowest component.
All three represent the system from outside it.
Not a map of the territory — a map that is the territory. Simulation with sufficient fidelity is implementation.
The tools failed because the metaphor failed. We need a new vocabulary.
A vocabulary drawn from complexity theory, network science, and evolutionary ecology — fields that already solve coordination at scale.
The coordination pattern that works for 3 agents should work for 30 and for 300.
Every network has a hidden metric space. Clustering maps to curvature — dense regions curve like spheres, sparse branches like hyperboloids. Nodes greedily route by minimizing hidden distance at each hop. The graph is the landscape.
Boguñá, Krioukov & Claffy (2008); Eckmann & Moses (2002); Hanacek (2016)
The landscape shifts as agents traverse it. Agent A's actions change Agent B's terrain. Co-evolutionary dynamics.
Instead of specifying exact agent behavior (brittle), define the attractor basin — the set of acceptable states. Agents self-organize toward coherent behavior without centralized control.
Competitive exclusion (Gause, 1934): two species competing for the exact same niche cannot coexist. One will outcompete the other.
If you deploy two agents with overlapping capabilities, they will compete. The solution is niche differentiation.
Ants find the shortest path not by mapping terrain, but by leaving pheromone traces. Bad paths fade. Good paths get reinforced. Coordination through environmental signals.
Problems on the left, solutions on the right. Recursion terminates not by depth but by fitness. The presentation is the navigable system it describes.
Not duplication but endless mappings. The same data — seen differently. A gesture draws a new view. A name creates a new lens.
No-Mode
Context determines action. The tool is the gesture, not a menu.
Composable
Simple things combine into complex things. Named compositions become building blocks.
Queryable
Everything is connected, searchable, meaningful. Ask the system about itself.
The vocabulary exists. The patterns work. So why aren't today's tools using them?
Each turn isn't repetition — it's recursion. "I am learning that I am learning" has unbounded depth. The agent IS the loop.
Zoom is semantic
Each level reveals structure, not just bigger pixels.
The representation runs
A live simulation, not a static diagram. Agents are visible.
Self-description
The system visualizes itself using the same structures it operates with.
This presentation is itself a navigable concept space — an ecosystem of prose describing an ecosystem of prose.
The CS primitives already exist: recursion, delta encoding, grep, AST parsing, git history. The filesystem ships exact, instant, free affordances.
The ecosystem isn't a hierarchy you browse — it's a landscape you inhabit.
“The solution to agent orchestration is not a better harness.
It's a better habitat.”
the ecosystem is the interface
The session is the runtime. The .prose program runs inside the agent.
Each pass carries forward compressed learning. Not retry — recursive self-modification.
We host the habitat. You own the organism.
Interfaces. Resources in, outputs out. Roots = persistent state.
Message-passing agents. They connect the workers.
Selection pressure. Remove the redundant. Enforce quality.
Recycle spent context. Return resources to the soil.
Logging, monitoring, heartbeats. Invisible, essential.
The agent whose removal collapses the system. Protect it.
These roles aren't assigned — they're discovered. An organism finds its niche.