I build production LLM agents for a living. This past week eight papers dropped on arXiv that fix almost every hard, unspoken problem that has stopped this technology from leaving demo hell.

None of them made it to the front page of Hacker News. None got viral twitter threads. Almost nobody outside the very small group of people actually building production agents has even seen them.

This is not incremental progress. This is the stack that will be used for every production agent deployed in 2027.

We stopped building agents wrong

For two years everyone operated from one unexamined assumption: the agent is the LLM. Every responsibility got dumped inside the transformer context window. Remember what you searched. Remember what you found. Remember what you discarded. Remember which claims you verified. Remember the constraints. Plan. Communicate. Decide. When this failed, we made the model bigger. We added more context window. We added more RAG. None of it worked. Every single paper in this batch agrees on one thing. That model was stupid. Stop asking the LLM to do bookkeeping. That is what computers are for.

The end of transcript-only agent policies

Harness-1 is the cleanest demonstration of this shift. Search agents were always trained as policies over growing raw transcripts. At every step the model had to parse the entire history again, extract state, discard noise, and then finally make a decision. Reinforcement learning was forced to optimize both semantic judgment and trivial recoverable bookkeeping. Harness-1 splits the system cleanly. All state lives outside the model, in an environment side harness. This harness maintains the candidate pool, importance tagged evidence, verification records, deduplicated observations, and budget aware context rendering. It does all the bookkeeping. The LLM policy only does one thing: make semantic decisions. What to search next. Which documents to keep. When to stop. The policy is 20B parameters. Across eight retrieval benchmarks it achieves 0.730 average curated recall, outperforming the next strongest open search agent by 11.4 points. It matches performance of 70B and larger frontier model search agents. This is not a marginal gain. This is an architectural discontinuity. You will not get this gain by making your model bigger. You will get this gain by stop asking the model to be a bad spreadsheet. Every production search agent will copy this design within 6 months.

World modeling does not need a separate simulator

Up until this week every proposed world modeling approach for agents required three things: a separate simulator, an extra training stage, and additional inference time compute. Everyone accepted this as an unavoidable cost. PaW changes this entirely. The authors made one trivial observation. On policy RL rollouts already contain every single bit of signal required to train a world model. Every transition pairs an action with its resulting next observation. You are already generating this data. You are already throwing it away. PaW adds a single auxiliary world modeling loss head during RL training. Same forward pass. Same rollouts. No changes to inference. No extra runtime cost. No separate model. Across three standard agent benchmarks this change delivers consistent 4-7% improvement over every strong RL baseline, across all model sizes and RL algorithms. There is no tradeoff. You can add this to any existing RL agent pipeline this week.

Agents can internalize skills instead of retrieving them

All skill based agent work up until now operated the same way. You maintain an external skill bank. At every turn you run retrieval. You shove the relevant skill into the context window. This works for demos. It does not work for production. It adds latency. It burns tokens. It breaks context limits. It fails silently when retrieval picks the wrong skill. SIRI fixes this. SIRI first runs standard RL to collect successful trajectories. It then mines compact reusable skills directly from its own successful runs. It validates each skill by running paired head to head rollouts. Finally it distills only confirmed beneficial skills directly into the model weights. At inference there is nothing. No skill bank. No retrieval. No extra prompts. No additional context. The agent just knows the skill. On WebShop this takes baseline GiGPO performance from 0.728 to 0.813. It outperforms every prompt based, RL based and memory augmented baseline. This solves one of the most annoying operational problems with long horizon agents.

Multi-agent communication was fundamentally broken

Every multi agent system built until now used exactly one communication scheme. Agents send full raw messages only to their direct neighbours. After three hops 90% of signal is gone. Everyone responded by just adding more agents to compensate. MOC fixes the fundamental scaling limit of multi agent systems. Instead of passing raw concatenated first order messages, MOC constructs structured multi order evidence streams. It runs semantic topological merging to preserve signal fidelity within hard token limits. Across all tested datasets and model sizes MOC delivers 15-22% better task performance while using 30% less total communication volume. Performance improves as agent count increases, instead of degrading. This is not a tweak. This removes the hard upper limit that every existing multi agent system hits at around 7 agents.

Coordination without central control

For any system with more than 4 agents you had two bad options. You could run a central orchestrator that becomes a single point of failure and a bottleneck. Or you could run fully distributed agents and get emergent chaos. CG-CMARL is the first method that actually works at scale. It decomposes the joint problem into pairwise regions using coordination graphs. Shared Q functions handle objectives and constraints independently. At execution time Max Sum message passing coordinates actions across the graph. No central controller exists at any point. The system will respect hard constraints. A single trained model can trace the full Pareto front between objective and constraint tradeoffs without retraining. It scales cleanly to 100 agents, well past the point where all centralized approaches become intractable.

We finally have a way to detect silent agent failures

This is the paper that will unblock regulated deployments. All existing failure detection approaches used an external evaluator model. This creates a new single point of failure. It requires domain specific tuning. It misses most silent failures. It performs worse as problem complexity increases. POIROT does the obvious thing that nobody thought to try. It uses the other agents already in the system as auditors. Agents executing the task already have full context. They already understand the requirements. They already understand what failure looks like. POIROT just asks them. Across test cases POIROT correctly identified 89% of silent failures, compared to 51% for a standalone GPT-4o evaluator. Detection performance improves with agent count, improves with problem complexity, and persists under compound fault conditions. Safety oversight does not need to be external. The agents executing the work carry sufficient collective intelligence to audit it.

Benchmarks are finally starting to measure real performance

Every agent benchmark released before this week was fake. They all used synthetic tools. They all used stateless environments. They all had answers embedded in the prompt. MCP-Persona is the first benchmark that measures actual agent performance on real world work. It runs standard MCP tools against fully simulated user accounts for Reddit, Slack, Lark, calendar and email. Every state of the art agent tested scored below 40% success rate. The best open agent scored 27%. This benchmark will kill every demo agent that only works on twitter. This is the benchmark that people will actually use to measure progress from this point forward.

Agents are now doing original research

Iteris got a small amount of attention, but not nearly enough. This agent did not solve an olympiad math problem. It did not answer a question that already had an answer somewhere on the internet. It solved two open research problems in computational mathematics. Problems that human mathematicians had been working on. It generated numerical evidence. It constructed the counter example. It ran the experiments. It wrote the proof draft. Human researchers only corrected minor formal errors. This is not a demo. This is the first time an agent has made original publishable contributions to mathematics.

What comes next

None of these papers are from OpenAI, Google or Anthropic. All are from independent research teams. All have open reproducible code. All can be implemented today. For two years we have been iterating on bad architecture. We have been making incremental improvements to a design that was fundamentally broken. Now we have good architecture. Over the next 12 months agent performance will not improve 10%. It will double. Most people have not noticed yet. Most people will not notice until it is already done.