# What is rote?

> rote is a method layer for AI agents. It turns a successful execution trace into an inspectable, versioned Play that another permitted agent can run with fresh inputs.

## The problem

An agent can reason well, use the right tools, recover from errors, and finish a task. When the session ends, the result usually survives but the useful path does not. The next run spends reasoning to rediscover the same method and may repeat the same mistakes.

rote preserves the method that worked—not the whole transcript.

## How it works

1. An agent works through APIs, local processes, or browser interfaces inside a workspace.
2. The workspace records each response 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.
5. Versions and execution evidence make the method inspectable, shareable, and repairable.

## What a Play is

A **Play** is a saved, runnable unit of work. It 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 rote is not

- It is not an AI model.
- It is not an agent framework 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 as a reusable method layer. |
| 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.
- 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
```

## 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