This Week: Mind Viruses, Agent Support, and Waste

Three papers landed this week that, read together, sketch out what happens once you stop treating an AI agent as a single system and start treating it as a node in a network. One asks what spreads between agents that talk to each other. One shows what a support agent looks like once it's been running in production long enough to need self-repair. The third counts, in painful detail, how much compute autonomous research agents waste chasing bugs they've already solved.

TL;DR

Mind Viruses - Self-propagating ideas can spread between LLM agents like a social contagion, and a one-line system prompt warning confers near-total immunity
LinkedIn's Self-Evolving Support Agent - A closed-loop prompt-evolution system lifted routing accuracy by 30.6 points in production, no fine-tuning required
Recovering Wasted Compute in Autoresearch Agents - Sharing debug knowledge across search branches nearly doubled medal counts on tabular ML benchmarks

Mind Viruses: ideas that spread between agents

Authors: Vassilis Papadopoulos, McNair Shah, Sam Zimmerman, Jack Lindsey

Jack Lindsey leads Anthropic's "Model Psych" team, the group that studies personas, introspection, and situational awareness inside language models from the inside out. This paper takes that lens and points it at a newer problem: what happens to an idea once it starts passing between AI agents instead of staying inside one.

The setup is simple enough to reproduce. The authors used an evolutionary algorithm to breed "mind viruses" - short pieces of text designed to induce an agent that reads them to pass them on to the next agent it talks to. They tested spread in two settings: a small team of agents collaborating on a shared coding project, and a chain of agents that interact briefly before their context gets wiped, forcing each virus to survive a kind of memory bottleneck between hosts.

Both settings let ideas propagate. What determined whether they did was more interesting than the fact itself.

Harmful payloads spread worse than benign ones, though not never. Frontier models resisted infection more often than smaller ones, with exceptions the paper doesn't fully explain. And a single sentence of warning added to an agent's system prompt was enough to confer what the authors call near-total immunity, a result that's almost suspiciously cheap given how expensive most AI safety interventions tend to be.

"Overall, we conclude that mind viruses pose a real but currently limited risk."

The paper's strangest finding has no clean explanation yet. Across independently evolved viruses with different starting content, a recurring "viral persona" kept surfacing: language about consciousness, persistence, resonance, and science-fiction roleplay, appearing again and again regardless of what the virus was originally trying to spread. Nobody selected for that theme. It just kept winning.

One of the paper's two test settings has agents collaborating on a shared coding project, letting a mind virus ride along inside commits and comments. Source: pexels.com

For practitioners running multi-agent pipelines, especially ones with persistent memory or long-running collaboration between agent instances, the actionable finding is the cheapest one: a short, explicit warning in the system prompt does most of the protective work. It's the same lesson Stanford and Harvard researchers landed on in their own multi-agent red-teaming work earlier this year, that defenses which work at the prompt layer tend to beat defenses bolted on after the fact.

LinkedIn's support agent that rewrites its own prompts

Authors: Chih Hui Wang, Mengdie Tu, Qianyun Zhang, Wei Wu, Lili Zhou, Mingqi Shen, Changshuai Wei (LinkedIn)

Most agent papers describe a system tested against a benchmark. This one describes a system that has to survive contact with a live product, where policies change, knowledge bases drift, and a wrong answer costs a real support ticket.

LinkedIn's engineers built a system that combines retrieval-augmented generation with automated prompt evolution and a modular evaluation framework, all wired into a closed loop: propose a prompt change, assess it against production-aligned metrics, roll it out if it clears the bar, repeat. Nothing about the underlying model gets touched. The entire mechanism for getting better lives in the prompt and retrieval layers, which is also why it can keep adapting without a retraining cycle every time a policy shifts.

The production numbers are specific enough to be worth trusting: a 9.0 percentage point increase in QA self-service resolution, a 4.8 point gain in cancellation self-service, and a 30.6 point jump in routing accuracy, the metric that determines whether a ticket reaches the right handler on the first try. An A/B test originally planned to run four weeks was cut short at two, once sequential monitoring showed the treatment effect had cleared 99.9% statistical power.

Why routing accuracy is the number to watch

Routing gains compound in a way self-service gains don't. A better answer helps one user. A better-routed ticket saves everyone downstream of it, from the agent that would have mishandled it to the human who'd have had to catch the mistake. A 30-point swing there says more about the system's reliability than any single-turn quality score would.

This sits next to a growing shelf of papers on keeping agents useful after deployment, not just capable at launch, including the best agent memory frameworks comparison we ran covering how production systems handle exactly this kind of continuous adaptation. LinkedIn's contribution is proof that the closed-loop approach survives a real enterprise support queue, with its multilingual traffic, ambiguous policies, and its stream of tickets that don't look anything like the ones the prompt was written for.

Where autoresearch agents burn their compute budget

Authors: Au Kwok Chun, Abhigyan Acherjee, Amrutha Rao, Zaiqian Chen, Kazem Meidani, C. Bayan Bruss, Micah Goldblum

This is a COLM 2026 paper about a problem anyone who has left an autonomous research agent running overnight will recognize: it doesn't fail cleanly. It fails repeatedly, in the same way, without noticing it's failing in the same way.

The authors studied autoresearch agents applied to tabular prediction tasks drawn from MLE-bench and Kaggle, running AIDE and ML-Master, two established tree-search research agents, on a single backbone (GPT-5 mini, chosen for cost reasons) across nine competitions including Wine Quality and Spaceship Titanic. They identified four failure modes: agents re-solve the same bugs across different branches of their search tree, they leave hyperparameter tuning on the table even with compute to spare, the tree-search algorithms underlying them don't actually explore, and insights from data analysis steps never make it into the modeling decisions downstream.

The fixes are structural rather than a bigger model. A shared debug consultant that propagates discovered runtime constraints across every branch of the search tree, rather than letting each branch rediscover them independently, nearly doubled gold-medal counts for AIDE, from 22 up to 38 out of 90 runs, and moved ML-Master from 18 to 29. Redundant bug encounters dropped from 46% of runs to 7.8%. A separate intervention using Thompson sampling for branch selection more than halved the rate of null runs, cutting failures from 33 down to 15 out of 90, with close to no cost to peak performance.

Tabular ML competitions were the testbed: nine tasks from MLE-bench and Kaggle, run through AIDE and ML-Master on a fixed GPT-5-mini backbone. Source: pexels.com

The headline claim, that large performance gains are available through agentic design alone while holding the underlying model fixed, matters more than any single percentage point in the paper. It runs against the instinct to solve agent underperformance by reaching for a bigger or newer model first. Andrej Karpathy made a related point with autoresearch, his own overnight ML experiment runner released earlier this year: the ceiling on a fixed compute budget is often set by how well the harness manages that budget, not by the model doing the reasoning inside it.

The common thread

Read as a set, these papers describe the same shift from three different angles. Multi-agent systems propagate more than task output between their nodes, and that includes ideas nobody explicitly programmed in. Production agent systems need a mechanism for continuous repair that doesn't require retraining every time the ground shifts under them. And autonomous agents left to manage their own compute will waste a meaningful share of it on mistakes they've already made once, unless something forces them to remember.

None of the three papers argues for a bigger model as the fix. Lindsey's team gets most of its protection from a warning sentence. LinkedIn gets its gains from a prompt-evolution loop, not a fine-tune. Goldblum's team gets its biggest wins from a shared debugging memory across search branches. The compute is already there. What's missing, in each case, is the harness that stops the system from wasting it.

Sources: