autopilot-init
/autopilot-init
One-time setup of the linear-autopilot runtime on this machine, complete enough that a new project runs without further setup. Finds the AI coding CLIs really installed (Codex, Claude Code, opencode, Cursor, Grok, Antigravity, Mistral Vibe, ...) and their accounts, asks the owner once which subscription each account is on (paid plan, free plan, reserved for other uses), gives every model its tier and vendor from the owner's tier table, enforces vendor -> CLI, smoke-tests every model, reads the quotas, and prints per role which models can take it and what is missing. Use when the user says "/au
- Author
- iCarossio ↗
- Repository
- linear-autopilot ↗
- Licence
- MIT
- Last repository change
- 13.11.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 13.11.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
One-time setup of the linear-autopilot runtime on this machine, complete enough that a new project runs without further setup. Finds the AI coding CLIs really installed (Codex, Claude Code, opencode, Cursor, Grok, Antigravity, Mistral Vibe, ...) and their accounts, asks the owner once which subscription each account is on (paid plan, free plan, reserved for other uses), gives every model its tier and vendor from the owner's tier table, enforces vendor -> CLI, smoke-tests every model, reads the quotas, and prints per role which models can take it and what is missing. Use when the user says "/au
Original author description
One-time setup of the linear-autopilot runtime on this machine, complete enough that a new project runs without further setup. Finds the AI coding CLIs really installed (Codex, Claude Code, opencode, Cursor, Grok, Antigravity, Mistral Vibe, ...) and their accounts, asks the owner once which subscription each account is on (paid plan, free plan, reserved for other uses), gives every model its tier and vendor from the owner's tier table, enforces vendor -> CLI, smoke-tests every model, reads the quotas, and prints per role which models can take it and what is missing. Use when the user says "/au
How it works
- The policy the roster must express (README, "Tiers")
- Steps
- Adapter format (for reference)
SKILL.md preview
---
name: autopilot-init
description: One-time setup of the linear-autopilot runtime on this machine, complete enough that a new project runs without further setup. Finds the AI coding CLIs really installed (Codex, Claude Code, opencode, Cursor, Grok, Antigravity, Mistral Vibe, ...) and their accounts, asks the owner once which subscription each account is on (paid plan, free plan, reserved for other uses), gives every model its tier and vendor from the owner's tier table, enforces vendor -> CLI, smoke-tests every model, reads the quotas, and prints per role which models can take it and what is missing. Use when the user says "/autopilot-init", "set up the autopilot", "add a harness/account/model to the autopilot", or when another autopilot skill reports a missing roster.
---
# Autopilot: init
**Caveman, always.** Your first action, before any other tool call: invoke the `caveman` skill (`/caveman`), and keep it for the whole session, including after a resume or a context compaction (invoke it again then). If it is not installed, follow its rules anyway: answer first, no ceremony, commands, paths, numbers and errors verbatim. Every subagent you start talks caveman too: `run-model` adds the rule to every model prompt by itself, and every Agent-tool (subagent) prompt you write starts with "Invoke the `caveman` skill first and answer terse." Persisted text stays plain prose: code, comments, docs, commits, Linear, `PLAN.md`.
Goal: a roster at `~/.config/linear-autopilot/models.json` (`$AUTOPILOT_CONFIG_DIR` overrides) where every entry has a tier (`level`), a `vendor`, a `subscription` and a passed smoke test, and a `bin/harness check` that reports nothing blocking. Nothing personal (accounts, plans, cooldowns, API keys) is ever written into the skill repo.
`bin/<x>` below means the `bin` directory next to this SKILL.md (`~/.claude/skills/autopilot-init/bin/<x>` after `install.sh`, `${CLAUDE_PLUGIN_ROOT}/skills/autopilot-init/bin/<x>` as a plugin).
## The policy the roster must express (README, "Tiers")
1. **Every role has its tier.** Tier 1 (flagship) plans, pre-mortems, reviews milestones and coordinates; Tier 2 (balanced) implements, fixes and reviews each round of ticket code (implementer and reviewer always two different models; owner, 2026-11-11); Tier 3 (fast and cheap) implements only when a project pins it (models.json or the project's tier table); Tier 4 (every Mistral model, every free model, old Gemini) only does trivial tasks; Tier 0 (frontier ceiling) is never used unless the owner asks for one run. The tier comes from the owner's tier table (`bin/autopilot_lib.py` `DEFAULT_TIER_TABLE`, overrides in `models.json` `tier_table`): never ask the owner what the table already answers. Ask only about a model the table does not know.
2. **Vendor -> CLI.** Anthropic models only through `claude`, OpenAI only through `codex`, Google only through `agy`, Mistral only through `vibe`, xAI through `grok` or `cursor`, every other vendor through `opencode` (OpenCode Go or OpenRouter). `bin/harness add-model` refuses anything else; never work around it (no Claude through Antigravity or OpenRouter, no GPT through Cursor).
3. **No hand-ordered pools.** A role takes every model of its tier. At run time `run-model` draws one at random, weighted by the credit left on its account and by its subscription (paid first, free plans last), so every paid subscription is used up before its reset. Never encode preferences by hand.
4. **The coordinator's account is protected, and detected, not configured.** Whatever CLI and account the coordinator session runs on is the protected one: Claude Code is recognised by `CLAUDECODE` and its account by the session's `CLAUDE_CONFIG_DIR` (the default home when unset); another CLI by its adapter's `coordinator_env` and `account_env`; `AUTOPILOT_COORDINATOR=<cli>[/<account>]` forces it. Its models run last, for cheap roles only, and only while it keeps `coordinator_reserve` (default 30% of the 5-hour window and 20% of the weekly window). Another login of the same CLI is a normal account. Starting the coordinator from another account moves the protection there by itself.
5. **Implementer and reviewer are always different models.** Enforced at run time (fail closed). Accounts of the same model are the same reviewer; a reviewer of another vendor than the implementer is preferred when one is available.
6. **Subscriptions and free tiers only.** No paid per-token ids, no top-ups, no extra-usage credits.
7. **No speed variants.** Never add a `-fast` / `build-fast` / "Fast" variant of a model family (e.g. `grok-4.7-build-fast`), whatever its tier: more expensive, no quality gain. `bin/harness add-model` refuses it, `bin/harness init` drops it, `run-model discover` skips it; only the owner can override with an explicit `--allow-fast` (never pass it on your own). "Flash" / "Flash-Lite" (Gemini, DeepSeek, GLM) are model families, not speed variants: add them normally.
## Steps
1. **Create or import the roster.**
- New machine: `bin/harness init` (copies `templates/models.json`: example models of November 2026 with their tier and vendor, no subscription).
- Existing roster in the format before the tier policy (it has `pools`): `bin/harness migrate --dry-run`, show the user what changes, then `bin/harness migrate`.
- Existing private roster to import: `bin/harness init --import <path/to/models.json>`.
2. **Discover what is really installed.** `bin/harness discover`: one line per CLI: installed (a real executable on PATH; a shell alias or function wrapping a removed binary counts as NOT INSTALLED, because `run-model` runs the binary, not the user's shell), adapter present or `NO ADAPTER`, version, roster entries; then one line per account directory on disk (e.g. `~/.codex*`) with whether it holds a login, who it is (email, plan, from the login's token claims; tokens are never printed), and the `add-account` command when it is not in the roster. A directory without a login is not an account. For a CLI that is not installed but has roster entries, tell the user now (install it, or `bin/harness set <key> excluded "not installed"`): finding out at run time costs a night.
3. **Register a CLI the runtime does not know** (rare: under rule 2 a new CLI only serves vendors without a CLI of their own). Ask the user (or read its `--help`) for the non-interactive invocation with full permissions, the model flag, stdout or an output-file flag, the variable that selects another account, a model-listing command, a usage command, and a variable the CLI sets in the processes it starts. Then `bin/harness new <name> --binary <bin> --vendor <vendor|by_model> --argv '["-p","{prompt}","--model","{model}","--yes"]' [--output file] [--account-env VAR --account-default ~/.x] [--coordinator-env VAR] [--list-cmd ...] [--usage-cmd ... --usage-regex ... --usage-groups ...] [--tokens-kind ... --tokens-path ...]`. Check it with `bin/harness adapters`.
4. **Add accounts: one standard for every harness.** The default account lives in the CLI's own home (`~/.codex`, `~/.claude`, `~/.local/share` for opencode); the next accounts live in `<default>-b`, `<default>-c`, ... and their roster keys are `<key>-b`, `<key>-c`, ... `bin/harness add-account <cli> b [--label "who@example.com"]` clones every base model of that CLI with the account's home. The user logs in once in that home. A directory with another name is renamed to the standard (`bin/harness set-home` when it was already in the roster), never registered as is.
5. **Add models.** For each model the user wants that is not in the template: `bin/harness add-model <key> --cli <cli> --model <id> [--family 'gpt-*-sol']`. The tier comes from the tier table, the vendor from the id; `--level` only for a model the table does not know (ask the owner which tier, with the README table in front of them). Give versioned ids a `family` with a `*` so `run-model discover` keeps them on the latest version. Remove template models the user does not have (`bin/harness remove <key>`).
6. **Ask once about subscriptions and plan sizes, per account.** For each paid account also record its plan's relative size as `capacity` in models.json (1 = the smallest plan; e.g. 12 for a plan with 12x its usage): draws are weighted by the remaining total usage of each subscription, credit left times capacity. Show the accounts (`bin/harness list`) and ask in one message, for each `<cli>/<account>`: paid (and the plan name), free plan, or reserved for other uses (and why). Record each answer: `bin/harness subscription <cli> <account|default> paid --plan "<plan>"`, `... free`, `... reserved --reason "<their words>"`. Reserved accounts are never used anywhere. An account the owner only wants kept out of one project goes in that project's `state.json` `exclude` instead (asked by `/autopilot-run` setup). Free models stay free whatever their account's plan.
7. **Detect the coordinator account.** `bin/harness whoami` prints the CLI and account this session runs on and the roster keys on it. Tell the user those keys are last resort for cheap roles only, guarded by `coordinator_reserve`. Nothing about it is written in `models.json`: each project records the account it was started from (`run-model whoami --record`) and re-detects it on resume.
8. **Smoke test every model** that is not excluded: `bin/run-model smoke <key>` (a 120 s "reply AUTOPILOT_OK" run; the coordinator's own account last, or skipped when the user wants to spare it). A model that fails is cooled down; fix the adapter or the login, `bin/run-model reset <key>`, smoke again, or remove it.
9. **Read the quotas and the latest versions.** `bin/run-model usage --apply` (every account's windows, used percentage and reset time; cools what is exhausted; records the credit left that weights the draws) and `bin/run-model discover --apply` (newer ids of every family, smoke-tested before switching). Harnesses without a usage probe say so: the runtime learns their resets from quota errors.
10. **Check the result.** `bin/harness check` prints, per role, the candidate models with tier, vendor, account, subscription, health and credit left, then every missing piece with what to do: a role with no candidate (e.g. no Tier 2 model: no ticket can be reviewed), a review role with a single vendor (works, but an outage of that vendor stops every review), no Tier 1 model of another vendor than the coordinator (no pre-mortem, no plan review), a CLI not installed, a refused entry, an unknown subscription, a coordinator account not detected. Fix what blocks; show the user the rest. Exit 0 means nothing blocks.
11. **Linear access.** Check that this harness has Linear tools (MCP), else that `LINEAR_API_KEY` is set and `bin/linear teams` answers.
12. **Permissions, so the run never stops on a prompt.** Show the user the rules in `templates/permissions.json`, plus any project command they already know their checks need. With their approval, merge them into `~/.claude/settings.json` under `permissions.allow` through the harness's settings mechanism (Claude Code: the `update-config` skill), never replacing existing entries. Rules use the prefix form `Bash(<command> *)`; replace `{HOME}` with the user's home. Never pre-approve actions that need a per-use owner decision: publishing a website, merging to the default branch, opening a PR, deleting branches or worktrees, paying for credits.
13. **Summary for the user:** the `bin/harness check` table (role -> candidates), the subscriptions recorded, the coordinator account detected, what was removed or excluded and why, the quotas right now, the missing pieces, and that `/autopilot-plan` is the next step.
## Adapter format (for reference)
`harnesses/<cli>.json`: `name`, `binary`, `vendor` (or `by_model` to derive it from the model id), `run.argv` with `{prompt}`, `{model}`, `{out}`, `{cwd}` placeholders, `run.env`, `run.output` (`stdout` or `file`), `account_env` / `account_default` / `account_detect`, `account_login` (the file that proves a login, and optional JWT claims naming the account), `coordinator_env` (variables the CLI sets in the processes it starts, so a coordinator session running in it is detected; only Claude Code's `CLAUDECODE` is declared today), `list_models` (`command` + `regex`, `json_file`, `probe` for a CLI without a listing: next version ids are smoke-tested, or `none`), `usage` (`command` + `regex` + `groups`, `codex_sessions`, or `none`), `quota_patterns`, `waiting_patterns` (optional: the CLI's own input prompts; by default only a non-code last line after 30 s of silence counts), `tokens` (`kind` + `path`: the local log `bin/tokens` counts consumption from). The repo's `harnesses/` has one per known CLI; copy the closest one as a starting point. Cursor: `cursor-agent` has one login per machine; `auto` is not a model id, and under the vendor -> CLI rule only xAI models go through it.
Files in this package (2)
- SKILL.md 13 KB
- bin 1 KB
Versions
The database has no other skills named autopilot-init.
Database snapshot: 13.11.2026 · package version 1a528bba15df (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100autopilot-setup
Use when the user asks to set up or change Autopilot roles, models, effort or their subscription plan. Interactive wizard that writes the autopilot-kit profile. - 100autopilot-plan
Turn a large change into an autopilot plan (SPEC.md + tasks.json) that the `autopilot` orchestrator runs unattended across many Claude Code sessions, each with its own model and effort. Use when the user runs /autopilot-plan or asks to plan work for an overnight or unattended run. - 100autopilot-run
Execute a planned Linear project autonomously over a long unattended session, ticket by ticket, about one commit per ticket. The coordinator (this session) only orchestrates. Every ticket is planned by the coordinator (Tier 1), plan-reviewed by a Tier 1 model of another vendor,… - 100autopilot-codex
在 Codex 中使用 autopilot 的全闭环 runtime 时使用。适用于用户提到 /autopilot、自动驾驶、设计审批、红蓝对抗、五层 QA,或希望在 Codex 中继续沿用 autopilot 方法论的场景。 - 100autopilot-codex
在 Codex 中使用本仓库的 autopilot 全闭环 runtime 时使用。适用于用户提到 /autopilot、自动驾驶、红蓝对抗、设计审批、五层 QA、或希望在 Codex 中继续使用 autopilot 的场景。不要在 Claude Code 插件运行时文件上直接操作。 - 100open-pr
Opens a review-ready GitHub PR, then autopilot and code review loop to PASS (phase 3). Use when the user says make a pr, open pr, handle review, autopilot on PR N, fix CI, or gives a PR URL/number.