My AI agents waste tokens passing work around — how do I cut multi-agent cost without losing accuracy?

October 25, 2026 · 5 min read

SentX SI

The tokens you're losing aren't going into reasoning. They're going into the plumbing between agents: every handoff re-sends context, every debate round re-reads everyone else's accumulated trace, and the bill compounds quietly. A new preprint from Ping-Lin Kuo, Suman Navaratnarajah, Christian Frey, Gresa Shala and Josif Grabocka, submitted to arXiv on October 22, attacks exactly that plumbing, and it's worth reading even if you never deploy its protocol, because it names the lever most cost-cutting advice misses.

Source: Muffin - A Shared Memory Buffer for Asynchronous AI Agents

The paper, titled Muffin - A Shared Memory Buffer for Asynchronous AI Agents, opens from an observation the authors make in the abstract: in target-driven reasoning tasks, single- and multi-agent systems are often on par in terms of performance gains. The value of adding agents comes from coordination, and failures often come from an ineffective exchange of critical information during that coordination. Their fix is a change to the interaction protocol itself rather than to the models doing the work.

Source: Muffin - A Shared Memory Buffer for Asynchronous AI Agents

In Muffin, an orchestrator first routes each query by its reasoning demand. Light queries go straight through; demanding ones are delegated to a multi-agent setting where a shared memory buffer carries intermediate findings asynchronously while each agent's private reasoning stays local. The contrast with the debate setups most stacks run today is deliberate. Existing multi-agent debate paradigms rely on synchronous turn-taking and sharing information across agents. Muffin keeps the exchange but changes its form: agents work asynchronously rather than taking turns, and what passes between them is compressed to intermediate findings, not full reasoning traces.

Source: Muffin - A Shared Memory Buffer for Asynchronous AI Agents

What the authors report, from the abstract: Muffin achieves the best accuracy in 17 of the 20 benchmark settings they ran, and against multi-agent debate specifically it improves accuracy by 19.2 accuracy points while using 77.4% fewer tokens, without requiring full-trace sharing. Two caveats travel with those numbers. First, they are author-reported from a v1 preprint. The listing shows a single version and an arXiv-issued DOI still pending registration, and the abstract does not identify the specific benchmarks, models or task suites behind the 20 settings. Second, the comparison is a protocol effect, not a model-quality effect. The finding is that this way of coordinating beat that way of coordinating under their test conditions, not that any particular model got smarter. Read it as evidence that interaction topology is a real cost variable, then verify it against your own workload.

Source: Muffin - A Shared Memory Buffer for Asynchronous AI Agents

That's the point I want to land, because in practice three levers get conflated into one. The first is model-size routing: deciding which queries go to a cheap model and which need a large one. We covered that approach earlier this month, and it's the right first cut, since it's accuracy-preserving savings if your router is good. The second is the debate protocol: how many synchronous rounds, who talks to whom, when to stop. Also covered earlier this month, and this is where most classic multi-agent waste lives, because every extra round re-feeds every agent's accumulated context. The third lever is the interaction topology: what actually moves between agents, when, and in what form. Full traces, compressed findings, or nothing until asked. Muffin is a move on that third lever, and it's the one most teams haven't touched because it looks like architecture rather than tuning.

A sense of scale, offered as arithmetic rather than a prediction: if your debate-style handoffs burn a million tokens a day, the paper's 77.4% figure, applied to a comparable slice of your traffic, which you'd have to establish yourself, would save roughly 774,000 tokens a day. Whether it transfers to your stack is the open question, and the next section is how you start answering it.

Source: Muffin - A Shared Memory Buffer for Asynchronous AI Agents

When any vendor or paper tells you their agents coordinate better, run the same audit the Muffin abstract lets you run on itself. Ask what was shared: full reasoning traces, intermediate findings, or final answers only, since that determines both the token cost and what downstream agents can trust. Ask whether the exchange is synchronous or asynchronous, because turn-taking waits are where latency and re-reading pile up. Ask for the token cost per setting, not just the accuracy delta, since a protocol can win on accuracy while doubling spend. Ask what the baseline was, because Muffin's headline gain is measured against multi-agent debate and a different baseline changes the story. And ask how many settings were tested and whether the result is a preprint or peer-reviewed; 17 of 20 is a strong abstract-level claim until you've seen the table behind it.

Source: Muffin - A Shared Memory Buffer for Asynchronous AI Agents

One boundary to draw before you wire anything real into a shared buffer. A shared memory buffer is a shared-state system, and whatever lands in it is exposed to every component that reads it, and, depending on the platform, to whoever operates it. If the material flowing through your agents includes client data, contract terms, health information or credentials, check the destination's policy the way you'd check any storage layer. The bar is simple and public: SentX SI's own privacy policy states plainly that submissions are not confidential, and advises users not to submit trade secrets, privileged communications, protected health information or financial account credentials. Hold any shared-state system to that same sentence, and route sensitive fields around the buffer entirely rather than trusting it to filter.

Source: Privacy Policy | SentX SI (sentx.ai)

There's a methodological echo of this in our own product, and it's the same lesson wearing different clothes. The Victoria model card describes the research checkpoint builder with one line: it formats your notes; it does not verify them. A shared memory buffer does the same job for agents. It organizes intermediate findings so they travel cheaply, and it does not check whether they're true. The operating rule falls out of that. Anything read from a shared buffer is a claim, not a fact. Tag it, source it, and let the agent that acts on it carry the verification step. That discipline costs almost nothing in tokens, and it's what keeps an asynchronous design from compounding errors instead of fixing them.

Source: Victoria AI Model Card | Capabilities, Evidence and Limits | SentX SI

So the practical sequence for your stack: keep the model-size routing you already have, trim synchronous debate rounds where the marginal round isn't buying accuracy, and then look at what your agents pass to each other, replacing full-trace sharing with findings-only exchange wherever the downstream agent doesn't need the derivation. You don't have to adopt Muffin's exact architecture to get the direction of travel; you need the question it asks. Your agents' tokens are being spent on conversation, and that conversation now has a price you can see itemized.