Every agent demo you have seen lied. They work for 3 turns on scripted examples, then fall apart the second they hit unplanned edge cases. For two years every new agent paper just added more loops, more tools, more prompt engineering. None fixed the fundamental failure modes.

This batch of papers is different. Every one attacks a bottleneck that was stopping agents from leaving demonstration environments. None require 70B+ parameters. All have working open source code released alongside results. This is the week agentic systems stopped being research toys.

The self evolution tradeoff that broke everything

All self improving LLM systems have been trapped on one side or the other of a brutal tradeoff. You can run self play inside a bounded verifiable environment and get clean reliable feedback, but you will never learn anything outside that narrow box. Or you can run open ended self generation, get infinite task variety, and watch bad rewards poison the training loop until the model collapses into generating convincing garbage.

No one had found a middle ground until Skill Self-Play. The core insight is stupidly obvious once you see it: use atomic skills as the boundary between verification and exploration.

Each skill is a narrow, verifiable unit of capability. Execution success can be measured perfectly. But instead of locking the agent inside one skill, a dynamic controller samples and combines skills at runtime to generate arbitrarily varied open ended tasks.

All three components co-evolve in a standard RL loop. The proposer learns to generate tasks just at the edge of the solver's current capability. The solver pushes its own performance boundaries. The controller prunes dead skills and adds new ones when stable execution patterns emerge.

In testing this framework took misaligned base models that scored below random on benchmarks and pulled them up to competent performance in 120 hours of self play. No human annotations were used at any point.

Stop routing individual LLM calls

This is the single most deployable result from the entire batch. Every enterprise running agentic systems today has a routing layer. Every single one implements routing incorrectly.

Existing routers make an independent decision for every single LLM call. They will send an easy lookup to a small cheap model, then send the next reasoning step to a large expensive one. This sounds logical until you remember agents are long running tasks. Success or failure is only known at the end of the entire run. There is no way to correctly attribute credit for the final outcome to any individual turn.

Per call routers systematically underinvest in early critical steps and overspend on trivial late steps. They will never produce optimal tradeoffs.

TRACE-Router fixes this. It makes exactly one routing decision per task, at admission. It pins every subsequent LLM call for that entire task run to the selected backend. It only updates its routing policy using the final terminal reward for the full task.

Benchmark	Best single model baseline	TRACE-Router	Accuracy delta	Latency reduction
tau2-Bench	62.1	69.3	+7.2	0% (latency matched)
Terminal-Bench	71.4	78.5	+7.1	36%
WebAgent-Bench	58.9	65.0	+6.1	29%

There is no trick here. No better base model. No clever prompt. Just correct credit assignment. You can drop this into your existing agent stack this week and get these numbers.

3B parameters that beat 12B on agent tasks

Nanbeige4.2-3B is the sleeper hit that almost no one noticed. This is a 3B non-embedding parameter model that outperforms both Qwen3.5-9B and Gemma4-12B across every standard agent benchmark. It runs comfortably on a mid range phone.

This model did not win by being smarter. It won by being built for agents from day one.

• It uses a Looped Transformer architecture that reuses the layer stack 4 times during inference, getting effective depth without additional parameters
• All fine tuning data is full agent trajectories, not isolated question answer pairs
• RLHF is run separately over think tokens and output tokens, with separate rewards for process and outcome

Most teams still evaluate base models on MMLU and GSM8K then wonder why they perform terribly as agents. Agent capability is almost uncorrelated with standard reasoning benchmarks. This model proves you can build a production capable agent at sizes everyone wrote off as too small.

Root cause analysis that does not need fault labels

Industrial root cause analysis is a 100 billion dollar a year problem. Every factory runs thousands of sensors. No one has labeled training data for every possible fault. Faults happen once every few years. By definition you have never seen the one that just broke your plant.

All existing automated RCA systems fail for exactly this reason. They are trained on historical faults. They will never detect a new failure mode.

AgentRCA takes the opposite approach. It does not train on faults at all. It only has a model of normal system operation. When an anomaly is detected, the agent generates competing physical hypotheses for what went wrong, then iteratively queries sensor data, runs statistical tests, and eliminates hypotheses until one remains.

On test deployments at a real world chemical plant this system matched the diagnostic accuracy of fully supervised baselines. Unlike those baselines it worked on fault types that had never been observed before. Every diagnosis came with a full auditable trace linking every observation back to the final conclusion.

This is not a demo. This system is already running in production.

Automated research that does not lie

Last year the Bad Scientist paper destroyed everyones faith in LLM peer review. It showed that state of the art models accept completely fabricated research papers at almost exactly 50% chance. You can not close an automated research loop with an LLM reviewer. It will just approve garbage forever.

CausalForge solves this by throwing out the LLM reviewer entirely. The entire loop runs on top of the Lean proof assistant. The agent will select a research topic, propose an informal result, formalize the statement, construct a full machine checked proof, then only run a lightweight audit to confirm the formal statement actually matches the original informal claim.

There is no room for fabrication. If Lean accepts the proof, the result follows from the axioms. The team has already used this system to build 7,035 machine checked declarations for causal inference, most of which were previously unpublished results.

This is the first system that can run unsupervised research for weeks and produce output you can trust.

Research ideation requires both quality and diversity

Every one has done this. You ask a good LLM for 10 research ideas. You get 10 minor variations on exactly the same idea. All existing ideation systems optimize only for quality. They will always converge to the safest most obvious thing.

IDEAgent frames ideation as a Quality-Diversity search problem. It explicitly optimizes for two separate objectives:

1. An idea must be sound, rigorous and non trivial
2. An idea must be meaningfully different from every other idea already generated

The system tracks full lineages of ideas, repairs weak proposals instead of discarding them, and explicitly rejects anything too close to existing work.

On the joint Yield metric IDEAgent outperforms the best existing baseline by 3.89x. It produced non zero valid output on 8x more test topics.

Self calibrating agents for edge deployment

Agent drift is the silent failure mode no one talks about. You deploy an agent, it works perfectly for two weeks, then it slowly drifts and starts making increasingly bad decisions. There is no human in the loop watching every decision. By the time you notice the damage is already done.

The edge agent framework released this week adds an internal ARIMA forecaster that runs continuously alongside the agent. It builds a predictive model of expected agent behaviour and uses this to dynamically approximate ground truth without any external labels or human oversight.

When tested on zero knowledge workload profiling for edge networks this system:

• Outperformed baseline LLM agents by 91.7% on resource usage prediction
• Ran 71.7% faster than manual profiling
• Generated ground truth estimates 52% faster than standard ARIMA implementations

This is the first general mechanism for running autonomous agents for extended periods without continuous human supervision.

The unstated pattern across all results

None of these papers made the base model smarter. Not one improvement came from training a larger model, or getting more data, or better alignment.

Every single gain came from better structure around the LLM. Better credit assignment. Better feedback boundaries. Better verification. Better routing.

The biggest mistake engineering teams are making right now is waiting for the next generation base model to fix their agent problems. It will not. All the hard gains are in agent architecture, not base model capability. This batch of papers proves that beyond any doubt.

What you should test this week

You do not have to wait for anyone to productize this. All code is public right now.

1. Drop TRACE-Router into your existing agent routing layer. You will get 6-7 accuracy points for free, or 30% lower latency.
2. Run Nanbeige4.2-3B on your local machine. You will be shocked how good it is at tool use.
3. Replace your research ideation prompt with IDEAgent.

We are no longer building demo agents. We are building systems that work.