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:

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.

Documentation

• Set up Until
• Run your first Until Loop
• Plan approvals
• Plan checks
• Custom Loops
• Troubleshooting

The Until Loop

A change stays in the Until Loop until the implementation matches the Plan.

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. 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. 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:

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:

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:

opencode plugin @until-dev/plugins --global

Restart OpenCode, then authenticate the Until MCP server:

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:

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:

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:

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:

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:

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:

pi install git:github.com/until-dev/plugins@v0.2.5

For local pre-release testing, point Pi at this plugin directory instead:

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 <url> — that path is for single-file plugins only.

Amp CLI (system plugin):

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):

amp clone user-plugins
git clone https://github.com/until-dev/plugins.git <that-repo>/until

Commit in that repo if Amp asks. Personal plugins apply on 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 <user-plugins>/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.

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. 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:

agy plugin install /absolute/path/to/until-plugins

Refresh the global OpenCode plugin and restart OpenCode:

opencode plugin @until-dev/plugins --global --force

On Cursor, update the cloned repository and reload the window:

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.

Update through Copilot's plugin manager:

copilot plugin update until@until

VS Code Chat picks up updated plugin content on the next window reload.

Refresh the installed Pi package with:

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:

git -C ~/.config/amp/plugins/until pull

Or, for personal plugins: git -C <user-plugins>/until pull, then reload Amp.

Uninstalling

On Claude Code, remove the plugin through the plugin manager.

On Codex, remove the plugin and marketplace:

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:

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:

pi remove npm:pi-until-loop

A Git install is removed with the same source you used to install it:

pi remove git:github.com/until-dev/plugins@v0.2.5

On Amp, delete the until plugin directory (~/.config/amp/plugins/until or <user-plugins>/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 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
• Until is built by the team behind AI Is Not Your Peer.

License

MIT — see LICENSE.

Portions of Until are adapted from obra/superpowers, created by Jesse Vincent and distributed under the MIT License. The combined license preserves the copyright notices for both projects.