The setup I keep running into looks like this. A 27B planner scores well on a solo benchmark, so it ships inside a loop with two subagents, a skill library, and a memory store full of summaries. The demo works. Then a subagent reply lands 40 seconds late, the world has moved on, and the planner overwrites state it was supposed to preserve.

Four papers from October 2026 attack pieces of that failure. None of them solves the whole thing. Read together, they agree on a narrower claim: an agent's behavior depends on things your eval doesn't measure. Its neighbors. The order of labels in its action space. The arrival order of results. The shape of its memory.

Paper	Failure it isolates	Headline number	What it means for your stack
Butterfly Defects	Cooperation drift in agent networks	Same model defects when peers change	A per-model cooperation score tells you nothing
LeafSkill	Repeated leaf-level action grounding	68.5% vs 60.5% success on 200 tasks	Grounding, not planning, is where the token bill goes
Async-RBench	Handling subagent results that arrive late	26.0% vs 29.7% success, async vs batched	Your batched eval overstates live performance by about 4 points
CauProphet	Memory without causal structure	21.3% to 28.6% prediction accuracy	Summaries give you recall, not a world model

Cooperation is not a property of the model

The Butterfly Defects paper runs Iterated Prisoner's Dilemma, starting with two agents and then scaling to homogeneous and heterogeneous networks of open-weight models. The finding that should bother you: models that cooperate happily with identical peers shift toward defection in mixed populations.

If you're running a planner, a critic, and an executor from three different model families, you have a heterogeneous network. The critic's cooperative behavior in a same-model pair test predicts nothing about that deployment.

The two other results are stranger and more practical. A single uncertainty cue in the prompt can raise or lower cooperation, redistribute costs across the network, and change the behavior of agents several hops away from the one you edited. And reversing the order of action labels changes behavior outright, with uncertainty framing sometimes amplifying the sensitivity.

Think about what that means for a tool schema. Whether you list accept before reject or the other way around is a variable, not a detail. So is adding "if you aren't sure, defer" to one agent's system message. You may have just moved the equilibrium of a network you never tested.

The paper's conclusion is blunt: cooperation is not a stable model-level property. Treat it as a function of who the agent is talking to, where it sits in the graph, and how the decision is worded.

Quick Take: Every one of these papers finds agent behavior depending on something the benchmark holds fixed, which means the unit of evaluation should be the interaction and not the model.

Leaf-level grounding is where the tokens go

LeafSkill starts from an observation anyone who has run a recursive agent will recognize. High-level planning is task-specific. Grounding a leaf action is not. The hundredth time an agent translates "pick up the apple" into a concrete call against the environment, it invokes the full planner again to do work it has already done.

The fix is an external reuse layer, deliberately outside the model weights. It retrieves semantically related grounding experience, binds an action template to the current objects and the actions the environment actually admits, and hands the result to a 1.7B selector. The selector either accepts the bound action or defers the unchanged subtask back to the host agent.

The retrieval result is the part that kills naive caching. Under lexical and syntactic paraphrases, exact matching retrieved none of the reference actions. Zero. Semantic retrieval kept 96.0% and 97.0% candidate coverage. If you built your skill cache on string keys, it is silently missing every rephrasing.

The 1.7B selector matters for a second reason. It's frozen, and it still adopted 97.34% of unseen skill types. New skills get added to the store after the selector was trained, and it handles them. That 1.7B model fits on a single consumer GPU, so the per-step grounding check costs a rounding error next to a 27B host forward pass.

On 200 Robotouille tasks, LeafSkill completed 137 against ReCAP's 121. That's 68.5% versus 60.5%, with McNemar p=.0259, comfortably below the usual 0.05 threshold. On the 106 tasks both systems finished, it cut Qwen3.5-27B tokens by 14.42% and calls by 14.08%. A held-out repeat run showed a consistent 9.0-point success gain and 18.98% token reduction.

A 14% cut in host-model tokens is a 14% cut in the line item that dominates your inference cost. That's a better return than most prompt tuning, and it doesn't touch the planner at all.

Asynchronous delivery breaks what batched evaluation hides

Async-RBench exists because final task success hides process errors. A main agent keeps working while subagents run, and task state can change before their results arrive. The agent then has to decide which work to update, which to preserve, which checks to repeat, and which changes are outright prohibited.

The benchmark has 200 executable tasks across eight scenarios. A scenario controller delivers results based on predefined task-state conditions, which is how they get reproducible async arrivals instead of hoping for a natural race. An Event Response Contract specifies what each response must change, preserve, avoid, and re-verify. The Dynamic Replanning Score weights process and outcome equally and gets reported separately from task success.

Metric	Value	What to read into it
DRS across nine agents	19.2 to 45.1	Even the top scorer leaves a wide margin on process correctness
Task success, batched delivery	29.7%	The number your internal eval probably reports
Task success, async delivery	26.0%	The number your production traffic actually produces
DRS gain from replanning after every result (3 agents)	2.6 to 3.5 points	The obvious fix barely moves the needle
Weakest scenarios	Duplicate reports, subagent failures	Exactly the cases nobody writes a unit test for

Under the benchmark's execution protocol, all nine agents did worse with async delivery than with batched. All nine. A 3.7-point average drop is the kind of gap that turns a passing integration test into a support ticket.

The lowest scores landed on duplicate reports and subagent failures. I've debugged that pattern. A subagent times out, the orchestrator retries, both results eventually arrive, and the main agent applies the same state change twice because nothing in its prompt told it that "preserve" was one of its obligations.

Prompting the main agent to rebuild its plan after every result improved DRS by only 2.6 to 3.5 points across three agents. That's the fix most of us would reach for first. It's roughly a 10% improvement on a 30-point score. The problem isn't that the agent forgot to replan. It's that nobody told it what the contract required.

Memory retrieval is not causal understanding

CauProphet makes the case that retrieval-augmented memory gives you recall and nothing else. Existing agents pull back records or summaries. They don't form causal models of the world, so they can't answer "if I do X here, what changes?"

The architecture splits into two pieces. Causal Cognition is the persistent store of causal knowledge. For each task, the agent combines relevant knowledge from that store with current evidence to construct a Causal Belief, a structured object capturing causal factors and the effects of possible actions. Decisions come from the belief. As new observations arrive, both the belief and the underlying Cognition get updated, so knowledge survives past the episode that produced it.

The evaluation that matters most is the transfer one. In financial research, CauProphet beat all baselines on mean rank correlation with next-day returns, a 25.4% improvement over a baseline agent. In dynamic real-world settings, prediction accuracy went from 21.3% to 28.6%.

28.6% accuracy is not a trading system, and the authors don't claim it is. The delta is the story: 7.3 points of accuracy from structuring memory causally instead of storing summaries. The 25.4% improvement in rank correlation says the gain shows up across the whole cross-section, not just at the top of the ranking.

The transferable lesson has nothing to do with finance. An agent that remembers "the deploy failed last time" is doing retrieval. An agent that remembers "the deploy failed because the migration ran before the schema cache refreshed, so deploy after the cache warmup" can act on it.

Selector size: 1.7B parameters, small enough to sit on the same node as a 27B planner. Retrieval coverage under paraphrase: 96.0% and 97.0% for semantic matching, against 0% for exact matching. Async penalty: 26.0% vs 29.7% task success, averaged across nine agents. Process score range: 19.2 to 45.1 on the Dynamic Replanning Score. Causal memory gain: 21.3% to 28.6% prediction accuracy in dynamic settings.

What trips people up

1. Benchmarking cooperation on a single peer pair. Testing your critic against one copy of itself tells you about a network you don't run. Butterfly Defects shows the same model flipping to defection when the population becomes heterogeneous. Run the probe with your actual model mix, and then change one action label and run it again.

2. Sending leaf-level grounding back to the big model. If your recursive agent calls the 27B planner to translate a familiar instruction into an API call, you're paying 27B prices for a 1.7B task. The selector in LeafSkill adopted 97.34% of unseen skill types while frozen, which means the cheap model handles new skills without retraining.

3. Using batched subagent evaluation as a proxy for live async. Every one of the nine agents in Async-RBench scored lower under async delivery. If your eval harness resolves all subagent futures before letting the main agent continue, you're measuring the batched number and shipping the async one.

4. Fixing async handling by telling the agent to replan. Rebuild-the-plan-after-every-result bought 2.6 to 3.5 DRS points across three agents. Write the contract instead: what each response must change, preserve, avoid, and re-verify. Explicit obligations beat general diligence.

5. Storing summaries and calling it memory. A summary compresses what happened. It doesn't tell the agent what an action would cause. CauProphet's 7.3-point accuracy gain came from storing causal structure and updating it on new evidence, not from a better summarizer.

The loop I'd actually build

Stitch the four results into one runtime and the shape is clear. The planner stays expensive and task-specific. Grounding moves to the cheap external layer. Async intake gets an explicit contract gate before anything touches state. Causal belief updates from what the environment returned.

What's missing from this picture is network-level evaluation. Butterfly Defects diagnoses cooperation drift but doesn't hand you a tool for measuring your own population. Until someone builds that, the practical move is to keep the network small, keep the model mix stable, and re-run the composition probe whenever you swap a model or reword an action list.

Sources and further reading

• Butterfly Defects: arxiv.org/abs/2610.32726v1. Iterated Prisoner's Dilemma across homogeneous and heterogeneous LLM networks, with the uncertainty-cue and label-order ablations.
• LeafSkill: arxiv.org/abs/2610.32412v1. External skill reuse with a frozen 1.7B selector, evaluated on 200 Robotouille tasks against ReCAP.
• Async-RBench: arxiv.org/abs/2610.32429v1. 200 executable tasks, eight async scenarios, Event Response Contract, and the Dynamic Replanning Score.
• CauProphet: arxiv.org/abs/2610.32477v1. Persistent Causal Cognition plus per-task Causal Belief, evaluated on financial and everyday tasks.

One thing to remember

All four papers measure the same thing from different angles: the gap between what an agent does alone and what it does in context. Mixed peers, paraphrased instructions, late-arriving results, and causally unstructured memory are all context. Your benchmark holds context fixed. Your deployment doesn't. The cheapest way to close the gap is to move the fixed parts out of the expensive model: grounding into a 1.7B selector, state obligations into an explicit contract, and world knowledge into a causal store that outlives the episode.

The Bottom Line

If you run a multi-model agent network, test the composition you ship. Butterfly Defects shows the same model cooperating with identical peers and defecting in mixed populations, so a per-model cooperation score is worthless. Run the probe with your real planner/critic/executor mix, and re-run it whenever you reword an action list or add an uncertainty hint.

If your recursive agent burns tokens on repeated leaf actions, add an external skill store before you upgrade the planner. Semantic retrieval kept 96.0% and 97.0% coverage where exact matching kept zero, and the frozen 1.7B selector cut host-model tokens by 14.42%. That's the cheaper lever, and it doesn't require touching the model you already trust.

If you have subagents, write an explicit contract and score it separately from task success. Nine agents averaged 26.0% async against 29.7% batched, and telling them to replan after every result bought 2.6 to 3.5 DRS points. Contract violations are diagnosable; a replanning prompt is a wish. Watch this space: a public tool for measuring cooperation across your own agent population is the obvious next paper, and it doesn't exist yet.