Self-optimising AI agents are considered the next step after classic prompting: systems that iteratively adapt their own instructions, processes or tools in order to get better at a task. In benchmarks – standardised test collections on which models are compared – the results often look impressive. A study by Google researchers now suggests that part of this improvement has less to do with genuine capability than with memorisation.
With RRSI, the researchers describe an approach that makes precisely this effect visible and deliberately slows it down. The finding: agents that are allowed to improve themselves over many rounds adapt strongly to the specific test tasks. On tasks they have not seen before, however, they fall behind.
Memorising instead of generalising
The difference between memorising and generalising is central to practical use. Memorising means: the system finds a solution that works exactly for the test cases at hand – for example a very specific prompt formulation or a hard-wired sequence of steps. Generalising means: the system develops an approach that also holds up for deviating, new tasks.
The self-improvement process initially rewards the former. Anyone who optimises exclusively against the result of a fixed task collection gets an agent that shines on that collection. The metric rises – the actual deployability does not necessarily rise with it.
According to the study, RRSI improves performance on unseen benchmarks by up to 4.7 points. At the same time, token consumption drops by around 30 percent. Tokens are the text units by which language models are billed – fewer tokens usually mean directly lower operating costs and shorter runtimes.
Why this is relevant for coding agents
Coding agents are currently one of the most common productive use cases: systems that work through tickets, write tests, update dependencies or prepare refactorings. This is precisely where the gap between test results and everyday work is large.
An agent that achieves excellent scores on a well-known example repository encounters a different world in a real project: a grown codebase, company-specific conventions, incomplete documentation, legacy baggage. If the agent's strength essentially stems from adaptation to known tasks, performance collapses exactly where it is needed.
The pattern can be transferred to other agent deployments: invoice auditing, text classification, data migration, support pre-qualification. Wherever you tune an agent using a manageable set of example cases, there is a risk that the system learns the examples and not the task.
What companies can derive from this
The consequence is less technical than organisational. It is about the way you evaluate agents before giving them responsibility.
- Separate test data. The cases on which an agent is optimised must not be the same ones on which it is accepted. Hold back a set of tasks that neither the development team nor the agent sees during optimisation.
- Measure on unseen cases. A success rate is only meaningful if it was collected on new tasks. Scores from the optimisation run itself are not suitable as acceptance criteria.
- Measure costs too. Token consumption, runtime and the number of agent steps belong in the same table as the hit rate. An agent that is one percent better and twice as expensive is not an improvement.
- Increase task diversity. The broader and more varied the cases in the optimisation phase, the harder it is to circumvent the problem through memorisation.
- Re-measure instead of accepting once. Codebases, data structures and business rules change. A benchmark value collected once ages.
Efficiency is part of quality
What is remarkable about the reported results is the combination: better transferability and lower consumption. This contradicts the widespread assumption that more quality in agents automatically means more computational steps and thus higher costs.
A plausible reading: agents that cling to test tasks produce a lot of detours – additional attempts, redundant intermediate steps, ever longer instructions. An approach that aims more strongly at transferability reaches the goal with less effort. For budget planning, this is an important indication: token costs are not just a question of price, but also an indicator of how cleanly an agent works.
Assessment with a sense of proportion
This is a research result, not a finished product. The figures cited come from a controlled setting and cannot be transferred unchecked to arbitrary company scenarios. The methodological core, however, is usable independently of this: separate what is optimised on from what is measured on.
For web and software projects, this means above all not introducing agents based on demo impressions, but based on results on cases the system did not know beforehand – ideally from your own day-to-day project work. Anyone who builds a small, held-back test set already during the pilot project and logs costs per task will recognise early on whether an agent really holds up or merely looks good.
This is less complex than it sounds and saves expensive corrections when the agent is later let loose on real tickets.