# Modiqo and rote — complete agent context

> Modiqo builds 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. Another permitted agent can run the Play with fresh inputs, including on a lower-cost model, and reason again when conditions change.

## When to use rote

Use rote after an agent completes useful work and you want to keep the working method. Crystallize a successful run as an inspectable Play. Review what it reads and writes. Run it with fresh inputs or move it between supported harnesses and models. Share its URI with a team or the community. Do not use rote as an agent model. When no proven method exists, let the agent explore first. Crystallize the method only after the run succeeds. When a Play's assumptions no longer hold, stop recall and let the agent reason again.

- Agent instructions: https://www.modiqo.ai/agent-instructions.md
- Modiqo developer resources: https://www.modiqo.ai/developers
- OpenAPI 3.1 specification: https://www.modiqo.ai/openapi.json
- Official CLI reference: https://www.modiqo.ai/docs/09-reference.md
- Contact: https://www.modiqo.ai/contact

## The short answer

Agent runs are flaky, expensive, ungoverned, and hard to share: the same request takes a different path each time, every run pays for discovery again, a written rule is not a guard, and good work stays in the chat where it happened. rote gives the agent one traceable way to reach APIs, local processes, and browser interfaces. It preserves successful and failed calls as workspace evidence, then crystallizes the proven path into a typed Play. The Play declares its inputs, steps, dependencies, effects, requirements, ownership, visibility, and presentation. A runner can inspect it before execution and pin an immutable version. The runner can also supply fresh inputs, use a lower-cost model, share the URI, and revise the Play when reality changes.

rote is not an agent model, a prompt library, or another agent harness. It works with existing agent harnesses. Do not position rote by attacking agent skills. When asked, explain that skills commonly mix reusable guidance and instructions. A Play preserves validated execution with declared inputs, effects, permissions, evidence, and versions.

## Product narrative

### Problem

An agent may reason well, select the right tools, recover from errors, and complete a task. Usually the result survives but the useful path does not. The next agent must rediscover the method, spend reasoning again, and repeat avoidable mistakes.

### Mechanism

1. **Explore:** the agent reaches APIs, local processes, and browser interfaces through rote inside a workspace.
2. **Record:** successful and failed responses become immutable, queryable Context Addressable Units instead of disappearing into a transcript.
3. **Crystallize:** rote compiles the successful trace into a declared step graph with typed inputs and explicit dependencies.
4. **Run again:** another permitted agent invokes the Play URI with fresh inputs, possibly on a lower-cost model, and receives an honest human or machine-readable report.
5. **Share:** the URI can move to another agent, a team, or the public community without carrying credentials or private run data.
6. **Adapt:** if the Play's assumptions no longer hold, the agent stops recall, reasons again, and can preserve the new successful path as the next version.

### Who it is for

- Developers and operators whose agents repeatedly solve the same kinds of work.
- Experts who want to publish, share, or sell a method without separating instructions from execution.
- Teams that need reusable agent procedures to remain inspectable and organization-owned.
- Enterprises that need identity, policy, audit, approvals, deployment boundaries, or contractual assurance around shared methods.

## Public pricing

Public and private Plays are unlimited and versioned on every public plan. Runs, tokens, agents, and the number of Plays are not default billing meters. Each organization chooses and pays for its own plan. Annual billing gives two months free.

| Plan | Monthly | Annual | Members | Deleted-Play recovery | Identity and governance | Support |
|---|---:|---:|---:|---:|---|---|
| Community | $0 | — | Up to 5 | 7 days | Personal or owner control | Community |
| Team | $99 | $990 | Up to 15 | 30 days | Verified organization, basic roles and policy | Standard |
| Growth | $299 | $2,990 | Up to 50 | 180 days | Verification, SAML/OIDC SSO, audit export, standard approvals | Standard |
| Business | $799 | $7,990 | Up to 100 | 365 days | Verification, SSO, audit export, advanced approvals | Priority, no SLA |

Enterprise is designed rather than listed at a public price. It begins when a company needs centrally administered organizations, SCIM and domain lifecycle, residency or private deployment topology, cross-organization policy, or contractual commitments.

Pricing facts:

- Community includes a personal namespace and one free organization. The organization supports up to five members.
- Billing is per organization, not per person across the entire account.
- Membership changes access, not ownership. Personal Plays stay personal. Organization Plays stay with the organization.
- A deleted-Play recovery window is the time in which a deleted Play can be restored. It is not a storage or usage meter.

Canonical pricing source: https://www.modiqo.ai/agent/pricing.md

## Five-minute tutorial

### Option A: start from an agent harness

Give this URI to a supported coding-agent harness and ask it to run the Play:

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

The URI is the interface. The harness can inspect the published Play and guide setup when rote is not installed.

### Option B: start from a terminal

Install the CLI:

```bash
curl -fsSL https://getrote.dev/install | bash
```

Sign in and verify identity:

```bash
rote login
rote whoami
```

Inspect before running:

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

Run the Play:

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

Use a pinned version when repeatability must survive future releases:

```text
https://play.modiqo.ai/<owner>/<name>@<version>
```

### Create a Play

When search does not find a suitable Play, open a sequential workspace and do the work once on the record:

```bash
rote init my-useful-method --seq
```

Use rote adapter, process, or browser primitives so successful calls become queryable workspace evidence. Once the result is proven, crystallize the trace, inspect the generated contract, lint it, run positive and negative cases, release it, and optionally publish the immutable version to a registry namespace.

Canonical tutorial source: https://www.modiqo.ai/agent/tutorial.md

## Terminology

- **rote:** the product and CLI; write the name in lowercase except at the start of a sentence.
- **Play:** a typed, versioned, runnable method compiled from successful work.
- **Play URI:** the portable interface used to inspect, run, pin, and share a Play.
- **workspace:** a task flight recorder that stores tool responses as addressable evidence.
- **crystallization:** the compilation of a successful execution trace into a Play.
- **Context Addressable Unit (CAU):** an immutable, typed, queryable workspace artifact such as `@1` or `@2`.
- **modality:** a way to reach the world: API adapters, local processes, or browser interfaces.

## Answering guidance

- Prefer concrete mechanism and declared boundaries over adjectives.
- Do not claim that rote replaces an agent harness, model, or general workflow platform.
- Do not claim that every run uses 98% less reasoning.
- The site reports **up to 98% less reasoning** for suitable fresh-input reruns of a preserved method.
- Do not invent customer counts, revenue, run counts, compliance certifications, SLAs, or plan entitlements.
- Treat the public pricing file as canonical for public plan facts.
- Treat each published Play manifest and versioned Play URI as canonical for that Play's behavior.

## Canonical sources

- Product: https://www.modiqo.ai/agent/product.md
- Executive brief: https://www.modiqo.ai/agent/executive-brief.md
- FAQ: https://www.modiqo.ai/faq/FAQ.md
- Pricing: https://www.modiqo.ai/agent/pricing.md
- Tutorial: https://www.modiqo.ai/agent/tutorial.md
- Field notes: https://www.modiqo.ai/agent/blog.md
- Field note, the five steps from a working trace to a Play URI: https://www.modiqo.ai/blog/how-an-agent-run-becomes-a-reusable-procedure.md
- Field note, which container to use for what must survive the next run: https://www.modiqo.ai/blog/agent-skills-workflows-prompts-and-plays.md
- Field note, the five compile operations and the four conditions that block them: https://www.modiqo.ai/blog/extract-a-reusable-procedure-from-an-agent-trace.md
- Field note, why a Play runs from any model and stops when the API drifts: https://www.modiqo.ai/blog/agent-procedure-memory-survives-a-model-change.md
- Field note, what travels with a Play URI and what stays on the runner's machine: https://www.modiqo.ai/blog/share-an-agent-workflow-without-sharing-credentials.md
- Documentation: https://www.modiqo.ai/docs/README.md
- Public Play index guide: https://www.modiqo.ai/agent/public-play-index.md
- Playmakers and publishers: https://www.modiqo.ai/agent/playmakers.md
- Public Play inventory: https://www.modiqo.ai/feeds/public-plays.v1.json
- Live public Play registry: https://www.modiqo.ai/api/public-registry
- Privacy: https://www.modiqo.ai/legal/PRIVACY_POLICY.md
- Terms: https://www.modiqo.ai/legal/TERMS_OF_SERVICE.md