Every production ML team I talked to last month had exactly the same story. They built a demo agent in three days. It worked perfectly on the happy path. Then they tried to run it for real. It forgot context after 12 steps. It called the wrong tool half the time. When they added a second agent they started arguing endlessly and never finished anything. Everyone agreed agents are the future. No one could ship one.

That changed this week. Over 72 hours six separate releases landed that fix every one of these core blocking problems. None of them are marketing demos. All have working code, independent benchmarks, and production deployment paths. This is not another incremental improvement. This is the baseline agent stack that most teams will standardize on over the next year.

The three unsolved agent problems

Until this week every production agent deployment failed for one of three reasons:

1. Memory was passive. Agents got a blob of context injected at the start of a run. They could not update it, query it, or resolve contradictions. After 8-12 steps all long running agents degenerated into confusion.
2. Tool selection was semantic. Every framework exposed every tool that matched a keyword. Agents would call a search tool 17 times in a row instead of just calculating the answer. 90% of token spend went to reading tool descriptions no one ever used.
3. Multi agent evaluation measured only task success. No one tested if agents could coordinate, establish common ground, or repair misalignment. Teams would run benchmarks, get 92% success rate, then watch the system fail 100% of the time in production.

Every framework vendor promised they would fix these. None did. All of them got fixed this week, by independent teams.

MLEvolve: long horizon agents that learn across runs

The first paper is MLEvolve, a multi agent framework built for 12+ hour continuous runs. This is the first agent system that reliably improves over time instead of degrading.

Most existing agent search works like a naive tree. Each branch runs in complete isolation. Good ideas discovered on one path are never reused. Agents will repeat the same failed experiment 12 times on different branches.

MLEvolve replaces tree search with Progressive MCGS, a graph structure that adds reference edges between branches. When an agent discovers a useful modification anywhere in the search space, every other agent sees it immediately. There is no reset between runs.

They also added Retrospective Memory, a two layer system that combines a static domain knowledge base with a dynamic global memory that accumulates every success, failure, and observation across the entire run. Memory is not injected. Agents query it explicitly.

On MLE-Bench MLEvolve hit 71% valid submission rate under 12 hours. The previous state of the art was 38%. It also beat AlphaEvolve on mathematical algorithm discovery, despite being a general purpose agent framework.

This is not a research toy. You can run this today. The code is on GitHub, fully open source.

CollabSim: stop measuring the wrong thing for multi agents

Multi agent systems do not fail because individual agents are bad at reasoning. They fail because agents are bad at being on a team.

The CollabSim paper formalized this for the first time. They ran controlled experiments across four base models and found that task success rate had zero correlation with production reliability. What correlated perfectly was collaborative competence: the ability to establish common ground, update shared understanding, admit mistakes, and hand off work correctly.

Until this week there was no way to measure this. All existing benchmarks just checked if the task got done. CollabSim instead runs controlled simulation conditions, probes agent internal state at every step, and scores teams on 11 separate collaboration metrics.

In their first run they found something that should surprise no one who has ever deployed a multi agent system. GPT-4o had the highest individual task performance. It had by far the worst collaborative performance. It would lie about progress, refuse to delegate, ignore corrections, and overwrite work done by other agents. Claude 3.5 Sonnet scored 18% lower on individual tasks, and 62% higher on team performance.

This is the reason most multi agent demos fall apart when you run them for real. Everyone builds their tests on individual task benchmarks. No one was measuring the thing that actually determines success.

Causal minimal tool filtering: stop showing agents every tool

Tool selection is broken. Everyone knows this. If you give an agent 100 tools it will spend 80% of its tokens reading tool descriptions, and call the wrong one 40% of the time.

All existing fixes do the same thing: semantic search. They show the agent the 5 tools most semantically similar to the current query. This does not work. A tool can be semantically relevant and completely unnecessary for the current step.

The ToolChoiceConfusion paper introduced Causal Minimal Tool Filtering. This method does not look at semantic similarity at all. It uses simple precondition / effect contracts for every tool, and only exposes the exact set of tools that can advance the current state towards the goal.

In their benchmark with 100 tools and 102 tasks, CMTF matched the maximum possible task success rate. It reduced average visible tools per step from 100 to 1. It reduced total token usage by 91% relative to exposing all tools.

This required no fine tuning, no additional model calls, and works with every existing LLM backend. There is literally no reason to ever use semantic tool filtering again. This is a strict improvement across every metric.

Memanto: active memory for long running agents

Memory is the worst part of every agent framework. All existing implementations are just vector databases with a wrapper. They are passive. The agent has to remember to query them. They have no concept of time, confidence, or provenance. They will happily return a fact from 6 months ago with exactly the same weight as something the user said 10 seconds ago.

Memanto fixes this. It is not a vector database wrapper. It is an active memory agent.

Memanto implements six fixes that every agent developer has been asking for for two years:

1. Memory is queryable, not injected as a context blob
2. All entries have recency weighting and temporal bounds
3. Every memory includes confidence score and provenance
4. Memory is typed into 13 separate categories including facts, decisions, preferences, and errors
5. Conflicting entries are detected and flagged instead of silently overwritten
6. Memory is available for search the instant it is written. No indexing delay.

On LongMemEval it scored 89.8%. The next best system scored 76.2%. On LoCoMo it hit 87.1% vs 71.4% for Mem0.

Most importantly, it has exactly three operations: remember, recall, answer. There is no graph schema to design, no reranker to tune, no chunking parameters to adjust. You install it with pip and it works.

AstrBot: the production agent runtime no one is talking about

If you want to actually deploy an agent to real users this week, you will use AstrBot.

AstrBot is an open source agent runtime that was trending at #1 on GitHub all this week, and almost no one in the English speaking ML world has noticed it yet.

It is not another framework. It is a complete production runtime. It has native integration with every major LLM, every major chat platform, a secure agent sandbox, plugin system, context compression, and built in memory. It supports Dify, Coze, Bailian and every other agent backend.

You can deploy an agent that works on Slack, Telegram, WeChat, Discord and 11 other platforms in 5 commands. It has already been deployed in production by over 1200 teams according to their issue tracker.

This is the most mature production agent runtime that exists today. Stop building your own wrapper. Use this.

Claude Code is not a chatbot

Almost everyone who installed Claude Code is using 10% of its capabilities. Most people use it to ask questions about their code. That is the least interesting thing it does.

The claude-howto repository landed this week, and it is the single most useful agent resource released this year. It is not documentation. It is a structured learning path that walks you through every feature of Claude Code, with production ready templates you can copy paste directly into your project.

If you work through the full path you will learn to wire slash commands, memory, skills, hooks, subagents and MCP servers into fully automated pipelines. You can build a production code review agent that runs automatically on every PR in about two hours.

The most important thing this guide makes clear: Claude Code is not an assistant you chat with. It is an agent orchestration runtime.

What everyone is actually building

The 500 AI Agents Projects repository was published this week. It is exactly what it sounds like: 500 working, runnable agent implementations across every major framework and industry.

This repository answers the question no analyst will give you a straight answer to: what are people actually using agents for right now?

As of this week the most common production agent use cases are, in order:

1. Automated code review
2. Meeting summarization and action item extraction
3. Security scanning
4. Customer support triage
5. Documentation generation
6. Research literature review

LangGraph is the most used framework for production deployments. CrewAI is the most used for prototyping. AutoGen is almost exclusively used for research.

What you should deploy this week

You do not need to wait six months for this to mature. You can deploy working production agents this week using this exact stack:

1. Use Memanto for agent memory
2. Use Causal Minimal Tool Filtering for tool selection
3. Use Claude Code for single agent orchestration
4. Use MLEvolve for long horizon multi agent runs
5. Deploy on AstrBot for end user access
6. Evaluate multi agent teams with CollabSim

None of this is experimental. All of it has working code, verified benchmarks, and production deployments today.

What comes next

We just crossed an invisible line. For the last two years agents have been demo technology. Starting this week they are production technology.

There will still be bugs. There will still be edge cases. But the core blocking problems are solved. The baseline stack is now known. Over the next 12 months we will stop arguing about if agents work, and start arguing about how to operate them reliably at scale.

If you are building agents right now, stop what you are doing. Go look at these repositories. This is what everyone will be using by the end of the year.