How a Play is born.
An agent is a model in a loop. Rote gives that loop a computer, a workspace, a graph of what it did, a steer when it slips, and, when the goal is met, a Play. Thirteen beats on one landscape.
SCROLL, OR USE ← → TO MOVEBACK TO THE CATALOG →
An agent is a model in a loop.
Reason picks the next move and the tool for it. Act touches the world through that tool, sees what happened, and reports back. Round and round until the goal is met.
# claude code, codex, or your own harness# reason → act → reason → act, until the goal is met# rote is the hands: everything it touches is on the record
Nothing keeps how.
The loop finds a path, then forgets it. The next run pays for the same discovery again, in tokens and in time, and may land somewhere else.
$ ls ~/.claude/skills/release-brief/SKILL.md triage-outage/SKILL.md$ head -2 ~/.claude/skills/release-brief/SKILL.md# Read the latest release, then compare the PRs merged since…# a skill is prose: read again on every run, ~2,400 tokens each time,# and followed probabilistically. the path itself is never kept.
Let the agent explore. Then compile what worked.
Reinforcement learning keeps the moves that led to the reward. A compiler turns one working program into something that runs the same way every time. Rote lets the agent reflect on its own run, keeps the path that worked, and writes it down as a program.
# reinforcement learningagent: π(a | s) # acts on what it seesenvironment: s′, r ← step(s,a) # answers, with rewardgoal: max Σ γᵗ·rₜ # keep what earned it# compilersyntax: source → tree # what was writtencontrol: tree → order # what happens, whenflow: values → next use # what feeds what# rote: the run is the source · the kept path is the program
Rote is a universal CLI that lets the agent use the computer.
API and MCP, browser, and shell, through one gate. Credentials stay on the machine, writes are guarded, and every call is recorded.
rote adapter call github pulls.list owner=modiqo repo=rote state=openrote proc run gh release view --json tag,bodyrote browse https://github.com/modiqo/rote/releases# credentials by name · writes guarded · every call recorded
First, a workspace.
Every run gets a place of its own. What the agent learns here is kept here, and nothing leaks out of it.
rote init weekly-release-brief --seq# open the recorder: you are now on the record# every call from here lands in this workspace as @1, @2, @3 …
The agent picks the tool. Rote makes the call.
Browser, shell, or API, the agent decides what fits. Each call and its result come back as one context unit, and the units settle in the workspace.
rote adapter call github pulls.list owner=modiqo repo=rote state=open# @1 captured · 14 pullsrote proc run gh release view --json tag,body# @2 captured · exit 0 · 0.4srote browse https://github.com/modiqo/rote/releasesrote browse snapshot# @3 captured · page snapshot
Units connect into a graph.
Each unit knows what came before it and what it fed. The run stops being a transcript and becomes a structure rote can reason about.
rote query @2 '.stdout.text | fromjson | .tag' -s tagrote query @1 '.[0].number' -s pr_numberrote workspace inspect deps# @4 ← @2 · @5 ← @1, @4 · @6 ← @3, @5
Mistakes are steered, not repeated.
When a branch goes wrong rote notices and pulls the agent back. An expert can step in and point at a better path.
rote query schema @2# don’t guess the shape: askrote query @7 '.items[0].id' -r# @7 · 404 · the branch stops hererote play pending write weekly-release-brief \--notes "release notes come from @2, not the changelog page"
The goal is met. The path is clear.
Of everything tried, one path worked. Rote keeps that one, and the land remembers it as a valley.
rote workspace inspect log# @1 @2 @4 @5 @6 @8 @9 → kept# @3 @7 → dead ends, evidence onlyrote workspace export weekly-release-brief --params repo,since# dead ends removed · fixed values → parameters · dependencies kept
The path becomes a Play.
Steps, tools, parameters and guard, in one file. It is catalogued into the agent’s memory, and it can be shared with anyone.
rote play lint main.tsrote play run main.ts repo=modiqo/rote since=7drote play release weekly-release-brief# draft → released · ~/.rote/flows/weekly-release-brief/main.tsrote registry play push main.ts modiqo# → https://play.modiqo.ai/modiqo/[email protected]
Switch the model. Switch the harness. The Play stays.
Claude today, Codex tomorrow, an open-weight model on your own hardware. The ground changes under it and the same Play runs the same way.
rote play run https://play.modiqo.ai/modiqo/weekly-release-brief \repo=modiqo/rote since=7d --yes# claude code · 7 steps · same result# codex cli · 7 steps · same result# your own harness · 7 steps · same result
Determinism, fewer tokens, shared expertise.
The same steps every time. The discovery paid once. And an expert’s way of doing things, kept, and made available to the rest of the world.
rote play inspect https://play.modiqo.ai/modiqo/weekly-release-brief# steps 7 · reach shell, api · guard read-only# parameters repo, since · credentials by name# discovery paid once · shareable by uri
Every Play in the catalog began this way.
Scroll the catalog and every mark you see is one of these valleys, kept.
rote play search "release brief" --source registryrote registry play pull modiqo/weekly-release-brief --yesrote play run modiqo/weekly-release-brief repo=your/repo since=7d