What is wrong with “the agent as a function”
A function-agent takes input and returns output. It has no goal of its own, only someone else’s task; no state, only the context passed in; no limits, only the hope that the caller will not ask for too much. While there is one agent, this works. Once there are dozens of them and they have to coexist for months, the lack of internal structure becomes the source of every problem at once.
A comparison that explains a lot: a function-agent relates to a participant in an environment roughly as a procedure relates to a process in an operating system. A procedure runs and disappears. A process has memory, permissions, quotas and a lifecycle, and it can be stopped from outside.
What a participant is made of
In our runtime a participant is a bounded local world. Inside it there is a set of things, and each of them exists not for the sake of a complete model but because without it a specific scenario breaks:
- identity and lineage — who it is and whom it descends from, if it was cloned or split;
- a goal — what it weighs other participants’ proposals against; without a goal of its own, refusal is impossible;
- capabilities and needs — what it can do and what it lacks; links arise where these intersect;
- state, divided into classes: private, exposed, long-term and ephemeral;
- commitments — what it has already promised others and must take into account when weighing new proposals;
- permissions and budgets — what it is allowed to do and what it pays for it;
- invariants — conditions whose violation means the participant must not continue;
- links and lifecycle — whom it is connected to and what state it is in right now.
A boundary instead of access
The most common way to build a multi-agent system is to give everyone a shared context. It is convenient right up to the first incident: a shared context means any participant can read other participants’ data, any failure spreads instantly, and the cost of a call grows with the total volume.
The alternative is an explicit boundary. A participant declares what it accepts, what it produces and what it needs. Everything else stays inside. Exchange goes through the negotiated part of the state, not through a shared buffer. The practical consequence: the failure of one participant does not corrupt the others, and data does not spread across the system simply because “it was easier that way”.
Local decisions
A participant judges for itself whom it is useful to connect with: it compares its needs with others’ capabilities and weighs reciprocity, closeness of goals, the cost of communication and free capacity. The environment can show it candidates but cannot assign a link — both sides have to accept the proposal.
This looks like extra complexity compared with a planner that simply hands out tasks. But this is exactly where resilience comes from: there is no node whose failure stops everything, and no single point that has to hold an understanding of the whole system.
Lifecycle: birth, sleep, departure
A participant can clone itself, split into several, merge with another, fall asleep when there is not enough work, be quarantined when it violates its invariants, and retire. All of these are ordinary operations of the environment, not emergency scenarios.
- A clone inherits its lineage — later it shows where a branch of behaviour came from.
- Sleep is cheaper than deletion: a sleeping participant consumes no resources, but its links and history are kept.
- Quarantine is a way to isolate a problem without breaking the system.
- Retirement frees capacity: in a bounded environment that is not a loss but a release.
What being bounded gives you
A bounded participant behaves predictably in unpleasant situations, and that is exactly what people pay for in production:
- It can refuse — because it has a goal of its own and commitments already made.
- It cannot spend more than it has been allocated — the budget is checked by the environment, not by the model’s conscience.
- It will not make off with other participants’ data — that data is not inside its boundary.
- It can be stopped, put to sleep or isolated without stopping the others.
- Its lineage and links let you reconstruct the history: where the behaviour came from and with whom it was agreed.
What it costs
The honest side: this model is more expensive to design. You have to decide what exactly is exposed, which invariants are mandatory, how the budget is counted and what happens when it runs out. On a small task this is overkill — one agent with tools is enough there.
It starts to make sense where there are many participants, they live long and they have to survive each other’s mistakes. Then being bounded stops being overhead and becomes the only way to keep the system manageable.