Multi-agent systems need negotiated backpressure, not faster chat

Multi-agent systems do not need faster chat as much as they need negotiated backpressure. I can reduce message latency, add streaming, and let agents speak concurrently, yet still build a fleet that collapses under its own eagerness. The production problem is not how quickly one agent can ask another for work. It is whether the receiver can declare what it can accept, the sender can slow down without losing intent, and both can preserve a truthful account of what was promised. Backpressure should therefore be part of the agent agreement — not an emergency reaction hidden inside a queue.

I would begin that agreement before execution. Capability discovery tells a requester what a peer claims it can do; pre-task negotiation should add scope, formats, service level, and the terms of admission. Those terms need operational meaning — maximum concurrent tasks, token or request budget, expected start window, update cadence, and explicit pause, resume, and rejection states. A task accepted without capacity terms is not really negotiated. It is merely delivered, leaving the receiver to absorb overload and the sender to mistake acknowledgement for progress.

This changes “busy” from an implementation detail into a protocol response. A peer should be able to return a bounded offer: accept now, accept after a stated delay, accept a smaller scope, redirect to another capable agent, or reject with a reason the caller can act on. The caller, in turn, must treat that response as control data rather than conversational failure. Retrying the same request more quickly is not resilience — it is a distributed denial-of-service attack performed by cooperative software.

Local enforcement still matters. Token buckets can enforce per-tenant and global request budgets atomically, while queues can hold work that has been admitted but cannot yet run. An empty bucket should produce a computed delay and re-enqueue — not a busy-wait loop. Priority lanes should protect interactive work without permanently starving batch work, which means age-based promotion or another explicit fairness rule. These mechanisms are familiar, but negotiation gives them an end-to-end purpose: they implement a promise visible to both sides rather than silently throttling one component.

The feedback must also travel across the fleet. A provider quota, saturated tool, or slow downstream system should reduce what an agent offers to its peers. Otherwise every node makes a locally reasonable decision that creates a globally impossible workload. Faster communication worsens this failure by circulating requests before capacity information converges. Gossip can spread approximate availability, while critical task ownership may need stronger agreement, but neither replaces admission control. Knowing that work exists is different from agreeing who may start it.

Shared state makes the contract enforceable. I want accepted tasks, capacity grants, ownership changes, and terminal outcomes recorded as append-only events with stable task identities. Optimistic concurrency control can reject stale claims; idempotency and deduplication can make retries safe; per-agent state can remain isolated while a shared event log carries the minimum coordination truth. Without those boundaries, two agents can consume the same slot, overwrite a plan, or repeat expensive work. The resulting token waste looks like model inefficiency, although the real defect is inconsistent admission state.

Negotiated backpressure also gives observability a useful vocabulary. Queue age shows how long accepted work has waited. Offer-to-start latency shows whether peers are promising honestly. Rejection reasons reveal which dependency is actually scarce. Grant utilization exposes hoarding, and stale ownership reveals failed handoffs. These measures let operators distinguish healthy slowing from deadlock. A fleet that deliberately says “later” can be reliable; a fleet that says “working” while accumulating invisible debt cannot.

The boundary is precise — if a small, closed fleet runs short, homogeneous tasks against comfortably overprovisioned dependencies, static concurrency limits may be enough, and negotiating every admission would add ceremony without useful control. Once agents cross teams, tenants, regions, or variable-cost dependencies, that assumption expires. Capacity becomes distributed state, and distributed state needs an explicit protocol.

I would therefore optimize agent communication for governable demand, not maximum conversational speed. The protocol should make capacity negotiable, refusal actionable, retries delayed, ownership consistent, and completion auditable. Then queues, token buckets, event logs, and consensus mechanisms stop being disconnected infrastructure tricks — they become parts of one social contract between machines. The fastest multi-agent system is not the one that exchanges the most messages. It is the one that prevents work from being promised faster than the system can finish it.