Most research teams that use AI seriously end up keeping a file for it. It starts as a few lines about how the team names things and which tools to use. Before long it holds operating limits, preferred methods, reference values, warnings about mistakes the agent made once, and a folder of prompts that worked well for someone.
That habit is sound. This post looks at why the file helps, where it stops keeping up with the research, and what changes when the AI learns from confirmed outcomes instead of waiting for someone to edit a line.
Why teams write things down for their AI
A model starts every session from what it knew when its training ended. It has not seen your lab’s conventions, your analysis pipeline or the limit your senior scientist or engineer confirmed last month. An instruction file closes part of that gap at almost no cost. The assistant reads it at the start of each session, and the team’s most important context comes along.
A typical file for a research team holds some mix of these:
- Conventions: how files, samples and runs are named, which units to report and which format a summary should take.
- Limits: settings a method should not go beyond, inputs that need a check before use, steps that need a person.
- Preferred methods: the order of steps that gives a clean analysis, or the tool the team trusts for a given job.
- Reference values: the numbers the agent should use instead of guessing.
- Warnings: mistakes the agent made once, written down so it does not make them again.
- Prompts: wording that produced a good plan or review for one person, saved for the rest of the team.
The file is readable by anyone, easy to change and fully under the team’s control. It works with any model. For stable conventions and house style, it is hard to beat, and teams should keep it.
Where the file stops keeping up
The trouble is that research does not stay still, and a file only changes when someone edits it. As the work moves on, the same file that helped in its first month starts to cost the team in quieter ways.
- It grows long. Every incident adds a line and few lines are ever removed, so the model rereads more each session and has to judge for itself which parts apply.
- It goes stale. When a reference value changes, the old line stays until someone deletes it. If two people edit the file, both values can sit there side by side.
- Nobody knows which line still holds. A line rarely says where it came from, when it was added or under which conditions it was true. A new team member cannot tell a confirmed limit from one person’s preference.
- It has no link to outcomes. The file does not know whether its advice worked. A method that failed twice since it was written down reads the same as one that succeeded every time.
- It splits by person. Each researcher keeps a version, prompt libraries drift apart, and what one person learned stays in that person’s copy.
- It is only as good as the last edit. The agent improves when someone finds time to update the file, and not between those edits.
Careful teams run into all of these. They follow from keeping knowledge that changes with every result in a document that changes by hand. The team’s experience grows every week, and the agent stays where the file left it.
What a learned lesson carries that a line does not
MS Duplex plugs into the AI your team already uses and learns from the outcomes and expert corrections your team chooses to capture: a passed test, a measurement, an approved conclusion, a correction with its reason. It learns beside the model, with its weights left as they are, so each lesson is ready from the next request.
Where a line in a file is a sentence someone wrote, a lesson in MS Duplex arrives with what a reviewer would want to know about it:
- Its source: the result, measurement or expert judgment it came from.
- Its conditions: what held when it was confirmed, so it is applied where those conditions match.
- Its reason, for a correction: why the expert rejected what the agent proposed.
- Its history: when a newer confirmed value replaces an older one, the newer one applies and the change stays on record.
- Its reach: whether it stays with one researcher, is shared with a team or applies across the organization, as your rules decide.
The way it is used is different too. A file is reread whole and the model judges what applies. MS Duplex checks whether the conditions of the new case match before it brings a lesson back. Where they match, the lesson applies. Where something differs, it is adapted and proposed for checking, or flagged so the team can decide.


And each lesson can be handled on its own. Your team can review it, correct it and only that lesson changes, or remove it, and the recommendations that depended on it go with it while everything else stays. That is the question a long file cannot answer: which line still holds, and what depends on it.
From a line in a file to a method the team reuses
The most valuable lines in an instruction file usually describe a procedure that worked. Say a researcher on a team that ranks candidates for review works out a sequence of checks on the input data that removes a recurring error from the rankings. In a file, that becomes a paragraph someone has to find and follow. In MS Duplex, it becomes a method.
- The procedure is confirmedThe researcher’s agent runs the checks before ranking, and an expert confirms the rankings came out clean.
- It is kept as a methodMS Duplex keeps the steps with the conditions they were confirmed under and the result that proved them.
- The next case like itA colleague’s agent ranks a new batch from the same source. The method is applied directly, with nobody pasting in a paragraph.
- A related caseAnother batch arrives from a different source in a different format. MS Duplex adapts the method and proposes the adapted version for checking. Once confirmed, it becomes a method of its own.
- A new team memberA new hire’s agent starts on the same work with both methods in place, each with the result behind it, and each re-verified where it is used.
Compare that with the file. The paragraph would have helped the people who knew to look for it, and it would have said nothing about the second source until someone wrote another paragraph. The method went to the agents that needed it, was checked where the case differed and kept its evidence the whole way.


Keeping the file, adding the layer
Teams that connect MS Duplex keep working in Claude, Codex, Cursor or their own agents as before, and the file the assistant reads keeps working too. A useful first exercise is to sort what is already in it.
- Stable conventions and house style: keep them in the file. They rarely change and the file serves them well.
- Rules the work must respect: state them as rules in MS Duplex. Rules are kept apart from preferences and visible in the reasoning, a new rule applies from the next request, and in governed environments a step that breaks a rule is stopped before it runs.
- Reference values: let them come from confirmed results, so the newest confirmed value applies and the history of each change is kept.
- Procedures that worked: let them become methods, kept with the result that proved them.
- Warnings about past mistakes: capture them as corrections, with the reason and the conditions, so the agent checks them from the next request and only where they apply.
Sorted this way, the file can get shorter instead of longer. New knowledge arrives as the work confirms it, and the file goes back to holding what it is good at.
Common questions
Should we delete our instruction files?
No. Keep them for stable conventions and house style. Move rules, reference values, proven procedures and corrections into MS Duplex over time, where each one keeps its source and can be changed on its own.
How is this different from retrieval over our notes?
Retrieval finds passages that look relevant, whether they apply or not, and old and new versions of a fact can both come back. MS Duplex keeps confirmed outcomes with their evidence, checks whether the conditions match and applies the newest confirmed value, with the history kept.
Who sees a lesson one researcher’s agent learned?
That depends on your rules. Each researcher, each team and the whole organization has its own layer of experience, and your rules decide what moves between them.
Which AI tools does this work with?
Claude, Codex, Cursor and other agents that speak MCP connect directly, and your own agents and pipelines connect through the API and Python SDK. Your scientists and engineers keep the AI they already use.


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.









