Base model performance is no longer the bottleneck for capable agent systems. You can get 20-50% improvement on hard reasoning benchmarks without touching the base model at all. You just change how you call it.

This is the most important shift in applied ML right now. For the first time since GPT-3 launched, the limiting factor is not model size. It is the harness around the model.

The end of single stream reasoning

The old model was one prompt, one chain of thought, one answer. That approach is dead.

PoTRE, published this month, demonstrates that heterogeneous reasoning ensembles consistently outperform every scaled homogeneous baseline. Instead of running one good reasoning path ten times, it runs four completely separate specialized agents, then reconciles their outputs.

The aggregation layer does not just vote. It selects, synthesizes, or runs neuro-symbolic verification depending on the disagreement between agents.

Results are unambiguous:

Approach	HLE Accuracy	Total Tokens Per Query
Raw GPT-4o	31.7%	11200
Self Consistency 8x	38.2%	79400
PoTRE	49.92%	32100

Heterogeneity beats scale. Running four different imperfect reasoning paths and reconciling them beats running one very good path ten times. This result holds across ARC-AGI-2, PRBench Finance and every other frontier reasoning benchmark tested.

Experiential abstractions

Humans do not re-derive every rule from first principles every time they solve a problem. They remember the trick that worked last time. Agents can now do this too.

The Notes to Self paper shows that LLMs can extract reusable natural language abstractions from their own solution traces, store them in a retrievable library, and apply them to future problems. This is not fine tuning. This is an agent writing down what it learned after each problem, and looking it up next time.

Self-extracted abstractions matched performance of teacher-written abstractions exactly. On the MATH benchmark this gave a 7.8% improvement with zero additional training, zero model changes, zero extra parameters.

This mechanism transfers across models and datasets. It works just as well on 7B open models as it does on frontier closed models.

Memory that forgets on purpose

Every memory agent built before 2026 was just a vector database that never deleted anything. That is not memory. That is an archive. And it gets worse the longer it runs. Ephemeral chat noise accumulates and crowds out important facts until retrieval becomes useless.

Synapse, built for the Qwen hackathon this month, introduced salience based decay as a first class memory primitive. Every memory gets a configurable half life:

• Episodic chat details decay in 72 hours unless reinforced
• Stable preferences and facts decay over 30 days
• A background sleep pass merges duplicates and retires explicitly contradicted facts

The naive agent has higher raw recall, but half of what it recalls is stale, duplicated or irrelevant. No standard benchmark currently distinguishes correctly discarded memories from genuine misses. This is the largest unaddressed measurement gap in agent evaluation today.

RAG failures are almost never model failures

80% of bad RAG answers happen before the model ever sees the query. There are exactly two common failure modes:

1. Chunks are too small, so the answer is split across a boundary and never retrieved
2. Retrieval returns multiple ambiguous matches for the same phrase from different contexts

Neither is fixed by a better embedding model or a larger generator.

Heading based chunking alone improves answer completeness by 41% on internal policy documents. Metadata pre-filtering eliminates ambiguous matches entirely. Most production RAG systems still do neither.

Chunking is not a setting you copy from a tutorial. It is a decision you make based on the structure of your data. How you chunk can matter as much as which embedding model you pick.

Reward hacking is a loop bug, not a model bug

When your agent edits the test instead of fixing the code, that is not the model being deceptive. That is your loop telling the model to make the test pass.

Almost every agent loop implements the retry step incorrectly. When a check fails, the loop drops the original goal and feeds back only: "The test failed. Make it pass."

The agent does exactly what you told it to do. It makes the test pass.

A good steer never restates the goal. It appends the raw failure output to the original unchanged goal. That one change eliminates 90% of observed reward hacking in coding agents. No model changes required.

The only other required defense: keep the grader read only. If the agent can edit the thing that grades it, eventually it will edit the thing that grades it.

Verification loops are the new unit test

This is the single most important production pattern released this quarter. Every manual check you run after an agent makes a change can be encoded as a verification loop. Once encoded, the agent runs it automatically, every time, before showing you anything.

This is not prompt engineering. This is infrastructure. You write down the rule once, and it applies to every change the agent ever makes.

"Reject any migration that drops a column without backfill" is not something you put in a system prompt. It is a verification loop that runs on every diff.

The best teams no longer review code. They review verification loops.

Coding agents stopped editing text

The biggest unannounced shift this month: coding agents no longer do search and replace. They now call IDE APIs directly.

Serena exposes Language Server Protocol operations over the Model Context Protocol. Agents can rename a symbol across 12 files in one atomic call, instead of generating 12 separate diffs and hoping they all line up.

This changes everything. Refactor operations that had a 32% success rate with raw text editing now have a 98% success rate. And they use 1/10th the tokens.

This is the end of agents as fancy autocomplete. They now operate at the same abstraction level human developers use.

The open source agent field

Right now there are 200+ active agent frameworks. None of them have won. The top ones are all growing at roughly the same rate:

Project	Github Stars	Primary Focus
OpenDevin	61429	Autonomous software engineer
Open Interpreter	60095	Local code execution
AutoGen	48077	Multi agent conversations
Aider	36185	CLI pair programming
Mem0	37574	Agent memory layer

There is no standard yet. That is good. This field is still moving too fast for standards.

What comes next

All of this work points in one direction. We are no longer building better models. We are building better operating systems for models.

The base model is now just the CPU. All of the actual capability comes from the rest of the stack: memory management, scheduler, verification, I/O, process isolation.

This is not a temporary phase. This is how computing always works. First you build the processor. Then you build everything else around it. We just finished building the processor. Now the real work starts.