# Until Spend your time on the engineering trade-offs that matter. Let the Until Loop make sure your agents deliver what you want, how you want it. Until moves the important decisions into the Plan before a coding agent writes any code. It then enforces that Plan during implementation and checks the resulting pull request against it. For individual developers and teams whose agents can produce code faster than they can confidently review it. This plugin connects Cursor, Claude Code, Codex, Factory Droid, Antigravity CLI, OpenCode, Pi and Amp to Until, guiding the agent through the Until Loop. The open-source plugin runs alongside your coding agent. The hosted Until workspace stores Plans and, once you connect source control, links them to pull requests and runs Plan checks. ## Quickstart Install Until in Claude Code: ```text claude > /plugin marketplace add until-dev/plugins > /plugin install until@until ``` Restart the session, run `/mcp` to complete authentication, then start a fresh conversation. Until will guide you through creating a workspace. You can connect source control later, when you submit your first Plan for repository-backed work. Installation instructions for Codex, Factory Droid, Antigravity CLI, OpenCode, Cursor and Pi are [below](#install). ## Documentation - [Set up Until](docs/setup.md) - [Run your first Until Loop](docs/first-until-loop.md) - [Plan approvals](docs/plan-approvals.md) - [Plan checks](docs/plan-checks.md) - [Custom Loops](docs/custom-loops.md) - [Troubleshooting](docs/troubleshooting.md) ## The Until Loop A change stays in the Until Loop until the implementation matches the Plan. ```mermaid flowchart LR B[Brainstorm] --> P[Plan] --> S[Submit] --> R[Run] --> C[Check] --> D([done]) C -->|fix the code| R C -->|difference acknowledged on the record| D ``` 1. **Brainstorm** with your coding agent until the shape of the change is clear. 2. **Plan** the work in enough detail for someone else to understand and build it. 3. **Submit** the Plan as the target for implementation. If its saved policy requires Review, another person must approve it before implementation. 4. **Run** the Plan with your coding agent. Until keeps the Plan attached to the work while the agent implements it. 5. **Check** the pull request against the Plan. Where they differ, fix the code, correct the Plan, or acknowledge the difference on the record. ## The Until Rule > No code until the Plan is agreed. How the Plan is agreed depends on its saved Review policy. Plans that do not require Review proceed after submission is confirmed. Plans that require Review need another person's approval before implementation. The argument behind the rule is our manifesto, [AI Is Not Your Peer](https://www.notyourpeer.com/). A coding agent cannot defend its decisions like a human author. The Plan records the intent before someone has to reconstruct it from a finished pull request. ## Plan checks After a pull request opens, Until compares it with the Plan and reports anything missing, changed or outside its scope. Plan checks require a source-control connection. When you submit your first Plan for repository-backed work, Until will guide you through connecting your provider. It later links the pull request to that Plan and checks again whenever new code is pushed. A difference is not automatically a failure. You can ask the agent to fix the code, correct and reclear the Plan, or have an authorized person acknowledge the difference on the record. A check is successful only when no differences remain; acknowledged differences produce a neutral, non-blocking outcome. ## Extend with Custom Loops Custom Loops handle the paperwork around a change: updating tickets, refreshing stale documentation and reporting progress in Slack. They are written in Markdown and kept in git, so you can inspect and change them alongside the rest of your development process. ## Install ### Requirements - Cursor, Claude Code, Codex, Factory Droid, Antigravity CLI, GitHub Copilot, OpenCode, Pi or Amp - macOS or Linux - `python3` on `PATH` for the Claude Code, Cursor, Factory Droid, Antigravity CLI and OpenCode enforcement hooks (Amp uses TypeScript enforcement in the plugin; no Python required) Windows is not supported yet. The skills that teach the Until Loop may load, but the hooks that track Plan state and enforce the Until Rule are not reliably launched or validated there. Nothing on Windows will stop an agent from writing code without a Plan. ### Claude Code Follow the [Quickstart](#quickstart). Claude Code loads its enforcement hooks from the plugin, so there is no separate hook-installation step. ### Factory Droid Install Until from the Factory marketplace: ```bash droid plugin marketplace add https://github.com/until-dev/plugins droid plugin install until@until --scope user ``` Restart Droid and start a fresh session. Until's skills, MCP server and enforcement hooks load from the same plugin root as Claude Code. Droid loads the wrapped Claude-compatible `hooks.json` from that root; a native `.factory-plugin/` manifest also ships beside `.claude-plugin/` and points at the same `./` source. When you change plugin metadata, update both manifest directories together. Factory Droid names shell and file tools differently from Claude Code. The main Droid session is enforced on `Execute` (shell) and `Create`, `Edit`, and `ApplyPatch` (files). Claude Code uses `Bash`, `Write`, and `Edit` for the same jobs. The shared commit gate maps each host onto the same enforcement paths. While Until is enforcing (a Plan is in flight or the cwd is a `.until-method` repository), the main session also denies `Task` spawns on Claude Code and Factory Droid. Idle sessions in unmarked repositories may still use `Task`. If `python3` cannot run the hook, enforcement fails open and the tool is allowed — including `Task`. Until is a workflow guard, not a security sandbox. Windows is not supported for Factory Droid enforcement hooks. ### Antigravity CLI Install Until as a native Antigravity plugin: ```bash agy plugin install /absolute/path/to/until-plugins ``` For a published checkout, point `agy plugin install` at the Until plugin root (the directory that contains `plugin.json`, `mcp_config.json`, and `hooks.json`). Restart `agy` and start a fresh session. Run `/mcp` (or the TUI MCP auth flow) to finish sign-in. After install, Until tools must load. `/hooks` is the project hook editor and does not list plugin hooks. Confirm the install with `agy plugin list`, then look for `commit-gate fired` in `~/.until/hooks.log` after a write or shell call. Skills without Until tools is a failed install. The native hook file calls the same session-start, prompt-reminder, commit-gate, and state-tracking scripts as Claude Code and Factory Droid. The gate covers `run_command` (shell), `write_to_file`, `replace_file_content`, and `multi_replace_file_content` (files), plus `invoke_subagent` (spawn) and any `create_file` / `edit_file` aliases your `agy` build still emits. Read and search tools stay allowed. If `python3` cannot run the hook, enforcement fails open and the tool is allowed. Until is a workflow guard, not a security sandbox. Inspect `~/.until/hooks.log` after a supported tool call. Windows is not supported for Antigravity CLI enforcement hooks. ### OpenCode OpenCode 1.18.23 or later is required. Install Until as a global OpenCode plugin: ```bash opencode plugin @until-dev/plugins --global ``` Restart OpenCode, then authenticate the Until MCP server: ```bash opencode mcp auth until ``` Start a fresh session. The plugin supplies Until's workflow, skills and MCP configuration without adding files to each repository. OpenCode enforcement covers its built-in `write`, `edit`, `apply_patch` and `bash` tools. Tools added by other OpenCode plugins are outside this initial support boundary. The enforcement process fails open if `python3` cannot run; Until is a workflow guard, not a security sandbox. ### Cursor Clone the plugin into a permanent location: ```bash git clone https://github.com/until-dev/plugins.git ~/src/until-plugins mkdir -p ~/.cursor/plugins/local ln -s ~/src/until-plugins ~/.cursor/plugins/local/until ``` Install the user-level enforcement hooks: ```bash cd ~/src/until-plugins ./hooks/install-user-hooks.sh ``` Reload the window with **Developer: Reload Window**, then start a fresh chat. The extra hook installation is a platform limitation rather than a design choice. Cursor dispatches plugin-shipped hooks for `sessionStart`, but the enforcement events (`afterMCPExecution`, `beforeShellExecution`, `preToolUse`) load only from the user or project `hooks.json` chain. The enforcement hooks are inactive in ordinary conversations until Plan submission or source-control setup begins. A repository containing `.until-method` is enforced before a Plan exists. Installing the hooks globally is therefore safe. ### GitHub Copilot Install Until through Copilot's plugin manager: ```bash copilot plugin marketplace add until-dev/plugins copilot plugin install until@until ``` This single install covers two surfaces: - **Copilot CLI in the terminal.** The plugin loads on the next `copilot` invocation. Run `/plugins` in a session to confirm `until@until` is listed. - **Copilot Chat in VS Code.** VS Code auto-discovers plugins installed via the Copilot CLI (from `~/.copilot/installed-plugins/`) and loads Until the next time you open Chat. Requires VS Code 1.102 or later for Agent Plugins support. To confirm the install: open the Extensions view, filter by `@agentPlugins`, and check that Until appears under `Agent Plugins - Installed`. If it doesn't, restart VS Code once — auto-discovery runs on VS Code startup. Both surfaces route new implementation asks through the Until Loop: Copilot brainstorms, drafts a Plan, submits it for review, and only writes code once the Plan is cleared. Copilot's async Coding Agent — which opens PRs from GitHub issues in a cloud environment — is not covered by this install. ### Codex Install Until through Codex's plugin marketplace: ```bash codex plugin marketplace add until-dev/plugins codex plugin add until@until ``` Restart Codex and start a new task. The plugin registers Until's MCP server automatically. ### Pi Install Until from npm: ```bash pi install npm:pi-until-loop ``` `pi install npm:@until-dev/plugins` still loads the same plugin if you already use that name. It is not the catalog listing. Git remains an alternative: ```bash pi install git:github.com/until-dev/plugins@v0.2.5 ``` For local pre-release testing, point Pi at this plugin directory instead: ```bash pi install /absolute/path/to/workspace/plugins ``` Start Pi, run `/mcp-auth until`, and complete authentication in the browser. Then start a fresh session. Until's skills and startup guidance should be available, and `/mcp` should show the Until server. This first Pi release supports the Until workflow and MCP tools. Pi does not load the deterministic enforcement hooks used by Claude Code, Factory Droid, Antigravity CLI, Cursor and OpenCode. ### Amp Amp requires a **directory plugin** (`index.ts` plus `skills/`). Do not use `amp plugins add ` — that path is for single-file plugins only. **Amp CLI (system plugin):** ```bash git clone https://github.com/until-dev/plugins.git ~/.config/amp/plugins/until ``` Reload Amp (`plugins: reload` or restart). The folder name must be `until` so skills appear as `until:using-until`, and so on. **Amp CLI and website (personal plugins):** ```bash amp clone user-plugins git clone https://github.com/until-dev/plugins.git /until ``` Commit in that repo if Amp asks. Personal plugins apply on [ampcode.com](https://ampcode.com) as well as the CLI. On first load the plugin registers Until MCP at `https://run.until.dev/mcp` if you do not already have an `until` server configured. Amp lists it as **awaiting approval** until `amp mcp approve until` (or Settings). Until tools do not appear in the first thread before that approval. After approval, `amp mcp doctor` should show Until connected. Complete OAuth when prompted (localhost on CLI; `https://ampcode.com/auth/mcp/callback` on the website). **Verify:** `amp plugins list` shows `until`; after MCP approval, `amp mcp doctor` shows `until` connected; a new thread contains the bootstrap marker `until:using-until bootstrap for amp` as a visible user message. Amp has no hidden plugin context. **Update:** `git -C ~/.config/amp/plugins/until pull` (system) or `git -C /until pull`, then reload. **Uninstall:** delete the `until` plugin directory; remove `amp.mcpServers.until` if the plugin added it; reload. If MCP is missing after install, add `https://run.until.dev/mcp` under Amp Settings → MCP (website) or run `amp mcp add until https://run.until.dev/mcp` (CLI). See [Troubleshooting](docs/troubleshooting.md#until-mcp-is-not-connected). Orbs are not supported. ### Verify the installation Start a fresh conversation and ask your agent to implement a small change. Until should begin by helping you shape the change and create a Plan before writing code. After the Plan is cleared, it should stop again until you explicitly start implementation. If either stop is missing, follow the [enforcement troubleshooting steps](docs/troubleshooting.md#the-agent-starts-implementing-before-there-is-a-plan). In an ordinary repository, pre-Plan behaviour comes from the plugin's session guidance; deterministic hooks begin enforcement when submission or source-control setup starts. A `.until-method` repository is enforced before submission. ### Updating Claude Code updates through the plugin manager. Update Until through Codex's plugin manager, then restart Codex. Update Factory Droid through its plugin manager, then restart Droid. Reinstall Until in Antigravity CLI from the plugin root, then restart `agy`: ```bash agy plugin install /absolute/path/to/until-plugins ``` Refresh the global OpenCode plugin and restart OpenCode: ```bash opencode plugin @until-dev/plugins --global --force ``` On Cursor, update the cloned repository and reload the window: ```bash cd ~/src/until-plugins git pull ``` The existing hook entries point into that clone and do not need reinstalling after an ordinary pull. If the clone moved or the hooks are missing, follow [Troubleshooting](docs/troubleshooting.md#until-enforcement-hooks-do-not-run). Update through Copilot's plugin manager: ```bash copilot plugin update until@until ``` VS Code Chat picks up updated plugin content on the next window reload. Refresh the installed Pi package with: ```bash pi update npm:pi-until-loop ``` Git tags are immutable. To move a Git install to a later Until release, remove this tagged source and install the newer tagged source. For Amp, pull the plugin directory and reload: ```bash git -C ~/.config/amp/plugins/until pull ``` Or, for personal plugins: `git -C /until pull`, then reload Amp. ### Uninstalling On Claude Code, remove the plugin through the plugin manager. On Codex, remove the plugin and marketplace: ```bash codex plugin remove until@until codex plugin marketplace remove until ``` On Factory Droid, remove Until through the plugin manager. On Antigravity CLI, remove Until through `agy plugin uninstall until`, then restart `agy`. On OpenCode, remove `@until-dev/plugins` from the `plugin` array in `~/.config/opencode/opencode.json`, then restart OpenCode. On Cursor, delete the plugin symlink and remove the Until entries from your user-level `hooks.json`. Remove the plugin from Copilot: ```bash copilot plugin remove until@until copilot plugin marketplace remove until-dev/plugins ``` VS Code Chat stops auto-discovering Until on the next window reload. On Pi, remove the package: ```bash pi remove npm:pi-until-loop ``` A Git install is removed with the same source you used to install it: ```bash pi remove git:github.com/until-dev/plugins@v0.2.5 ``` On Amp, delete the `until` plugin directory (`~/.config/amp/plugins/until` or `/until`). Remove `amp.mcpServers.until` from Amp settings if the plugin added it. Reload Amp. ## Bypassing the Until Loop Tell your agent not to use the Until Loop for the current change. Clicking Build or saying "looks good" does not count, and the agent cannot make that choice for you. Until explains what you are giving up. When enforcement is active, it also gives you a session-specific bypass command that you must run in your own terminal; the agent cannot run it for you. ## FAQ **How is this different from Superpowers?** Until adapts parts of Superpowers' brainstorming and planning method, with thanks to its contributors. Until adds shared Plans, optional Plan approval, deterministic enforcement and pull request checks against the Plan. See the [License](#license) for attribution. **Does every change need a Plan?** The Until Rule applies to changes an agent implements. You can bypass it for a particular change. **What happens if the agent ignores the Plan?** The Plan check reports the difference on the pull request. You can ask the agent to fix the code, correct the Plan, or acknowledge the difference on the record. Either way, the difference requires a decision from you. ## Support - **Issues:** [github.com/until-dev/plugins/issues](https://github.com/until-dev/plugins/issues) - Until is built by the team behind [AI Is Not Your Peer](https://www.notyourpeer.com/). ## License MIT — see [LICENSE](LICENSE). Portions of Until are adapted from [obra/superpowers](https://github.com/obra/superpowers), created by Jesse Vincent and distributed under the MIT License. The combined license preserves the copyright notices for both projects.