> ## Documentation Index > Fetch the complete documentation index at: https://docs.pluxx.dev/llms.txt > Use this file to discover all available pages before exploring further. # Autopilot # Autopilot `pluxx autopilot` is the coordinated import flow for people who want Pluxx to scaffold the project, run the right semantic passes, and verify the result without manually chaining every command. It is a real command, not a planning spec. ## What autopilot does Autopilot combines: 1. deterministic MCP import 2. optional semantic refinement through a host coding agent 3. final verification Autopilot does not replace the underlying commands. It orchestrates them. ## Command shape ```bash theme={null} npx @orchid-labs/pluxx autopilot \ --from-mcp https://example.com/mcp \ --runner codex \ --name acme \ --display-name "Acme" \ --author "Acme" ``` Supported runners: * `claude` * `cursor` * `codex` * `opencode` ## Deterministic steps vs agent steps Autopilot always starts with deterministic work: * MCP introspection * scaffold generation * quality analysis Then it decides whether to run agent passes based on: * the selected mode * MCP quality signals * whether you supplied docs, website, or local context * whether you explicitly requested a review pass The agent is only used for: * taxonomy refinement * instruction rewriting * review The agent is not used for: * import * lint * eval * build * install * test ## Modes ### `quick` Quick mode is the lightest path. * taxonomy runs only when MCP metadata warnings are present * instructions are skipped * review is skipped Use it when you want a fast first pass and do not need much semantic cleanup. ### `standard` Standard mode is the default. * taxonomy runs when MCP metadata signals cleanup work or when you provide docs/website/context * instructions run when warnings are present or when richer context is provided * review runs only if you add `--review` Use it when you want a balanced import flow. ### `thorough` Thorough mode is the heaviest path. * taxonomy always runs * instructions always run * review runs by default Use it when you want the strongest semantic pass before review or publishing. ## Context inputs Autopilot can enrich the agent context with: * `--docs ` * `--website ` * `--context ` Example: ```bash theme={null} npx @orchid-labs/pluxx autopilot \ --from-mcp https://example.com/mcp \ --runner claude \ --mode standard \ --docs https://docs.example.com/overview \ --website https://example.com \ --context notes.md,positioning.md ``` These context inputs only affect the agent layer. They do not change the deterministic import contract. ## Auth examples Bearer auth: ```bash theme={null} npx @orchid-labs/pluxx autopilot \ --from-mcp https://mcp.sumble.com \ --runner codex \ --yes \ --name sumble-plugin \ --display-name "Sumble" \ --author "Orchid Labs" \ --targets claude-code,cursor,codex,opencode \ --grouping workflow \ --hooks safe \ --auth-env SUMBLE_API_KEY \ --auth-type bearer ``` Custom header auth: ```bash theme={null} npx @orchid-labs/pluxx autopilot \ --from-mcp https://mcp.playkit.sh/mcp \ --runner codex \ --yes \ --name playkit \ --display-name "PlayKit" \ --author "PlayKit" \ --auth-env PLAYKIT_API_KEY \ --auth-type header \ --auth-header X-API-Key \ --auth-template '${value}' ``` OAuth-first remote MCPs are also supported. If the provider needs platform-managed runtime auth, use the platform-auth flags. If it requires browser-interactive OAuth during handshake, add `--oauth-wrapper`. ## Useful flags * `--mode quick|standard|thorough` * `--review` to force a review pass in standard mode * `--no-verify` to skip the final verification step * `--verbose-runner` to stream runner logs instead of showing the condensed summary * `--json` for machine-readable output * `--dry-run` to preview the planned scaffold and runner commands * `--model ` to override the runner's local default model * `--attach ` for OpenCode only If you do not pass `--model`, Pluxx uses the selected runner's local default model and reports that model in the autopilot output when it can detect it. ## What dry run shows `--dry-run --json` shows: * the planned scaffold * which agent passes will run or be skipped * the exact runner commands * which files would be created or updated It does not: * write files * invoke the runner * run verification ## What a real run leaves behind A real autopilot run writes the normal source project plus the agent pack under `.pluxx/agent/`: ```text theme={null} .pluxx/agent/ context.md plan.json taxonomy-prompt.md instructions-prompt.md review-prompt.md ``` Those files make the runner behavior inspectable instead of opaque. ## When to use autopilot vs manual commands Use autopilot when: * you want one coordinated import flow * you already know which runner you want to use * you want Pluxx to decide which semantic passes are worth running Use the manual flow when: * you want to inspect the deterministic scaffold first * you want tighter control over each agent pass * you want to stop after import, validation, or one specific refinement step Manual equivalent: ```bash theme={null} npx @orchid-labs/pluxx init --from-mcp https://example.com/mcp npx @orchid-labs/pluxx doctor npx @orchid-labs/pluxx test npx @orchid-labs/pluxx agent prepare npx @orchid-labs/pluxx agent run taxonomy --runner codex npx @orchid-labs/pluxx agent run instructions --runner codex npx @orchid-labs/pluxx agent run review --runner codex --no-verify npx @orchid-labs/pluxx test ``` ## Example: workflow-grouped import with verification ```bash theme={null} npx @orchid-labs/pluxx autopilot \ --from-mcp https://example.com/mcp \ --runner opencode \ --mode thorough \ --name acme \ --display-name "Acme" \ --author "Acme" \ --targets claude-code,cursor,codex,opencode \ --grouping workflow \ --hooks safe ``` That flow: * imports the MCP * applies the selected semantic passes * verifies the resulting scaffold * leaves a normal Pluxx source project you can keep editing and syncing later