This week, researchers introduced AgentRadio — an async messaging layer that lets coding agents exchange information between execution steps without burning an extra turn.
The headline was performance: agent teams using AgentRadio nearly doubled results on long-horizon software engineering tasks versus isolated agents.
The part I found more interesting was cost.
Better coordination already reduces waste
Traditional multi-agent systems sync at fixed checkpoints. So if Agent A figures out halfway through that the team is going in the wrong direction, Agents B, C, and D keep running until the next sync point.
Every one of those calls is still billed.
AgentRadio cuts that waste. Agents receive updates asynchronously and adjust at their next step — no waiting for a scheduled checkpoint. Less duplicated work means fewer wasted model calls.
Better coordination isn't just faster. It's cheaper.
But that's the easy part.
The real problem: per-agent budgets don't compose
The harder problem shows up once multiple agents share the same objective.
Most budget guards look like this:
class AgentBudgetGuard {
private spent = 0;
check(cost: number) {
if (this.spent + cost > LIMIT) {
throw new Error("Budget exceeded");
}
this.spent += cost;
}
}
Perfect for one agent. Completely blind to the others.
Now imagine four agents sharing the same task:
| Agent | Spent |
|---|---|
| A | $0.42 |
| B | $0.39 |
| C | $0.47 |
| D | $0.44 |
Every individual guard says: still within budget.
Combined, the task has nearly blown its limit.
Nobody knows. Nothing stops.
Fix: budget belongs to the task, not the agent
Stop tracking spend per agent. Track it once — at the task level — and make every agent check the same pool before each call.
// Every agent checks the shared task budget before calling a model
await taskBudget.check(agentId, estimatedCost);
One line change. Every agent now knows what the team has left, not just what it has spent.
The implementation is straightforward. The critical detail is atomicity.
If two agents simultaneously read the same remaining balance and both decide to proceed, they'll both overspend — together, instantly. Whether you use Redis, PostgreSQL, or DynamoDB, the check-and-update must be a single atomic operation. Read-then-write doesn't cut it here.
Shared budgets unlock team-level controls
Once your agents share a budget, threshold-based policies actually make sense:
const THRESHOLDS = {
NOTIFY: 0.60, // alert the orchestrator
DOWNGRADE: 0.80, // switch all agents to a cheaper model
HALT: 1.00, // stop all new model calls
};
Notice what changes: the decision applies to the entire team. Not whichever agent happened to cross the threshold first. Everyone degrades together, everyone stops together, everyone operates under the same budget policy.
That's coherent cost governance. Per-agent guards can't give you that.
The principle AgentRadio proves, applied to money
AgentRadio's core insight is that agents perform better when they share information.
The same is true for financial state.
Sharing context without sharing budgets creates a strange situation: every agent makes a locally correct decision while the team collectively burns through money nobody is watching.
As multi-agent architectures get more common, shared budgets need to be treated as seriously as shared memory.
Capability scales through coordination. Cost control has to scale with it.
Top comments (0)