Skip to main content

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

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

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 <url>
  • --website <url>
  • --context <files...>
Example: 
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: 
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: 
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 <name> to override the runner’s local default model
  • --attach <url> 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/: 
.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: 
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

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