# Play field guide > Run what already works. Explore what does not. Keep the method when you find it. Play has three layers. Start as a **Playrunner**, become a **Playmaker** when the catalog has no answer, and open the **advanced controls** only when you need routing, credentials, recall, or recovery. ### Choose your lane | I want to… | Start here | |---|---| | Run a saved method | Ask for the outcome, search, or paste a Play URI | | Make a method that does not exist yet | `$play explore ` | | Recall a recent Play journey | `$play journal [today\|yesterday\|YYYY-MM-DD]` | | Take one native-tool detour | `direct: `, then `continue exploration` | | Recover or configure Play | Go to **Advanced: routing, credentials, and recovery** | ### Use the prefix your app understands | App | Play prefix | |---|---| | Codex or Cursor | `$play` | | Claude Code, Hermes, OpenCode, or DeepSeek Harness | `/play` | | Kimi Code | `/skill:play` | The examples below use `$play`. Substitute your app’s prefix. An ordinary request can also activate Play when the local catalog contains a strong match. ## Playrunner: ask, inspect, pull, run ### Your first lap ```text You: $play Play: verifies setup and offers the low-risk Hello Play You: Run Hello Play: shows the method, inputs, credentials by name, and declared effects You: Pull and run Play: runs the approved version and returns the complete result and receipt ``` Hello uses public data, needs no account credentials, and declares no writes. It proves the whole journey before you trust Play with consequential work. ### Ask for the outcome ```text retrieve my rideshare receipts between July 15 and August 15, 2026 list the top committers for modiqo/rote $play run the PostHog daily active users report ``` Play searches the cached catalog, inspects a strong match, reuses parameters already in your request, and asks only for values that are genuinely missing or invalid. ### Search by outcome, service, or adapter ```text $play find a Play that checks calendar meetings $play find Plays that use PostHog $play find Crucible Plays ``` These searches can find a method by what it accomplishes or by the service it already knows how to use. ### Run an exact Play URI ```text $play https://play.modiqo.ai/modiqo/hello ``` An exact URI skips discovery. It never skips inspection, parameter validation, or run approval. ```text Play: Ready to run the displayed Play and parameters? Pull and run — install or replace that exact version, then execute it Not now — stop without installing, authenticating, or running anything ``` Choosing a result is permission to inspect it, not permission to execute it. ### Scan the public field These are the verified fast catalog aliases: ```text $play what's new $play popular Plays $play trending Plays ``` They read the install-warmed cache without a full preflight. Requests such as `$play list`, `$play list orgs`, and `$play list plays` are conversational inventory requests. They are useful, but they are not guaranteed fast paths. ### Recall a Play journey ```text $play journal $play journal yesterday $play journal 2026-08-17 ``` The journal is deterministic recall from successful lifecycle transitions, not a reconstruction of the chat. It records the Play reference, event, timestamp, and local day. It does not store prompts, parameters, outputs, credentials, continuations, or workspace paths. ## Playoffs bonus laps: watch and schedule ### Watch a live exploration ```text play journey view --active ``` Open **Journeys** in the top-left. Choose the workspace marked **Live · updating**, then record the viewer while you steer the agent. Keep one wrong turn and its correction in the clip. Post the short recording on X or LinkedIn with `#RotePlayoffs` for brownie points. ### Make a Play recur Check that the optional recurring clock is ready: ```text play recurring probe ``` Schedules require the exact version from a verified Play receipt. This example runs the public Hello Play daily for six days: ```text play recurring schedule --reference modiqo/hello@0.2.2 \ --cadence daily \ --why "Start with a fresh stack check" \ --for 6d ``` Use a pulled or newly created Play for your own entry. The schedule pins its version, approved parameters, reason, and stop condition. ## Playmaker: explore, steer, verify, save, publish ### The primary entrance When no saved Play matches the useful outcome, begin here: ```text $play explore ``` This is the normal Playmaker path. The current exploration progresses automatically from useful work to save-worthiness; you should not need to stop and manually settle a healthy session. ### A real exploration journey ```text You: $play explore PostHog daily active users Play: searches saved Plays Play: No match. Explore and create? You: Explore and create Play: finds the adapters or CLIs available on this machine You: choose PostHog Play: connects and verifies the prerequisite Play: begins the requested daily-active-users work Play: occasionally shows an Exploration progress pulse You: steer the work, correct assumptions, and test useful edge cases Play: verifies the useful outcome Play: offers to save, test, publish, and share the new Play ``` The pulse is a compact signal from the captured workspace: new steps, successes and errors, latency, cached-query savings, recent trajectory nodes, and dependency edges. It appears occasionally so you can understand progress without reading a narration of every tool call. ### Setup-led or goal-bound ```text $play explore connect to PostHog # Connects first, then asks what useful outcome to explore. $play explore connect to PostHog and retrieve DAU # Connects, then continues directly into the outcome you already stated. ``` If you name only the setup, Play finishes the prerequisite and asks what the connection is for. If you already name the useful outcome, Play does not make you repeat it. ### Take a one-turn detour without losing the exploration ```text You: direct: inspect the local PostHog CLI version Agent: handles that one turn outside Play and Rote You: continue exploration Play: revalidates any changed state and resumes the captured journey ``` Direct work stays outside the saved trajectory. `continue exploration` returns to the same captured goal after the one-turn detour. ### Keep it, prove it, then choose where it lives A good Play has named stages, reusable inputs, a stable output, and a verified rerun. When the method is ready, Play offers: ```text Team publish privately to an authorized organization Community publish publicly under an eligible owner Skip keep the result without publishing it ``` For an existing Play, manage the lifecycle conversationally: ```text publish posthog-project-dau publicly under chetan ``` Do **not** prefix that request with `direct:`. Publishing must stay inside Play so it can inspect the artifact, resolve the owner, preserve lineage, verify the published URI, and finish the lifecycle. Do not use `direct:` for **publishing, sharing, restoring, or managing a Play**. It bypasses the lifecycle needed to perform those operations. ### `settle` is a recovery door, not the main entrance Active exploration should advance into save, test, publish, and share on its own. Use `settle` only after an interruption or re-entry when a verified owner-private capture already exists: ```text $play settle ``` It cannot retroactively capture work that began outside the Play lifecycle. ### See where a Play came from ```text $play birth posthog-project-dau $play birth modiqo/retrieve-recent-emails ``` A birth certificate preserves provenance while excluding raw commands, parameters, responses, credentials, and workspace paths. ## Advanced: routing, credentials, and recovery The beginner path ends above. Use this section when you need an explicit native-tool lane, a static credential, deterministic recall details, or recovery from an earlier install. ### One direct turn ```text direct: without play: ``` The bypass covers the whole user turn, including continuations, delegation, retries, and tool loops. It is not sticky, and it never bypasses harness permissions or safety checks. Remember: it is not a lane for publishing, sharing, restoring, or managing Plays. ### Persistent project routing Prefer conversational setup: ```text Initialize Play routing for this repo Route GitHub directly through gh in this project Show this project's Play routing policy Stop routing GitHub directly here ``` Exact terminal syntax: ```sh play-routing --project . init play-routing --project . add github-direct \ --provider github --provider github-actions \ --tool git --tool gh \ --executor api --executor cli play-routing --project . list play-routing --project . remove github-direct ``` A routing policy chooses an orchestration lane. It is not a permission override or an executor. ### OAuth/DCR browser sign-in When a Play declares `adapter.auth.ensure`, authorization belongs to the approved Play run: ```text Play: opens the provider's secure browser authorization You: approve access in the browser Play: verifies the named credential and resumes the same run ``` Google may be one provider in this flow; it is not a separate authentication category. ### Static tokens stay out of chat ```sh rote token list rote token set --stdin ``` Paste the token into your terminal, never into chat. Play checks the credential name and health, not the secret value. ### Journal details ```text $play journal [today|yesterday|YYYY-MM-DD] ``` The journal is an owner-private, deduplicated local read. It performs no registry search, preflight, or narrated continuation. ### Backup, restore, and dossiers ```sh play-bootstrap backup list play-bootstrap backup show play-bootstrap restore --dossier --plan play-bootstrap restore --dossier play-bootstrap restore --backup --plan play-bootstrap restore --backup ``` A dossier is the verified install or restore report that points to an immutable recovery snapshot. Always run `--plan` first. Applying a restore creates a safety backup of the current Play state, restores the selected snapshot, verifies it, and writes a new restore dossier. ## Pocket card ```text # Playrunner $play $play what's new $play popular Plays $play trending Plays $play find Plays that use PostHog $play https://play.modiqo.ai// # Playmaker $play explore continue exploration publish posthog-project-dau publicly under chetan $play settle # Recovery only # Recall and advanced controls $play journal [today|yesterday|YYYY-MM-DD] direct: play-routing --project . list rote token list play-bootstrap backup list ``` ## The three rules worth remembering 1. **Inspect before you approve.** A match is not permission to run. 2. **Explore toward an outcome.** Steer the work, verify the result, and let the healthy lifecycle advance into save-worthiness. 3. **Keep lifecycle work inside Play.** Never use `direct:` to publish, share, restore, or manage a Play.