Three papers published within days converge on the same point: measuring what happens when an AI agent improves from its own errors between sessions. Prime Intellect releases Prime Agent, an open source harness where the agent can rewrite its own prompts, skills, and memory during execution. OneDayAgent, a paper from the ZJUNLP team on arXiv, formalizes cross-environment persistence across 104 tasks and five different backends, with an overall score of 0.821 on GLM-5.2. A third paper, Self-Evolving Coding Agents, documents how programming agents can accumulate experience from test and repair cycles instead of starting from scratch each time.

Why this matters to you. Until yesterday, an agent that made a mistake received a correction and on the next run started with an empty memory. Self-improvement was demo speculation. Now three independent teams measure it with repeatable benchmarks: the agent that errs and then remembers achieves better scores on real tasks, not on constructed scenarios. For anyone using agents in their work, the difference is between repeating the same instructions every time and having an assistant that accumulates experience in your specific context.

It’s the same territory we explored on August 5 with three benchmarks converging on agent progression over time: the question then was whether an agent that remembers also becomes an agent that learns. These three papers bring the first concrete numbers to that question.

In detail

The starting problem is the same for all three papers. Current agentic harnesses, from coding agents to general assistants, are static: prompts, skills, memory, and sub-agents are configured once at design time and never change. When the model fails, it corrects the single output, but the experience doesn’t accumulate. The next session starts from zero.

Prime Agent addresses the problem with two abstractions. The Recursive Language Model (RLM) treats context as a variable: the agent accesses its history, sub-agents, and tools as if they were function calls in a persistent IPython kernel. The Continual Harness goes further: the agent can create, read, update, and delete its own prompts, skills, memory, and sub-agents during execution. If it discovers that a certain prompt works better for a type of task, it rewrites it on its own. It’s open source, installable with a script, and works with frontier models both open and closed.

OneDayAgent takes a more measurable route. The ZJUNLP team built a harness for long-horizon, cross-environment, and multimodal tasks: open-ended requests that span work, study, and daily life, where the agent must maintain goals and constraints across many steps and heterogeneous tools. Evaluation on AgentIF-OneDay covers 104 tasks and five LLM backends from three model families. With GLM-5.2 as backend, OneDayAgent achieves 0.881 as an overall score (new state-of-the-art on the benchmark). The relevant finding is that the same harness runs on all five backends without recalibration, even though each model induces different execution styles under the same workflow.

Self-Evolving Coding Agents (arXiv paper) documents the specific case of programming agents. Software development is a dynamic, feedback-rich environment: repositories evolve, dependencies change, tests fail, repair attempts leave reusable experience. The paper’s argument is that current agents ignore this experience by design, and that collecting it in a structured way improves performance on subsequent tasks.

The three papers complement each other more than they diverge. Prime Agent shows the architecture (the agent that rewrites itself), OneDayAgent brings rigorous measurement across multiple tasks and backends, Self-Evolving Coding Agents formalizes the most mature application domain for this approach.

The limits. None of the three is a finished product. Prime Agent is a research harness, designed for those writing code, not for the end user. OneDayAgent has 104 tasks: a useful number but not broad. Scores depend on the backend, and 0.821 with GLM-5.2 doesn’t mean all models achieve the same result. Self-Evolving Coding Agents remains a paper, with numbers to verify on real repositories, not just lab benchmarks. The jump from “the agent improves on a benchmark” to “the agent learns in your specific case” still requires infrastructure and time.

For those following the agentic memory thread, these papers fit where we left off with July’s Experience Distillation: the idea of fixing in weights or state what the agent learns. The difference is that now there’s a benchmark to measure it.