Most research teams now use AI agents for recurring work: ranking candidates, recommending settings for the next run, planning a batch, reviewing an analysis. The work repeats every week. In most setups the agent stays as it was. On its hundredth task it behaves as it did on its first, and the mistake an expert corrected last month comes back this month.
This post is about agents that get better with use: what that should mean for a research team, how MS Duplex makes it happen with the agents you already run, how one verified result turns into a method the whole team reuses, and how to judge the improvement on your own work.
What “better with use” should mean
For a research team, the useful test is narrow. The agent’s behavior should change because of results your work has confirmed, and you should be able to see which results caused which change. Fluency and confidence are beside the point. Improvement in research shows up as fewer runs spent on approaches the team already knows fail, better first choices on recurring decisions and fewer corrections for the same kind of error.
In MS Duplex, the measure is the outcome. A test passes, a measurement comes back, an expert approves a conclusion or corrects it and says why. Those confirmed outcomes are what your agents learn from, and they are also what each change in behavior is judged against. The agent’s own sense of how well it did is not evidence.
- A test or check that passes or fails on the agent’s proposal
- A measurement or simulation result from a run the agent planned
- An expert’s approval of a conclusion
- An expert’s correction, with the reason behind it
Your team chooses which of these outcomes MS Duplex captures, and your scientists and engineers decide what is adopted. Your rules come first.
How an agent’s behavior changes, round by round
For the team, little about the day changes. Your agents keep working through the tools they use today, in Claude, Codex, Cursor, another agent that speaks MCP, or your own agents through the API and Python SDK. MS Duplex sits beside the model, with its weights left as they are, and takes in the outcomes as they arrive. Each confirmed result is learned from the next request on.
Two changes follow. What worked moves to the front: the next time a similar case comes up, the approach behind a confirmed success is among the first things the agent tries. What failed stops being proposed under the conditions where it failed. The second half matters as much as the first. A setting that fails beyond a known operating range may be fine inside it, so MS Duplex keeps the conditions with the failure and holds the setting back only where they match.
Say a team’s agent recommends settings for the next run of a recurring evaluation. Over a few rounds, the pattern could look like this:
- A mixed first roundThe agent recommends settings for eight runs. Five pass the team’s acceptance check. Three fail, all with the same setting pushed past the range where the method holds. The team confirms both sets of results.
- A narrower second roundThe agent starts from the settings behind the five successes and leaves the failing setting out where the conditions match. Fewer runs go to an outcome the team has already seen.
- A correction with a reasonA reviewer corrects one recommendation and records why: a check the agent skipped matters for this kind of input. From the next request, the agent includes that check on inputs like it.
- A better first choiceAn unusual combination succeeds where the usual first choice fell short. The new approach takes its place at the front, tied to the run that justified it.
- A review with the record openThe lead opens the record and sees each change in the agent’s behavior, when it happened and which outcomes caused it.
None of this waited for a training run, a prepared dataset or someone rewriting the agent’s instructions. The agent improved between reviews, because the evidence kept arriving between reviews.


From one verified result to a method the team reuses
Some of what an agent learns is a preference: try this first, hold that back here. Some of it is a whole procedure. A researcher settles on a sequence of checks that catches a bad input before it spends a run, or a way of preparing data that makes a comparison between designs fair. Once a test or an expert confirms the procedure works, MS Duplex keeps it as a method, with its steps, the conditions they were confirmed under and the result that proved them.
A method is used in one of two ways, depending on how close the next case is.
The next case like it
Where the conditions match the ones the method was confirmed under, the agent applies it directly. A colleague’s agent on the same kind of task gets the same proven steps, so the result depends less on who happened to run the work.
A related case
Where something differs, such as a new input format, a different tool or a wider operating range, MS Duplex adapts the method to the new conditions and proposes it for checking before anyone relies on it. Once the adapted version is confirmed, it becomes a method of its own. Over time a team builds a family of related methods, each tied to the result that proved it.
Methods your team trusts are shared with the people and agents your rules allow. A method can stay with one researcher, be shared with a team or become a standard across the organization. Each one is re-verified where it is used, so a procedure proven in one setting is checked again in the next before it is trusted there. A new team member’s agent begins with the team’s best methods already in place, and when an expert moves on, the methods they worked out stay with the team.


Seeing why the agent changed
An improvement your team cannot trace is hard to trust and harder to defend to the people who fund the work. MS Duplex keeps every change in behavior on record: what the agent now does differently, since when and which outcomes justified it. Every method keeps the result it rests on. When a lead asks why the agent plans better runs this month than last, the answer is in the record, with its sources.
The record is also how a mistake gets fixed. Say one change rested on a single result that later proved doubtful. The team removes that one lesson, and the recommendations that depended on it go with it, while everything else the agent learned stays. Correcting a lesson works the same way: only that lesson changes.
As approaches prove themselves, more routine decisions can be settled directly from learned methods, often with no model call at all. Where the evidence is thin or the case is unfamiliar, the decision goes to your model or to a researcher, with the reason.
- +16 ptsmore accurate than a model fine-tuned for the task, on recurring work, with no training run, in MatterSpace’s controlled tests
That figure comes from MatterSpace’s controlled tests of MS Duplex on recurring work. It shows what learning from confirmed outcomes can do beside a model. What it does for your team is a question for your own work, judged by your own experts.
How to judge it on your own work
The fair test of an agent that improves with use is recurring work your team already does, measured the way your experts would measure it.
- Pick decisions that repeat and where a wrong or unnecessary run is expensive. Improvement is easiest to see where the same kind of choice comes back often.
- Agree the measure with your experts before anything runs: the cost of each accepted, reproducible result, and the expert time it takes.
- Run the same model, tools, data and budget with and without MS Duplex, side by side.
- Have your experts score the results blind, without knowing which setup produced them.
- Read the record as well as the scores: mistakes that stop repeating, corrections nobody has to make twice and methods that reach new team members.
A pilot with MatterSpace follows that pattern, on your own workflows, with your experts as the judges.
Common questions
Does the agent improve without anyone reviewing it?
It improves from the outcomes your team chooses to capture, such as tests, measurements and expert corrections, so it keeps getting better between reviews. Your scientists and engineers decide what is adopted, your rules come first and, in governed environments, the steps you select wait for a person before they run.
What is the difference between a lesson and a method?
A lesson changes what the agent tries or holds back in a given situation, such as a setting that failed under certain conditions. A method is a whole procedure confirmed to work, kept with its steps, its conditions and the result that proved it, so it can be applied directly or adapted to a related case.
Do we have to fine-tune our model?
No. MS Duplex works beside the model, with its weights left as they are, so there is no dataset to prepare and no training run to wait for. It works beside a fine-tuned model as well as a general one.
What happens to what the agent learned if we change models?
It stays with your team. The experience lives in MS Duplex, in a store your organization owns, so a new model or agent starts from the methods and lessons your team has already confirmed.


Built by MatterSpace
MatterSpace builds MS Duplex for scientists, researchers and engineers in every field, so the AI they already use learns from every result they confirm.









