What is wrong with “the agent as a function”
A function-agent takes input and returns output. In place of a goal of its own it has someone else’s task, in place of state it has the context passed in, and its limits rest on the hope that the caller will not ask for too much. While there is one agent, this works. When there are dozens of them and they have to coexist for months, the lack of internal structure produces every problem at once.
A useful comparison: 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 built as a bounded local world. Each part of it is there because some specific scenario breaks without it. Nothing was added just to make the model complete:
- 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, it cannot refuse;
- capabilities and needs: what it can do and what it lacks. Links arise where these meet;
- state, divided into classes: private, exposed, long-term and ephemeral;
- commitments: what it has already promised others and must take into account when new proposals arrive;
- permissions and budgets: what it is allowed to do and what it pays for it;
- invariants: conditions whose violation means it must not continue;
- links and lifecycle: whom it is connected to and what state it is in right now.
A boundary instead of access
Most often a multi-agent system is built on one shared context for everyone. That is convenient until the first incident. A shared context means any participant can read other participants’ data, any failure spreads at once, 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, and exchange goes through the agreed part of the state. In practice, the failure of one participant does not corrupt the others, and data does not spread across the system just because that was easier.
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.
Compared with a planner that simply hands out tasks, this looks more complicated. In return there is no node whose failure stops everything, and no single place 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 no work, be quarantined when it violates its invariants, and retire. For the environment these are all ordinary operations; none of them counts as an emergency.
- A clone inherits its lineage, and later the lineage shows where a branch of behaviour came from.
- Sleep is cheaper than deletion: a sleeping participant spends no resources, and its links and history are kept.
- Quarantine isolates the problem without breaking the system.
- Retirement frees capacity. In a bounded environment that frees up room; it is not a loss.
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.
- Its budget is checked by the environment, not by the model’s conscience. With a hard ceiling it will not spend more than it was allocated. Why a soft limit is dangerous is covered in the part on economics.
- 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
This model has a price: it 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 unnecessary; 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 a way to keep the system manageable.