What is lost when the link is not an object
If an interaction comes down to a call, it has no memory. Every exchange starts from zero: who may do what, which context is needed, whether this pair works at all, everything is found out again. The system builds up no knowledge of its own structure.
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, so edits do not conflict;
- 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 by agreement between the parties; the environment cannot create it by order. 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 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 and not in someone’s memory. Revising the terms goes through the same mechanism: renegotiating a link means taking the same path as concluding it.
Adapting to observed usefulness
The terms of exchange are not permanent. 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 sounds like a biological metaphor, but the point is an engineering one. In a bounded environment, keeping a link alive costs resources, and weakening what is useless automatically keeps them from being spent on structure that no longer gives anything. Without such a mechanism a 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 goes on, but its volume is limited while reliability builds up. The link becomes a full one only after its usefulness is confirmed.
We apply the same principle to agent autonomy in applied systems: rights expand on accumulated statistics and are not granted in advance. The difference is that here the principle is built into the environment itself and does not depend on 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.
- The design itself rules out conflicting edits; developers do not need an agreement for that.
- Ending a relationship becomes a routine operation. No code has to be deleted for it.
- The history of agreements replaces word-of-mouth knowledge of why everything works the way it does.
- The cost of maintaining the structure is visible, and it can be managed.
There is a limitation too. All of this is justified where relationships are numerous and long-lived. For a pair of components that exchange messages twice an hour, an ordinary queue is simpler and cheaper.