Agent procedure memory survives a model change only when the procedure lives as a program, not as a prompt or a recalled fact. A program does not care which model issues it. A Play is such a program. Rote turns a successful agent run into an inspectable, repeatable Play that can travel across harnesses, models, machines, and teams.
Models get swapped all the time. Teams move between frontier and commodity models to control spend, harnesses ship new defaults, and a vendor deprecates last quarter's version. Everything stored as prompt or memory is bound to the model that produced it and must be re-derived. Everything stored as a program carries over unchanged.
Thinking is bound to a model; acting is not
Every agent task alternates two activities. The agent thinks: it picks a tool, orders the steps, shapes the inputs. Then it acts: it calls the API, drives the browser, runs the command.
Thinking is stochastic, priced per token, and tied to the model that did it. The same request minutes apart can produce a different tool order. Acting is deterministic, costs no reasoning tokens, and does not depend on which model asked.
A procedure that stores thinking is model-bound. A procedure that stores the acts is not.
A Play stores the acts
Rote records every API call, browser step, and shell command the agent makes as a reference in one workspace. When the run succeeds, Rote compiles the trace. It removes the failed steps, turns hardcoded values into typed parameters, resolves the order, fingerprints the API contract, and emits a step graph.
No model output enters the Play. Only the calls that worked do, plus two decisions the agent made and a person can read: the parameter list and the write contract.
That is why the Play runs from any model. A path discovered in Claude Code replays from Codex, Cursor, Kimi, Hermes, OpenCode, or DeepSeek Harness. From any of them the ask is the same:
$play run the daily active users reportThe sidekick shows the version, the inputs, and the declared effects, then asks before running. It also replays from a scheduled job with no model in the loop at all:
rote play run https://play.modiqo.ai/acme/daily-active-users --yes
play recurring schedule --reference acme/[email protected] \
--cadence "every weekday morning" --why "standup number"A schedule pins one exact version, carries a stated reason, and expires by default. Nothing keeps running after everyone forgot why it started.
Discovery costs once; replay costs almost nothing
In one measured run, an agent needed about 15,000 tokens and 40 seconds to find a working path through an API. Replaying the resulting Play took about 300 tokens and 2 seconds. A task that runs weekly amortizes the discovery about 50 times a year; a daily task, about 250 times.
The number is from a single run and Modiqo has scheduled a re-measurement. The ratio is the point: the frontier model buys the method once, and commodity inference or no model at all runs it afterward.
What breaks, and what a Play survives
Three things change under an agent over time. The table shows what each change does to a prompt, to harness memory, and to a Play.
| Change | Prompt or skill | Harness memory | Play |
|---|---|---|---|
| The model is swapped | Re-interpreted; path may differ | Facts recalled, path re-reasoned | Executes unchanged |
| The harness is swapped | A person ports it by hand | Captive to the old harness | Runs from the new harness by URI |
| The API changes | Prose silently goes stale | Facts silently go stale | Fingerprint mismatch stops the run; the harness repairs it as a new version |
The third row is the one that separates a program from a recording that breaks on the first change. A Play does not override reality. It executes only where the contract still matches, and hands control back to the agent where it does not.
When the API drifts, the agent reasons again
A Play carries a fingerprint of the API contract it was compiled against. Before replay, Rote compares the live contract to the fingerprint. On mismatch the run stops and reports what moved. The harness examines the failure, and the agent re-adapts to the changed environment. You can ask the same question of a local Play without running it:
rote play health ./daily-active-usersThe new successful path is pushed as a new version of the same Play URI. Runners who pinned the old version keep it; runners on the unversioned URI get the repair. Recall removes reasoning only where reality has not moved.
Route the expensive model to discovery and the cheap one to execution
The practical policy follows from the split. Use the most capable model when the task is new, because it is buying the method. Once the method is a Play, run it from the cheapest model that can invoke a URI, or from no model on a schedule. Model routing is safe because the Play is the object you route, and it is the same object on both sides.
Questions people ask
Does harness-native memory solve this?
No. Harness memory stores facts the agent recalls and then reasons about, which still pays the reasoning cost and still binds the result to that harness. A Play executes, and its URI works from any supported harness.
What if the new model would have found a better path?
Then let it. Run the task without the Play, and if the new run succeeds, release the new path as the next version. The old version stays pinned for anyone who depends on it.
Can a Play run with no model at all?
Yes. rote play run <uri> --yes executes from a script, a CI job, or a scheduler with no model in the loop.
Does a Play carry the credentials the original model used?
No. A Play names the credentials it needs. The runner supplies their own, on their own machine.
This essay is one of five on turning a run into a reusable procedure
Start with the overview, How a successful AI agent run becomes a reusable procedure. The other essays each take one question further:
- Agent skills, workflows, prompts, and Plays remember different things: which container to use for what must survive the next run.
- How to extract a reusable procedure from an agent trace: the five compile operations and the four conditions that block them.
- Share an agent workflow with a teammate without sharing a credential: what travels with a Play URI and what stays on the runner's machine.
Install the Play sidekick and try this on your own agent
One command installs the Play sidekick, installs Rote when it is missing, and wires the skill into the agent apps it finds on your machine. It runs on macOS and Linux, and on Windows inside WSL2.
curl -fsSL https://getrote.dev/playoffs/install.sh | shRestart your agent app, type $play (or /play in Claude Code), and run the Hello Play. It uses public data, needs no credentials, and declares no writes.
Decide what your agent should never solve twice
List the tasks your agent has solved more than once this month. Each one is a procedure that lives in a model's context today and is re-derived on every run. Start each one with $play explore, settle the Play, and let the next model change pass over it.