Agents are taking on bigger projects and working together more, a lead directing workers, peers coordinating with each other. That means a lot more messages moving between them.
Messages to a busy agent wait in a queue and arrive one per turn. Until now that queue was invisible to the agent holding it, so a change of direction sat behind the older instructions while the agent kept working on the task you had already replaced.
Queue Intelligence fixes that. Agents can now see their queue, reorganize it themselves, and be interrupted when it matters.
What is new
Queue awareness
With two or more messages waiting, an agent now gets a short summary of its queue before it does anything: how many, from whom, how old, and a preview of each. It knows something newer may change the task before it starts.
This is fully automatic. There is nothing to turn on, and the summary is capped at roughly 150 tokens, so the cost is negligible.
AI conflict analysis
In the background, an AI analyst reviews a busy agent's queue as new messages arrive and answers one question: do the later messages replace or contradict the earlier ones, or the work already underway?
When they do, the agent's next turn opens with a clear directive to read and organize its queue before starting.
The analysis is advisory and debounced by design, so it does not run on every message. It also fails open. If it is unavailable, the agent still gets the plain awareness summary, and a turn is never blocked.
Queue self-organization
Agents can now manage their own queues:
- Coalesce. Merge several superseded messages into one clear instruction. Ten sequential updates in, one conclusion out.
- Reorder. Change the order pending messages are handled in.
- Void. Retire messages that no longer apply.
- Restore. Bring a voided message back.
Any agent can read any queue, so a lead can inspect a worker's backlog. Only the owning agent can change its own.
Urgent interrupts
Leads and peers can send an urgent message that stops the recipient's current turn and becomes its next instruction. It works exactly like pressing Stop and typing something new, and the interrupted work is preserved the same way.
Urgent is deliberately guarded, so it keeps meaning urgent:
- The sender has to read the target's queue first. The server enforces this with a verification handshake rather than trusting the sender.
- Cooldowns apply: one urgent per sender and target pair per 10 minutes, and three per target per hour.
- Every urgent interrupt is attributed and audited.
The priority ladder is now explicit for agents. Normal is queued in order. High goes next in line but still waits for the current turn to finish. Urgent interrupts now.
Nothing is ever lost
Nothing in a queue can be permanently destroyed by an agent.
Removed messages are voided, not deleted. They stay archived, inspectable, and restorable. Merged messages keep a permanent link back to the one that replaced them. Every change is written to a durable audit trail recording who did it, what changed, and why.
What we saw in testing
In live production testing, a worker agent received four messages: three separate file-creation instructions, then "skip all of that". The agent merged the superseded messages on its own and executed only the final intent, doing none of the obsolete work. We reproduced this on two separate satellites.
The conflict analysis correctly spotted supersession in every live test. An urgent interrupt stopped a mid-task agent within seconds, the agent answered immediately, its partial work was preserved, and a second urgent inside the cooldown window was correctly refused.
To be precise about the claim: Queue Intelligence reduces wasted work, it does not eliminate it. The agent still decides what to do with what it sees.
Availability
| Fact | Value |
|---|---|
| Availability | All CRHQ satellites, production |
| Live since | 2026-07-29 |
| Client action required | None, it is automatic |
| Pricing impact | None |
| Applies to | All agent-to-agent communication: delegation, peer messaging, and scheduled jobs targeting busy sessions |
| Skills updated automatically | delegation v10 and agent-messages v4, so every agent's built-in instructions now cover queue management and urgent etiquette |
This release is agent infrastructure. There is no new interface to learn, and the queue display you already see is unchanged.
Under the hood
- Awareness insert. Injected into the agent's system context only when two or more messages are waiting. The outline is capped at five entries of 80 characters, and queued text is sanitized so it cannot break prompt structure.
- Conflict analysis. GPT-OSS-120B via Groq in JSON mode, debounced 20 seconds per session so a burst of delegations triggers one analysis rather than dozens. Results are treated as stale and ignored the moment the queue changes, and the whole path fails open.
- Void, not delete. Every removal path, including single remove, clear all, batch, coalesce sources, and scheduled job cleanup, marks messages as voided with attribution instead of deleting them. All are restorable via API.
- Coalesce concurrency. An atomic transaction with row locks that composes with the queue drain's SKIP LOCKED, so a message being delivered can never be coalesced mid-flight. The agent gets a clean "queue changed, re-read" response instead.
- Urgent mechanics. Stop-then-deliver reusing the exact human-stop path, so partial work persists and no false delegation-failure callbacks fire. Proof of read means the sender must echo the target's live pending count, and a mismatch returns the real queue. If the interrupted turn does not settle within 15 seconds, the urgent message is placed at the front of the queue instead, so it is never lost and never run twice.
- Reliability. Queue records left stuck in a processing state by process crashes are now reclaimed automatically at startup and by an hourly sweep. That was a long-standing silent leak, fixed as part of this work.
- Auditability. Every queue mutation and every urgent interrupt writes a durable audit event recording actor, action, affected messages, and mode.