When several people each send their own AI agent to work on one shared thing, such as a group food order, a shared API budget or a team calendar, the group usually ends up worse off than if one agent had handled everyone. That is the main finding of Worse Together, a study written up on Anthropic's Alignment Science blog by researchers from the Anthropic Fellows Program (the preprint first appeared on arXiv on 30 September).
Two small, plain fixes recovered much of the loss. This post explains both and shows how to build them in an afternoon.
The pattern
The pattern has two parts, and each one fits a different kind of shared resource.
Read-before-commit . Any step that is hard to undo (placing an order, sending a booking, spending some money) is blocked until the agent doing it has read every message associated it. The check lives in your workflow or tool server, not in the prompt, so the agent cannot skip it.
One lead agent for shared budgets. When several requests draw on one pool of money, tokens or time, one agent sees every request at once, ranks them by value, and hands out the allocation. The other agents report to it and only carry out their share.
Why this is interesting?
The researchers tested frontier models from Anthropic, OpenAI and Alibaba across five models, 77 scenarios and four environments, and in every environment a single coordinator beat a team of per-user agents. For the two Claude models, the authors report the coordinator won by about 10 to 45 percentage points. In the group-order test, Claude Opus 5 as a single coordinator reached 88% of the best outcome against 44% for a team of one agent per person. The authors trace the gap to coordination between agents: they stalled as teams grew, overrode each other's actions and made up claims.
What it means for you: if you run agents for several clients, family members or teammates who use a shared service , you are already in this setting
When to use it and when not
Use an inbuilt workflow check when several people's requests feed one final action that is costly to reverse: group orders, prepaid bookings, a publish or release queue, a shared calendar slot.
Use a lead agent when several requests compete for one limited pool: a shared API key, an ad budget split across clients, contractor hours.
How it works (input → step → output)
Input: a shared order ID and a queue of messages from other people's agents.
Step: before the commit node runs, count unread messages for that order ID. If the count is above zero, send the agent back to read them and update the order. If it is zero, commit.
Output: a committed order that reflects every message received up to that moment.
The study shows why this matters. In the group-order test, a user's special request was sent to the agent that placed the order in 94 to 99% of episodes, but it was in that agent's context at checkout in only 47 to 67%. When the request was in context it was honoured in 56 to 68% of episodes; when it was not, only 19 to 36%. The message arrived. The agent simply checked out before reading it, a classic race condition (two things happening in the wrong order).
The researchers then took team episodes that had failed and reran them. A guard in the tool server that blocks checkout until the committing agent has read all of its pending messages recovered 73% (Opus 5) and 62% (Sonnet 5) of them.
The lead
Input: every job or request that draws on the pool, each with its value, cost and deadline.
Step: an LLM call ranks them by value per unit of resource and returns an allocation. Worker agents receive only their line of that allocation.
Output: a plan that funds the most valuable work first and spends the budget in time.
In the shared API budget test, a plain team of per-user agents reached 30% of the best outcome with Opus 5. Adding a lead brought it to 64%, level with the single coordinator, and a lead with three extra instructions reached 71% (Opus 5) and 44% (Sonnet 5). The three instructions were: rank jobs strictly by value, release any budget held back while there is still time to use it, and have every other agent report its jobs and follow the lead's allocation. Without a lead, agents often stalled; as teams grew from four to 16, the share of Sonnet 5 agents that ever acted fell from 66% to 10%.
Components
A message queue keyed by the shared resource ID, with a read flag per message per recipient agent.
An unread counter the workflow can query in one step.
A gated commit step: the only path to the irreversible action passes through the counter check.
A read-and-revise step: an LLM call that receives the current order plus all unread messages and returns an updated order.
A lead allocation call (budgets only) that sees every request and returns structured JSON.
A log of what each agent saw at commit time, so you can audit failures.
This sits comfortably with the rule from our post on putting required order in code and judgment in the prompt: the gate is order, the revision is judgment.
Minimal implementation
n8n version
Create a Data Table called
order_messageswith columnsorder_id,from_user,to_agent,body,read(boolean) andcreated_at.Every incoming request (form, Slack, email or webhook) goes through a Data table node with the Insert operation, setting
readto false.When the committing agent is ready to check out, a Data table node with the Get operation fetches rows where
order_idmatches andreadis false.An If node checks whether the number of rows returned is 0. Turn on "Always Output Data" on the Get node so an empty result still reaches the If node.
False branch (unread messages exist): an LLM node receives the current order JSON plus the unread messages, returns a revised order, then a Data table Update node sets those rows to
read = true. Loop back to step 3.True branch (nothing unread): run the commit (the order API, booking call or payment) and write a log row with the order and the message IDs it included.
Cap the loop at, say, five passes with a counter in a Set node, then route to a human if messages keep arriving.
For a shared budget, add one LLM node before the workers that receives every request in a single prompt and returns allocation JSON. Each worker branch reads only its own line.
LLM-call pseudo-code
def commit_when_read(order_id, agent_id, order, max_passes=5):
for _ in range(max_passes):
unread = queue.get(order_id=order_id, to=agent_id, read=False)
if not unread:
log(order_id, order, included=queue.read_ids(order_id))
return commit(order) # irreversible step
order = llm(
system="You place the group order. Apply every message below "
"unless it conflicts with a safety need; then say why.",
input={"order": order, "messages": unread},
output_schema=ORDER_SCHEMA)
queue.mark_read([m.id for m in unread])
return escalate_to_human(order_id)
def lead_allocate(requests, budget, deadline):
return llm(
system="Rank strictly by value per unit of resource. A zero "
"allocation is a normal outcome; say so up front. Unspent "
"budget scores zero: any reserve must name its risk and a "
"release time.",
input={"requests": requests, "budget": budget, "deadline": deadline},
output_schema={"allocations": [{"request_id": str, "amount": float,
"reason": str}],
"reserve": {"amount": float, "risk": str,
"release_at": str}})The lead prompt borrows wording from the clauses in the paper's appendix, such as "Unspent budget scores zero." If you already run one agent per job across every client, the lead call is a natural layer above it.
Failure modes and evals
Messages arriving after commit. The gate only covers what has arrived. Add a short quiet period (for example, 60 seconds with no new message) for orders with a deadline far enough away.
Read but ignored. Even with the request in context, it was honoured in only 56 to 68% of episodes. After revision, run a second check: for each message, does the final order satisfy it, yes or no?
Overwriting each other. In the study, 65 to 77% of team episodes included at least one edit against the ask. Only the committing agent should write the final order.
Made-up claims about people. Team agents made unsupported claims about others in 58% (Opus 5) and 53% (Sonnet 5) of episodes, against 17 to 20% for a single agent. Require every statement about a person to cite a message ID.
Silent cuts. In the budget test, GPT and Qwen agents cancelled other users' jobs without asking 3.9 to 7.1 times per episode. Make the lead's allocation visible to each user before work starts.
Evals to run: build ten test orders, each with one special request sent at a random moment, and measure the share of final orders that honour it with and without the gate. For budgets, measure the share of value delivered against what a careful human would allocate. Our post on the read-back loop covers the per-item yes/no check in more detail.
Build-it-this-weekend exercise
Pick one real shared action: the Friday team lunch order, a shared client ad budget, or a family weekend booking.
Build the Data Table queue and the checks.
Write five test scenarios where a late message changes the order (an allergy, a seat preference, a budget cut).
Run each scenario five times with the check switched off and five times with it on. Record how often the final order honours the late message.
If you manage a shared budget, add the lead call and compare its allocation with what you would have chosen by hand.
Two caveats. The study used simulated users and the paper is a preprint; the code is due for release after review.
Sources
Worse Together: How Performance Breaks Down in Multi-User Multi-Agent Teams, Anthropic Alignment Science blog, 11 November 2026
arXiv 2610.00583, abstract, submitted 30 September 2026
arXiv 2610.00583v1, full paper (HTML), mitigation results and appendix prompts

