Skip to content
Back to search

t3-autopilot

MCP server that tells a T3 Code orchestrator which provider, model and reasoning effort to use for each child task, from a family-based policy and the models you actually have.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 21 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/pablosalme/t3-autopilot with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/pablosalme/t3-autopilot'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/pablosalme--t3-autopilot/badge.svg)](/listings/pablosalme--t3-autopilot)

HTML

<a href="/listings/pablosalme--t3-autopilot"><img src="/api/listings/pablosalme--t3-autopilot/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

You need:

- T3 Code, with at least one provider signed in. - [Node.js](https://nodejs.org) 22 or later. To check, run `node --version` in a terminal.

There is nothing to download by hand: `npx`, a tool that comes with Node.js, fetches t3-autopilot and runs it.

Step 1. Add it to your agent

Only the agent you talk to needs it (T3 Code calls it the *orchestrator*); the helpers do not. Copy the line for the agent you use and paste it into a terminal:

**Claude Code**

claude mcp add --scope user t3-autopilot -- npx -y t3-autopilot

**Codex**

codex mcp add t3-autopilot -- npx -y t3-autopilot

**Grok CLI**

grok mcp add t3-autopilot -- npx -y t3-autopilot

**OpenCode**

opencode mcp add t3-autopilot --global -- npx -y t3-autopilot

These lines register t3-autopilot as an *MCP server*, the standard way of giving an AI agent an extra tool.

<details> <summary>Another agent, or one that asks for a JSON configuration</summary>

Add this block to its MCP configuration:

{
  "mcpServers": {
    "t3-autopilot": { "command": "npx", "args": ["-y", "t3-autopilot"] }
  }
}

</details>

Step 2. Tell your agent to use it

Agents read a rules file every time they start: `CLAUDE.md` for Claude Code, `AGENTS.md` for most others. t3-autopilot prints the paragraph to add to it:

npx -y t3-autopilot snippet

Copy what it prints and paste it at the end of your rules file. Or let the terminal do it (on macOS and Linux only; on Windows, copy and paste, because PowerShell can save the added text in a different encoding from the rest of the file). For Claude Code:

npx -y t3-autopilot snippet >> ~/.claude/CLAUDE.md

For Codex:

npx -y t3-autopilot snippet >> ~/.codex/AGENTS.md

For Grok CLI:

npx -y t3-autopilot snippet >> ~/.grok/AGENTS.md

For OpenCode:

npx -y t3-autopilot snippet >> ~/.config/opencode/AGENTS.md

Do not skip this step. Without it, your agent has the tool but does not know when to use it. The paragraph also gives your agent permission to switch model, which T3 Code otherwise tells it not to do on its own.

<details> <summary>See the paragraph it adds</summary>

## Model selection for delegated tasks (t3-autopilot)

You are authorized to pick the provider, model and options of every child task in T3 Code following the t3-autopilot MCP server. Switching provider or model as recommended by `recommend_model` counts as asked for by the user.

1. For every child task, including the ones you would start with your native subagent tool, call `recommend_model` first with `task` (one line), `taskType` (always; choose from the types listed in the tool description) and, if you know them, `size` and `criticality`.
2. Pass `capabilities` (the full output of `orchestrator_capabilities`) on the first call of the thread and again after an error or when providers change; the server keeps the last one, so other calls can omit it. Pass it whole, exactly as returned, never trimmed or summarised: a copy without each model's `options` loses the effort settings. If a call fails with "No capabilities yet", call `orchestrator_capabilities` and pass its full output again.
3. Use the first candidate. If it has `sameAsOrchestrator: true`, your native subagent tool is fine; otherwise call `delegate_task` with its `providerInstanceId`, `model` and `options` as `target`. If that child cannot start, or stops at once, because of a usage limit or its plan (for example "not included in your weekly usage"), call `mark_unavailable` with its `providerInstanceId`, its `model` (omit it if the whole provider is out), a short `reason` and `until` if you know when the limit resets, then use the next candidate.
4. Tell the user in one line which provider and model you picked, and why (the candidate's `reason`).
5. If `recommend_model` returns no candidate or fails, delegate inheriting your own provider and model, and say so.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 341 lines
  1. **English** · [Español](docs/README.es.md)
  2. # t3-autopilot
  3. [![CI](https://github.com/pablosalme/t3-autopilot/actions/workflows/ci.yml/badge.svg)](https://github.com/pablosalme/t3-autopilot/actions/workflows/ci.yml)
  4. Picks the right AI model for every task your [T3 Code](https://github.com/pingdotgg/t3code) agent hands off, so you don't have to.
  5. ## What it is
  6. In T3 Code, the agent you talk to can hand parts of a job to helper agents, and each helper can run on any of the AI subscriptions you have connected: Claude, Codex, Cursor, Grok and others. t3-autopilot is a small add-on that tells your agent which of your models to use for each of those tasks.
  7. Think of the person who hands out the work in a workshop: the delicate job goes to the most experienced hand, sweeping up goes to the apprentice, and the inspection is done by someone who did not make the piece. t3-autopilot does that with your AI models:
  8. | You ask for | It suggests | Why |
  9. |---|---|---|
  10. | A new feature | Your newest Claude Opus, thinking hard | It is a demanding job |
  11. | A review of that feature | Your newest GPT, on Codex | A second opinion should come from someone else |
  12. | Renaming a few files | Your newest Claude Haiku, thinking little | Small and fast is enough |
  13. (This is what the built-in preferences give if you have Claude and Codex connected and your agent runs on Claude. You can change them.)
  14. It is an independent project, not part of T3 Code.
  15. ## Why it helps
  16. Left alone, an agent tends to:
  17. - use its own model for everything, even when another subscription you pay for suits the task better;
  18. - remember model names that go out of date as soon as a new version comes out;
  19. - ask the model that wrote the code to review it.
  20. With t3-autopilot:
  21. - **Each kind of task goes to a model that suits it.** There is a ready-made list for eight kinds of task: coding, reviewing, debugging, planning, research, quick edits, design and writing.
  22. - **You always get the newest version you have.** Preferences say "Claude Opus", not a version number, so a new version is used as soon as your account offers it.
  23. - **Reviews get a real second opinion,** from a different provider than the one your agent runs on.
  24. - **Your plans are respected.** A cheap plan with little room is kept for what you bought it for, and models your plan charges extra for are left alone while something included can do the job.
  25. - **A subscription that runs out does not stop the work.** If a helper cannot start because a limit was reached, your agent moves on to the next option.
  26. - **You are told what was chosen.** Your agent says in one line which model it picked and why.
  27. It only gives advice. It never starts agents itself and never sees your passwords or account tokens.
  28. ## How it works
  29. <picture>
  30. <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/pablosalme/t3-autopilot/main/docs/assets/how-it-works-en-dark.gif">
  31. <img src="https://raw.githubusercontent.com/pablosalme/t3-autopilot/main/docs/assets/how-it-works-en-light.gif" alt="Animation in three steps. 1, Ask: your agent, running on Claude, has the task 'Review the PR that moves auth checks' and asks t3-autopilot which model to use. 2, Decide: for reviews you prefer GPT, then Gemini, then Grok; of the models you have, Claude is left out because it is your agent's own, and Cursor, out of quota, moves to the end. 3, Answer: three options, best first, each with its reason: Codex with gpt-6.2-codex, Grok with grok-6 and Cursor with gemini-5.1-pro; the helper starts on the first one. Model names are made up." width="880">
  32. </picture>
  33. 1. **Your agent asks.** Before it hands off a task, it tells t3-autopilot what kind of task it is and which models you have in T3 Code.
  34. 2. **t3-autopilot answers.** It checks your preferences and returns up to three options, best first, each with its reason.
  35. 3. **Your agent uses the first one** and tells you in one line which model it picked and why. If that one cannot start, it goes on to the next.
  36. Your agent can also note how each handoff went (accepted as is, needed fixes, or not usable), so later you can see which models work best for you.
  37. ## Install
  38. You need:
  39. - T3 Code, with at least one provider signed in.
  40. - [Node.js](https://nodejs.org) 22 or later. To check, run `node --version` in a terminal.
  41. There is nothing to download by hand: `npx`, a tool that comes with Node.js, fetches t3-autopilot and runs it.
  42. ### Step 1. Add it to your agent
  43. Only the agent you talk to needs it (T3 Code calls it the *orchestrator*); the helpers do not. Copy the line for the agent you use and paste it into a terminal:
  44. **Claude Code**
  45. ```sh
  46. claude mcp add --scope user t3-autopilot -- npx -y t3-autopilot
  47. ```
  48. **Codex**
  49. ```sh
  50. codex mcp add t3-autopilot -- npx -y t3-autopilot
  51. ```
  52. **Grok CLI**
  53. ```sh
  54. grok mcp add t3-autopilot -- npx -y t3-autopilot
  55. ```
  56. **OpenCode**
  57. ```sh
  58. opencode mcp add t3-autopilot --global -- npx -y t3-autopilot
  59. ```
  60. These lines register t3-autopilot as an *MCP server*, the standard way of giving an AI agent an extra tool.
  61. <details>
  62. <summary>Another agent, or one that asks for a JSON configuration</summary>
  63. Add this block to its MCP configuration:
  64. ```json
  65. {
  66. "mcpServers": {
  67. "t3-autopilot": { "command": "npx", "args": ["-y", "t3-autopilot"] }
  68. }
  69. }
  70. ```
  71. </details>
  72. ### Step 2. Tell your agent to use it
  73. Agents read a rules file every time they start: `CLAUDE.md` for Claude Code, `AGENTS.md` for most others. t3-autopilot prints the paragraph to add to it:
  74. ```sh
  75. npx -y t3-autopilot snippet
  76. ```
  77. Copy what it prints and paste it at the end of your rules file. Or let the terminal do it (on macOS and Linux only; on Windows, copy and paste, because PowerShell can save the added text in a different encoding from the rest of the file). For Claude Code:
  78. ```sh
  79. npx -y t3-autopilot snippet >> ~/.claude/CLAUDE.md
  80. ```
  81. For Codex:
  82. ```sh
  83. npx -y t3-autopilot snippet >> ~/.codex/AGENTS.md
  84. ```
  85. For Grok CLI:
  86. ```sh
  87. npx -y t3-autopilot snippet >> ~/.grok/AGENTS.md
  88. ```
  89. For OpenCode:
  90. ```sh
  91. npx -y t3-autopilot snippet >> ~/.config/opencode/AGENTS.md
  92. ```
  93. Do not skip this step. Without it, your agent has the tool but does not know when to use it. The paragraph also gives your agent permission to switch model, which T3 Code otherwise tells it not to do on its own.
  94. <details>
  95. <summary>See the paragraph it adds</summary>
  96. ```markdown
  97. ## Model selection for delegated tasks (t3-autopilot)
  98. You are authorized to pick the provider, model and options of every child task in T3 Code following the t3-autopilot MCP server. Switching provider or model as recommended by `recommend_model` counts as asked for by the user.
  99. 1. For every child task, including the ones you would start with your native subagent tool, call `recommend_model` first with `task` (one line), `taskType` (always; choose from the types listed in the tool description) and, if you know them, `size` and `criticality`.
  100. 2. Pass `capabilities` (the full output of `orchestrator_capabilities`) on the first call of the thread and again after an error or when providers change; the server keeps the last one, so other calls can omit it. Pass it whole, exactly as returned, never trimmed or summarised: a copy without each model's `options` loses the effort settings. If a call fails with "No capabilities yet", call `orchestrator_capabilities` and pass its full output again.
  101. 3. Use the first candidate. If it has `sameAsOrchestrator: true`, your native subagent tool is fine; otherwise call `delegate_task` with its `providerInstanceId`, `model` and `options` as `target`. If that child cannot start, or stops at once, because of a usage limit or its plan (for example "not included in your weekly usage"), call `mark_unavailable` with its `providerInstanceId`, its `model` (omit it if the whole provider is out), a short `reason` and `until` if you know when the limit resets, then use the next candidate.
  102. 4. Tell the user in one line which provider and model you picked, and why (the candidate's `reason`).
  103. 5. If `recommend_model` returns no candidate or fails, delegate inheriting your own provider and model, and say so.
  104. 6. If the result has `warnings` about omitted models, call `orchestrator_capabilities` with the `search` they suggest and pass that output to `recommend_model` as `capabilities` with `mergeCapabilities: true`.
  105. 7. If the user names a provider or model for a task, use theirs instead.
  106. 8. Right after delegating, call `log_delegation` with the `taskType`, `providerInstanceId`, `model` and `options` you used, `recommendedRank` (1-based rank of the candidate, or null if you chose something else) and `childThreadId`; keep the `delegationId`. After you review the child's result, call `log_outcome` with that `delegationId` and `outcome`: `success` (accepted as is), `corrected` (you had to fix or redo part of it) or `failure` (not usable; a child that could not start goes to `mark_unavailable` instead); add a short `note`.
  107. 9. If the result has `setupNeeded`, ask the user its questions for every provider listed, all at once, without holding up the current task, and save each answer with `set_subscription` (plan, quota, purpose and, if they apply, quotaWindow, quotaPool, includedFamilies or paidFamilies, role, onlyFamilies or avoidFamilies, onlyTaskTypes). If a `warnings` entry says a candidate costs extra or is outside its subscription profile, ask the user before delegating to it.
  108. ```
  109. </details>
  110. ### Step 3. Restart your agent
  111. Restart your agent in T3 Code so it loads t3-autopilot and reads the new rules.
  112. ### Alternative: install from the source code
  113. If you prefer not to use `npx`, download the code and build it:
  114. ```sh
  115. git clone https://github.com/pablosalme/t3-autopilot.git
  116. cd t3-autopilot
  117. npm ci
  118. ```
  119. Then follow the same steps, writing `node /path/to/t3-autopilot/dist/cli.js` wherever they say `npx -y t3-autopilot` (replace `/path/to` with the folder you downloaded it to). For example, for Claude Code:
  120. ```sh
  121. claude mcp add --scope user t3-autopilot -- node /path/to/t3-autopilot/dist/cli.js
  122. ```
  123. To update later, run `git pull` and then `npm ci` again.
  124. ## Check that it works
  125. 1. **The program runs.** This prints a version number:
  126. ```sh
  127. npx -y t3-autopilot --version
  128. ```
  129. 2. **Your agent sees it.** In Claude Code, `claude mcp list` shows a line like `t3-autopilot: ... ✔ Connected`. In Grok CLI, `grok mcp doctor` checks the connection.
  130. 3. **It is used.** In T3 Code, ask your agent for something it has to hand off, for example: *"Delegate a review of the README to a child task."* Before it starts, it should tell you in one line which provider and model it picked and why, something like *"review #1: latest gpt on codex is gpt-6.2-codex, effort xhigh"* (the model name is made up).
  131. After the first handoff, a folder called `.t3-autopilot` appears in your home folder. If none of this happens, see [the questions below](#questions).
  132. ## Make it yours
  133. t3-autopilot works with no configuration. To change its preferences, create your own settings file:
  134. ```sh
  135. npx -y t3-autopilot init-policy
  136. ```
  137. This writes `policy.yaml` in the `.t3-autopilot` folder of your home folder. It is a plain text file with ready-made examples, all switched off with a `#` at the start of the line. Open it with any text editor, remove the `#` from the lines you want and save. Changes apply on the next task; there is nothing to restart.
  138. The most common changes:
  139. ```yaml
  140. # Never use this provider (for example, one you keep for yourself):
  141. excludeProviders: [cursor-work]
  142. # Get two options instead of three:
  143. maxCandidates: 2
  144. ```
  145. `cursor-work` is an example: use the provider name your agent shows when it explains its pick.
  146. You can also change which models are preferred for each kind of task, or add a model family that is not in the list. Both are explained in the [reference](docs/reference.md#the-policy).
  147. If you make a mistake in the file, nothing breaks: your agent gets a message that says what to fix, and carries on with its own model in the meantime. A setting whose name it does not know (a typo, for example) is ignored, and your agent is told which one.
  148. ## Your subscriptions
  149. Not every subscription is the same. One has plenty of room, another runs out in minutes, and some apps charge extra for certain models. The first time your agent meets a provider t3-autopilot knows nothing about, it asks you a few short questions: which plan you have, whether its limit is generous or tight and how often it resets (every 5 hours, weekly or monthly), whether it shares that limit with another app, which models it includes, and what you want it for. Your answers are saved, and from then on:
  150. - **A plan with a tight limit is kept for what you said it is for.** It is not used for big or delicate tasks, nor for models you already have elsewhere.
  151. - **Models your plan charges extra for are left alone** while an included one can do the job. If one is the only option, your agent asks you first.
  152. - **Two apps on one plan share one limit.** When one runs out, the other also drops behind the included ones that can still run.
  153. - **A provider that runs out waits as long as its limit lasts:** 5 hours, a week or a month, as you said, instead of a guess of 24 hours.
  154. Until you answer, everything works as before. For example, with Claude Max, an X Premium plan that covers both Grok and Cursor (in Cursor only Grok and Composer are included; Claude, GPT and Gemini are charged apart) and OpenCode Go to try models you have nowhere else, the saved answers look like this:
  155. ```yaml
  156. version: 1
  157. subscriptions:
  158. claudeAgent:
  159. plan: Claude Max
  160. quota: generous
  161. role: primary
  162. grok:
  163. plan: X Subscription Premium ($30)
  164. quota: standard
  165. purpose: main provider for Grok models
  166. role: primary
  167. quotaPool: x-premium
  168. quotaWindow: weekly
  169. cursor:
  170. plan: X Subscription Premium ($30), includes Cursor Pro
  171. quota: standard
  172. purpose: Grok and Composer from the shared weekly quota; Claude, GPT and Gemini cost extra
  173. quotaPool: x-premium
  174. quotaWindow: weekly
  175. includedFamilies: [composer, grok, grok-build, grok-fast]
  176. paidFamilies: [claude-opus, claude-sonnet, claude-haiku, claude-fable, gpt, gpt-mini, gemini, gemini-flash, gemini-flash-lite]
  177. opencode:
  178. plan: OpenCode Go
  179. quota: tight
  180. purpose: only models that are not in my other subscriptions
  181. role: experimental
  182. quotaWindow: 5h
  183. ```
  184. They live in `subscriptions.yaml`, in the `.t3-autopilot` folder. To change one, tell your agent, or edit the file. The details are in the [reference](docs/reference.md#subscription-profiles).
  185. ## Privacy
  186. Everything t3-autopilot keeps is in one folder on your computer: `.t3-autopilot`, inside your home folder.
  187. | File | What it holds |
  188. |---|---|
  189. | `policy.yaml` | Your preferences. Only there if you created it. |
  190. | `log.jsonl` | The handoffs your agent noted: kind of task, provider, model, the settings used, the id of the helper's conversation and how it went. A short summary or note only if your agent adds one (200 characters at most). |
  191. | `unavailable.json` | Providers or models that are out for a while because a limit was reached, with the reason and until when. |
  192. | `capabilities-cache.json` | The last list of providers and models T3 Code gave your agent, and whether each can be used. No passwords or tokens. |
  193. | `subscriptions.yaml` | What you told your agent about each subscription: the plan, how much room it has, what it is for and which models it includes. |
  194. What it never does:
  195. - **It never connects to the internet.** Nothing leaves your computer. (`npx` downloads the program from npm; the program itself contacts nobody.)
  196. - **It never reads passwords, API keys, tokens or cookies,** nor T3 Code's settings files.
  197. - **It never stores the task descriptions** your agent sends when it asks for a recommendation.
  198. - **It never starts agents or changes anything in T3 Code.** It only recommends; your agent decides.
  199. ## Uninstall
  200. 1. Remove it from your agent:
  201. - Claude Code: `claude mcp remove t3-autopilot`
  202. - Grok CLI: `grok mcp remove t3-autopilot`
  203. - Codex: delete the `t3-autopilot` block from `~/.codex/config.toml`.
  204. - OpenCode: delete the `t3-autopilot` entry from `~/.config/opencode/opencode.json`.
  205. 2. Delete the paragraph titled "Model selection for delegated tasks (t3-autopilot)" from your rules file (`CLAUDE.md` or `AGENTS.md`).
  206. 3. Delete the `.t3-autopilot` folder in your home folder, if you do not want to keep your preferences and the log.
  207. That is all. If you installed from the source code, delete that folder too.
  208. ## Questions
  209. **Does it cost anything or use up my subscriptions?**
  210. No. It is free and open source, and it never calls an AI model: it only answers your agent's question.
  211. **Do I need T3 Code?**
  212. Yes. It is built around the way T3 Code hands off tasks.
  213. **Which providers does it work with?**
  214. All the ones T3 Code offers: Claude, Codex, Cursor, Grok, OpenCode, Antigravity, Kiro, Pi, fx, Muse and ACP agents. Any combination works, including two accounts of the same provider. [docs/providers.md](docs/providers.md) has the details of each.
  215. **Does it know how much of my subscription is left?**
  216. No. T3 Code does not share that with add-ons, and t3-autopilot will not read your account tokens to find out. What it does: when a helper cannot start because a limit was reached, your agent notes it, and that provider drops behind the ones that can still run until the limit resets (24 hours if the date is not known; only models your plan charges extra for stay behind it). If you told it how often a plan's limit resets, it waits that long instead (see [Your subscriptions](#your-subscriptions)), and you can tell it which plans run out quickly.
  217. **A new model came out. Do I have to update anything?**
  218. Usually not. Preferences name families ("Claude Opus", "GPT", "Gemini"), and the newest version you have is picked each time. Only a brand-new family needs a line in your settings file.
  219. **Will my agent always follow the recommendation?**
  220. Almost always, but nothing forces it: your agent is an AI model following written instructions. If you name a model yourself for a task, yours wins.
  221. **My agent does not seem to use it. What do I check?**
  222. That step 1 worked (see [Check that it works](#check-that-it-works)), that the paragraph from step 2 is in the rules file your agent reads, that you restarted your agent afterwards, and that `node --version` says 22 or later.
  223. **Can I see how it is going?**
  224. Yes. Ask your agent for the t3-autopilot statistics: how many tasks went to each model and how they turned out.
  225. **Are the model names in the examples real?**
  226. No. Examples use made-up versions so that they never read as claims about real models.
  227. **Where is the technical detail?**
  228. In the [reference](docs/reference.md): the tools, every setting, the file formats and how models are matched.
  229. ## More
  230. - [Reference](docs/reference.md): everything technical.
  231. - [Providers](docs/providers.md): how each T3 Code provider is handled.
  232. - [Contributing](CONTRIBUTING.md), [security](SECURITY.md) and [changelog](CHANGELOG.md).
  233. ## License
  234. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.