Agent Orchestration Without Internal Representation
How stigmergy could drive coordination through the environment.
Present-day Agent Frameworks, whether based on a rigid state graph (LangChain) or a flexible group chat (AutoGen), share a universal truth: agents are constrained processing units that transform input representations into output representations. Representation is a common phenomenon, whether pooled in a central database or routed through distributed service queues.
Subsumption Architecture
Inspired by Rodney A Brooks’ influential 1991 paper “Intelligence without Representation” [1], I argue that today’s agent frameworks like LangGraph and AutoGen repeat a similar misstep made by the classical AI community decades ago: they decompose systems into functional modules (perception, planning, execution) bound to an explicit textual representation.
In his paper, Brooks argues that Classical AI researchers decomposed an intelligent system into individual information-processing units, each building its own world model (representation) and exchanging representations with one another. Modern agent frameworks, LangGraph and AutoGen, have adopted a similar approach: they force every agent to generate a text representation, read another agent's representation, and reason over it. This creates an architectural bottleneck in which agents are treated as finite-state machines with a beginning and an end, tightly coupled to one another through generating, parsing, and exchanging world models (the chat history or state), rather than interacting with the actual environment.
As an alternative, Rodney proposes a “Subsumption Architecture”: “the intelligent system is decomposed into independent and parallel activity producers that interface directly with the world through perception and action, rather than interface to each other particularly much.”[1]
With this in mind, the goal of this series is to build a new agent framework using Brooks’ “Subsumption Architecture” as a blueprint. In this model, each agent acts as a parallel activity producer, operating on a shared substrate instead of communicating directly with other agents. Each agent would form a tight, reactive loop, converting input directly into action and modifying the shared substrate. Other agents could then observe and act on the new world state independently, avoiding an intermediate “thinking” layer. By doing this, we are eliminating internal, siloed representation and message-passing between agents.
The fundamental idea of Brooks’ Subsumption Architecture is the decomposition of task-achieving behaviors into layers. Each layer is combined with other layers, in which an upper layer can suppress or inhibit a lower layer. My observation is that this could lead to a factorial expansion of layer combinations and is practically unscalable. And Brooks’ paper itself states that the highest number of layers they achieved was 3 in the physical experiment and 6 in simulation, with the rest slated for future work.
Brooks solves the representation problem but introduces the wiring problem, and directed graphs solve the wiring problem but reintroduce the representation problem; neither scalable nor practical for AI Agents.
This is where I look to Heylighen’s Stigmergy to implement Brooks’ “Intelligence without Representation” [1], at scale for AI Agents.
Stigmergy as a coordination mechanism
As defined by Francis Heylighen, “Stigmergy is an indirect, mediated mechanism of coordination between actions, in which the trace of an action left on a medium stimulates the performance of a subsequent action.” [2]
Stigmergy enables complex, coordinated activity without any need for planning, control, communication, simultaneous presence, or mutual awareness. Mediation via the environment ensures that tasks are executed in the correct order, without the need for planning, control, or direct interaction between agents.
Applying stigmergy to the agentic paradigm is not a brand-new concept. According to Heylighen, it is already being used in the fields of computer simulation and swarm intelligence, to solve the notorious traveling salesman problem, and in communications networks for optimal packet routing. [2]
The stigmergic process can be imagined as a feedback loop in which an agent leaves a trace that, in turn, leads to subsequent actions. This mechanism is not limited to coordinating actions performed by a swarm of agents but also fits well for coordinating multiple actions performed by a single agent.
This concept of Stigmergy, applied to AI Agents, solves the biggest bottleneck in Brooks’ “Subsumption Architecture,” which required combining layers through suppressive and inhibitive mechanisms. Stigmergy negates that requirement by having agents communicate solely through a common substrate, without awareness of one another or of the need to coordinate or interface. Because agents hold no state, the shared substrate instead serves as the physical environment on which they leave traces and to which they react.
Coordination through stigmergy requires an environment that can durably record traces without being corrupted by competing agents. Omnigraph fits this perfectly, as I have argued in detail in my previous article, not just because it is a graph database, but because its Git-style branching and versioning act as an immutable log of concurrent agent traces.
Conclusion
A directed graph with an internal representation is the wrong model for agentic orchestration. Brooks established why representation fails, and Heylighen showed how coherent coordination can be achieved without needing planning, control, mutual communication, or awareness. The intellectual case is made.
But an intellectual case is not a framework. In the next installment, I will propose an architecture and an agent framework with Omnigraph as the substrate, without a central planner, a shared representation, a directed graph, or direct message-passing among agents.
This framework does raise a few hard questions that I don’t yet have answers to.
Does stigmergic coordination always lead to the right answer, or just an answer? What are the failure modes?
LangGraph failures are visible and debuggable. How does one debug traces left by contradicting and competing agents?
Does Stigmergy assume a level of homogeneity that probabilistic language models powering AI agents, with baked-in biases and failure modes, cannot guarantee?
These are the questions that the implementation phase will have to answer.
References
[1] Brooks, R.A. (1991). Intelligence Without Representation. Artificial Intelligence, 47(1-3), 139-159.
[2] Heylighen, F. (2016). Stigmergy as a Universal Coordination Mechanism I: Definition and Components. Cognitive Systems Research, 38, 4-13.