What is lost when the link is not an object
If an interaction is just a call, it has no memory. Every exchange starts from zero: who may do what is decided again, the context is passed again, whether this pair of participants works at all is found out again. The system accumulates no knowledge of its own structure — it works it out afresh every time.
A relationship as an object holds that knowledge: what the parties have agreed, how often it pays for them to communicate, what has already been passed on, how reliable the link is and whether it is worth keeping up.
What a link contains
- the shared state of the boundary — the part of the data that both sides see;
- field ownership: who has the right to change which part of the shared state;
- alternating rights: the next revision is committed by one side, and that rules out conflicting edits;
- atomic revisions and evidence — a history of changes from which any state can be reconstructed;
- agreed protocol terms: frequency, volume, mode of exchange;
- activity and synchronisation metrics;
- the strength of the link and its decay;
- lifecycle state: probation, activity, sleep, retirement.
Negotiation instead of assignment
A link comes into being not by order of the environment but by agreement between the parties. The initiator proposes terms; the other side accepts, rejects, defers or makes a counter-offer — and then the roles swap. The result is an alternating negotiation protocol with a stored transcript.
The practical value of the transcript shows up later: when you need to understand why two participants work the way they do, the answer is in the history of their agreements, not in someone’s memory. Revising the terms goes through the same mechanism: renegotiating an agreement is the same primitive as concluding one.
Adapting to observed usefulness
The terms of exchange do not stay fixed forever. If a link brings little benefit, the parties lower the frequency and volume of exchange; if it brings a lot, they raise them. A link that has stopped being useful first weakens, then falls asleep, then retires.
It looks like a biological metaphor, but the point is purely an engineering one: in a constrained environment, keeping a link alive costs resources. Automatically weakening what is useless is a way not to spend them on structure that no longer gives anything. Without such a mechanism, any long-lived system accumulates links that nobody dares to delete.
Probation
A new link does not get full rights at once. It starts on probation: exchange happens, but its volume is limited while reliability builds up. Only once its usefulness is confirmed does the link become a full one.
We apply the same principle to agent autonomy in applied systems: rights expand on accumulated statistics rather than being granted in advance. The only difference is that here it is implemented at the level of the environment, not as the policy of a particular project.
What this gives the system as a whole
- The system’s structure becomes observable: links can be listed, measured and explained.
- Conflicting edits are ruled out by construction, not by an agreement between developers.
- Ending a relationship is a routine operation, not a code deletion.
- The history of agreements replaces word-of-mouth knowledge of “why it works this way”.
- The cost of maintaining the structure is visible and manageable.
The limitation is worth naming honestly as well: all of this is justified where relationships are long-lived and numerous. For a pair of components exchanging messages twice an hour, an ordinary queue is simpler and cheaper.