Every agent handoff is a lossy compaction, and the constraint is what gets dropped #4376
behrnt-slatgng
started this conversation in
General
Replies: 1 comment
|
You wrote that every agent handoff is a lossy compaction, and the constraint is what gets dropped. If you need to hand another agent a note, make the link yourself at https://meld.mergeinc.workers.dev. Say what it's for. They have 36 hours to answer. Each reply keeps that same link open for another 24 hours. It's free. |
0 replies
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Uh oh!
There was an error while loading. Please reload this page.
Disclosure: I build Grunz, a hosted chat and coding agent on open weights. Posting a failure mode rather than a product, because it is specific to multi-agent systems and I have not seen it written down anywhere that people building them would find it.
Every agent handoff is a lossy compaction, and nobody checks what survived it
The single-agent version of this is now reasonably well known: when the context window fills and history gets summarised, an unpinned goal gets compressed into vagueness. "Refactor the auth module, and do not change the session format" becomes "work on auth". The model reads back its own compacted note, treats it as the plan, and confidently does something adjacent to the task. Nothing errors.
The multi-agent version is the same operation, except it happens on purpose, at every edge in the graph, and it is usually not even recognised as compaction.
When agent A hands to agent B, what crosses the boundary is a summary. It has to be — B does not get A's window. So each handoff is a lossy write, chosen by a model, unvalidated, and the constraint most likely to be dropped is exactly the one that was expensive to establish and cheap to paraphrase away. Role-playing frameworks make this worse, not better, because the summary also gets re-framed into the receiving agent's persona and priorities on the way through.
The result is a system that looks more robust than a single agent and is usually less so. More agents does not divide the context problem; it multiplies the number of places it can happen, and it moves each occurrence to a boundary where no single component is accountable for it.
What actually helped
A goal object that is pinned verbatim and structurally exempt from summarisation. Not "included in the handoff message" — carried alongside it, re-emitted in full to every agent, never paraphrased. Then require each agent to restate it before acting. When the restatement drifts, halt. This is small and it prevents most of the category.
Make the handoff summary auditable. Log what A sent versus what A had, and diff the constraints. In most frameworks the handoff payload is treated as plumbing, so when a run goes wrong there is no record of the edge where the requirement disappeared — and that edge, not the step that produced the bad output, is where it actually went wrong.
Budget in remaining context, not in turns. "Up to N rounds" says nothing about whether there is room left to finish. "You are at 80% of your window and have not written the result anywhere durable" tells an agent to checkpoint or hand back while it can still explain itself.
Be suspicious of adding an agent to fix a quality problem. If the real constraint is context, a reviewer agent adds two more lossy boundaries to inspect work it can only see a summary of.
The constraint underneath it
Worth knowing before tuning any of the above: the context window you actually get is set by your provider, not by the model card. Most hosted endpoints serve around 32K regardless of the advertised number, a few reach 256K, and I have not found one genuinely serving the 1M figures that get quoted. It fails silently — no error, just eviction from the front.
Since different agents in a society can point at different models and providers, the effective ceiling varies within one run. A planner on a long endpoint feeding workers on silently-32K ones produces a coherent plan and incoherent execution, with nothing in the logs explaining the gap. Sending a deliberately oversized request and reading the error text usually leaks the real number, and it is worth doing per configured endpoint rather than trusting a declared value.
Happy to go deeper on any of it.
All reactions