We are no longer building demo agents.

Every paper, every open source release, every production deployment from the last four weeks agrees on this. The era of "look my agent can browse the internet" is over. We are now solving the boring, hard, unglamorous problems that stop agents from running unattended for more than 15 minutes.

This is the state of production agent systems as of August 2026. No hype. No roadmaps. Just what works, what breaks, and what people are actually running right now.

The memory reward trap is solved

For two years every self improving agent died after about 12 turns. No one talked about it much. Everyone saw it. Agents would start retrieving garbage memories, reward signals would contaminate irrelevant entries, and eventually the whole system would lock into repeating the same useless action forever.

RoMeRL fixes this.

The paper demonstrates exactly what was broken: trajectory indexed utility grows without bound. Feedback gets spread so thin across the memory space that no signal ever rises above noise. Worse, when you assign a reward to a set of co-retrieved memories, every single one of them gets the update. Irrelevant garbage that happened to be pulled in along with the good memory gets an undeserved reward boost. Eventually garbage wins.

RoMeRL replaces the unbounded trajectory memory with a fixed dimensional reduced order utility state. It does not store every interaction. It maintains a fixed set of semantic coordinates, and only updates the contents of those coordinates over time.

The results are not marginal.

This is not a 10% improvement. This is the difference between an agent that dies after 12 turns and one that runs reliably for 1000. RoMeRL cuts maintained memory size by 84.4% and reduces the cold Q ratio by 80%.

You should stop building generic vector memory banks tomorrow. Every production agent running today that lasts longer than an hour uses some variant of this architecture.

Agents do not run on big models

The largest performance jump this month did not come from GPT-5.5 or Qwen 397B. It came from LFM2.5-2.6B, a 2.6 billion parameter model trained explicitly to be an agent.

It beats every model up to 10B parameters on every agent and tool use benchmark. It runs at 220 tokens per second on an Apple M5 Max, 113 tokens per second on a consumer Ryzen CPU. It fits in 2.5GB of memory.

Benchmark	LFM2.5-2.6B (2.6B)	Qwen3.5-4B (4.7B)	Qwen3.5-9B (9.7B)
ToolSandbox	77.83	75.55	76.44
Multi-IF	80.07	55.67	62.55
IFStruct	85.49	36.25	78.50
Claw-Eval average	62.85	62.28	66.53

This is the single most important shift this quarter. Agent capability is no longer proportional to model size. The best agent you can run right now is smaller than GPT-2.

You do not need a 100B model to run a tool using agent. You need a model that was trained inside an agent harness. Everyone who learned this the hard way is now quietly deleting their GPT-4o endpoints.

Stateless MCP is the new standard tool interface

On July 28 2026 the Model Context Protocol removed sessions. This was not an infrastructure change. This was a correctness change.

Old MCP hid state inside the connection. An agent would call open_browser then click and the server would just assume they referred to the same thing. There was nothing in the request that proved this. Agents would regularly get crossed sessions, stale state and silent wrong answers.

Stateless MCP fixes this by making all state explicit.

Every call now carries the handle for the resource it operates on. No implicit context. No magic. If the handle is wrong the call fails immediately instead of silently operating on the wrong thing.

This is not just better for load balancing. This is the single largest reduction in agent silent failure mode shipped to date.

Every major agent runtime adopted this specification in the last two weeks. If you are building tools for agents today, this is the only interface you should target.

The agent loop is not the problem. The control plane is.

Agents do not fail because they cannot plan. They fail because they loop forever. They repeat the same search 12 times. They re-verify facts they already know. They burn $50 of tokens making zero progress and no one notices.

No amount of prompt engineering fixes this. This is a control plane problem.

LoopX is the first production implementation of an agent independent control plane. It sits between you and your agent runtime. It tracks objectives, gates, quota, evidence and handoffs. It does not run the agent. It decides if the agent is allowed to run at all.

It enforces exactly five rules:

1. You may not run the same tool call more than 4 times
2. You may not re-verify a fact you were already given
3. You must stop and ask when you hit a gate
4. All work is bounded by explicit quota
5. Every action leaves auditable evidence

This is not clever. This is boring. This is what you have to build if you want an agent to run overnight without you watching it.

Hardening production agents: what actually breaks

When you run an agent in production for three months you will not hit the failure modes you read about in blog posts. You will hit the stupid ones.

Joe Buckle documented every failure mode from running a coding agent in production for six months. None of them were hallucinations. All of them were structural failures of the agent harness:

#	Failure	Fix
1	Search tools cannot see filenames	Add filename matches to all search results
2	Agent searches the same thing forever	5 layer loop detection
3	One query phrasing is a single point of failure	Query inflation to 3 distinct angles
4	Retrieval invents APIs	Separate fact check and research tools
5	Agent ignores retrieved findings	Explicit finish gates before answering

Every single one of these fixes is 20 lines of code in the harness. None of them require changing the model.

This is the dirty secret of production agents. 90% of your reliability gains will come from 100 lines of boring code in the harness, not from better models or better prompts.

Agent security is now a solved problem for enterprises

Uber open sourced ADR this month. It is the agent security system they run in production across 200,000 employees.

ADR does not try to stop agents from doing bad things. It observes everything they do, detects bad behaviour after one step, and stops them before the action executes.

It has four components:

1. Sensor that hooks every agent runtime on every employee machine
2. Normalized telemetry schema for agent actions, tool calls and traces
3. Two tier detector that combines fast triage with deep agentic reasoning
4. Benchmark with 303 real attack scenarios

ADR detects 92% of agent attack techniques with a 0.7% false positive rate. This is good enough to run unmodified coding agents on enterprise workstations.

If you are deploying agents inside a company today you should be running this.

Deployment tooling finally exists

Until last week deploying an agent to Slack required 300 lines of boilerplate, three webhooks, retries, state management and half a dozen permissions. Now it takes 12 lines of code.

The CopilotKit Channels SDK abstracts every messaging platform behind one interface. You write your agent once. It runs on Slack, Teams, Discord, Telegram and WhatsApp without modification.

It handles retries, deduplication, state persistence, native UI rendering and human in the loop approvals. It works with every existing agent framework.

This is the layer that was missing. For the first time you can spend 90% of your time building the agent, not wiring it up to platforms.

Post training for agents just got 8x cheaper

Training tool using agents used to require enormous amounts of GPU memory. Gradient based methods like GRPO need to hold the entire model and optimizer state in memory for every worker.

CoPES changes this. It decomposes the full parameter space into independent low dimensional subspaces and searches them cooperatively with evolutionary strategies. Under identical GPU hour budgets it recovers 92% of GRPO's accuracy gain while using less than one eighth the memory.

You can now post train a 4B tool using agent on a single consumer GPU. This was impossible three months ago.

What no one is talking about

There is one gaping hole in all of this work. No one has a good answer for agent alignment over long time horizons.

All of the systems described here work great for agents that run for hours or days. None of them work for agents that run for weeks or months. Preferences drift. Objectives rot. Evidence goes stale. Agents slowly drift away from what you actually asked them to do.

There are no papers on this. There are no open source implementations. Everyone is encountering this right now and no one is talking about it.

That is the next problem.