# What is rote?

> Rote turns a successful agent run into a Play that is deterministic, cheaper in tokens, more secure, and easy to share across your team.

## The problems it solves

Agent work today fails in four ways. Rote exists to remove each one.

1. **Flaky.** The same request, run twice, takes two different paths. Teams chain non-deterministic models and tools, expect one method, and get a new one each time.
2. **Expensive.** Every run pays for discovery again. More tool calls and more turns than planned, and a bill that changes from run to run.
3. **Ungoverned.** A rule for an agent is a request, not a guard. The agent can be asked not to write and still write.
4. **Hard to share.** Good agent work stays in the chat where it happened. Engineering keeps it. Sales, marketing, and ops start from zero.

## What rote is

Rote records the run, drops the failed paths, and keeps the successful one as a Play. A Play is a saved, runnable unit of work. It follows the same method every time and costs a fraction of the tokens.

Rote is not an AI model and not an agent harness. It works inside Claude Code, Codex, Cursor, Kimi, Hermes Agent, and Pi Coding Agent, and through its own CLI.

## What a Play is

Same method. Fresh inputs. New answer. The step graph and tool path stay fixed. Fixed values from the original run become typed inputs. The Play returns a new result, never the old one.

A Play is:

- **inspectable:** inputs, dependencies, access, writes, and privileged requirements are declared before execution;
- **deterministic in method:** the proven step graph and tool path are preserved while inputs can change;
- **versioned:** an unversioned URI resolves to the latest release, while `@version` pins an immutable release;
- **portable:** the URI can move through chat, documentation, a runbook, or another supported agent harness;
- **owned and permissioned:** a Play can be personal or organization-owned, public or private;
- **honest about results:** human, summary, and JSON presentations report completed, failed, blocked, skipped, or degraded work.

## What a Play lets you do

Each manifest field exists for something the runner can do. This is the guard a written rule could not be.

| You can | Manifest field | Why it matters |
|---|---|---|
| Take fresh inputs | `parameters` | New values every run. No re-exploring the task. |
| Keep credentials local | `auth` | Your credentials never leave your machine. |
| Pin a release | `version` | An unversioned URI takes the latest. `@version` never changes. |
| Know who wrote it | `owner`, `author` | Author and owner are declared, not guessed. |
| Verify before it runs | `digest` | The digest is checked before a single step runs. |
| Refuse undeclared writes | `declared_writes` | It cannot write what it did not declare. |

## How it works

1. An agent reaches APIs, local processes, or browser interfaces through rote inside a workspace.
2. The workspace records successful and failed responses as immutable, queryable evidence.
3. rote crystallizes the successful trace into a Play with typed inputs, declared steps, dependencies, requirements, effects, and presentation.
4. Another permitted agent invokes the Play URI with fresh inputs, possibly on a lower-cost model.
5. The URI can move to another agent, a team, or the public community without carrying credentials.
6. If the Play's assumptions no longer hold, the agent reasons again and can preserve the new successful path as the next version.

## Where the Play URI can go

Pay frontier prices once, for discovery. Every repeat runs on a cheaper model. The URI can go to:

- **a lower-cost model**, which recalls the method at a fraction of the tokens;
- **a teammate**, who runs the same method with their own credentials;
- **the community**, which can inspect the Play and publish the next version.

One URI. Fresh inputs. Local credentials.

## When reality changes

Recall stops when reality changes. Before any step runs, the Play checks its assumptions against current conditions. If they hold, the agent recalls the known path with no reasoning. If they do not, the agent stops following the Play, reasons again, and the successful new path becomes version two. A Play follows the proven path while the path holds, and says so when it does not.

## Evidence

Measured on `modiqo/hello`: the first frontier run spent 14,900 reasoning tokens. Every Play run after spent about 300. That is 98 percent less reasoning.

For the runner it means three things. The run is predictable, with the same steps and tool path. It uses fewer tokens, on a cheaper model. It carries less risk, because the Play cannot wander or write what it did not declare. The [FAQ quick answers](https://www.modiqo.ai/faq/quick-answers) state the method.

Three published Plays anyone can run today:

| Play | A fresh agent would | The Play does |
|---|---|---|
| [Website launch readiness](https://play.modiqo.ai/modiqo/website-launch-readiness@1.1.2) | re-explore DNS, TLS, headers, metadata, and Lighthouse every run | 8 known steps, read-only, same path each time |
| [Summarize stacked GitHub PRs](https://play.modiqo.ai/modiqo/summarize-stacked-github-prs@0.2.1) | rediscover the stack every run | 3 known steps, reads only |
| [Retrieve rideshare receipts](https://play.modiqo.ai/modiqo/retrieve-rideshare-receipts@0.1.6) | search, dedupe, and total from scratch every run | 4 known steps with local Gmail credentials and consent |

## What rote is not

- It is not an AI model.
- It is not an agent harness and does not replace the user's harness.
- It is not only a prompt or instruction library.
- It is not a transcript archive.
- It is not a drag-and-drop reconstruction of work after the fact.

## Comparisons

| Compared with | Difference |
|---|---|
| Prompt | A Play declares execution, dependencies, effects, and requirements instead of relying on prose alone. |
| Skill | A skill guides how an agent should think; a Play preserves a specific executable method that worked. |
| Script | A Play adds typed inputs, effects, evidence, presentation, ownership, permissions, and versioned distribution. |
| Agent framework | rote works across existing harnesses and makes validated execution portable. |
| Workflow builder | The author performs the work once in a recorded workspace and crystallizes the successful trace. |

## Who uses it

- Developers and operators who see agents repeat the same work.
- Experts who want their methods to be inspectable, runnable, and shareable.
- Teams that need reusable work to remain with an organization when members change. The work engineering already proved reaches sales, marketing, DevOps, and AgentOps through one shared library. Each team keeps its own harness and credentials.
- Enterprises that need identity, approvals, audit, policy, deployment boundaries, or contractual assurance.

## A minimal example

The Play URI is the interface:

```text
https://play.modiqo.ai/modiqo/hello
```

Inspect it:

```bash
rote play inspect https://play.modiqo.ai/modiqo/hello
```

Run it:

```bash
rote play run https://play.modiqo.ai/modiqo/hello
```


## Field notes on reusable procedures

Five essays explain how a run becomes a reusable procedure, in order:

- [How a successful AI agent run becomes a reusable procedure](https://www.modiqo.ai/blog/how-an-agent-run-becomes-a-reusable-procedure.md): the five steps from a working trace to a Play URI.
- [Agent skills, workflows, prompts, and Plays remember different things](https://www.modiqo.ai/blog/agent-skills-workflows-prompts-and-plays.md): which container to use for what must survive the next run.
- [How to extract a reusable procedure from an agent trace](https://www.modiqo.ai/blog/extract-a-reusable-procedure-from-an-agent-trace.md): the five compile operations and the four conditions that block them.
- [Agent procedure memory survives a model change only as a program](https://www.modiqo.ai/blog/agent-procedure-memory-survives-a-model-change.md): why a Play runs from any model and stops when the API drifts.
- [Share an agent workflow with a teammate without sharing a credential](https://www.modiqo.ai/blog/share-an-agent-workflow-without-sharing-credentials.md): what travels with a Play URI and what stays on the runner's machine.

## Canonical links

- Human-readable product guide: https://www.modiqo.ai/agent/product/
- First-run tutorial: https://www.modiqo.ai/agent/tutorial.md
- Public pricing: https://www.modiqo.ai/agent/pricing.md
- Developer documentation: https://www.modiqo.ai/docs/README.md
- Public Play registry: https://www.modiqo.ai/feeds/public-plays.v1.json
- Live public Play registry: https://www.modiqo.ai/api/public-registry