If you're curious on what I'm building, not what I'm thinking PLEASE check out Warren. This is what I'm most excited about. Started it last weekend, and it's pretty incredible.

The default pattern I've seen in multi-agent systems for the past two years has been a hierarchy. A lead orchestrator agent at the top, delegating to sub-agents, sometimes delegating further down. I built this out ad nauseam in Overstory, increasing the abstraction between the human and the code-implementation agents to 3-4 layers.

Overstory has proven to be incredibly effective at coordinating huge amounts of compute. But I no longer feel that a hierarchical system is the best path forward in agentic engineering.

Here's the problem. Inter-agent communication is lossy. Every layer of delegation is a translation. The orchestrator interprets user intent, decomposes it, passes a degraded version to a sub-agent, who decomposes it again and passes a further degraded version to a worker. By the time actual work happens, you're three translations away from what the human actually wanted.

Instead, I'm beginning to view the human as a node within a graph. A heavily weighted node, mind you, but a node nonetheless. Surrounded by agent nodes. All nodes are operating overtop the same context substrate. Every agent has high intelligence (using frontier models) and access to the same context as one another. At any point, an agent can coordinate with the human node's artifacts to better understand user intent.

Inter-agent coordination still happens. There's still work being passed between agents, often with the human coordinating exchanges of work. The goal is that instead of 50+ agents operating in a hierarchy where the 3rd layer has had user intent distilled and mutated by two other layers, agents can just go straight to the source.

The obvious downfall here is scaling. A human can't cognitively manage getting pinged by 50+ agents at a time. That won't work. But the goal is to have intent and context distilled correctly up front so that agents won't need to be pinging the human constantly. The human produces artifacts explaining their intent, and the network begins operating around that.

Crucially, the agent nodes are also leaving artifacts wherever they go. The codebase itself becomes part of the context substrate. Documentation, external communication, user intent, all are aspects of the substrate which all agents have access to. The longer the network runs, the richer the substrate becomes.

This idea is still taking shape. I don't have a full picture of what the UI for a human-as-node system looks like, or what the right primitives are. I suspect there will be plenty of UIs built to try and address this. I'm building one out with Warren, and the best OSS example I've seen is Multica. What I do think is that the tooling that wins won't be the tooling that makes the orchestrator smarter. It'll be the tooling that keeps the human close while continuing to self-improve.