Skip to main content
You need the to11 binary on your PATH and a to11 account in your company’s organization. Nothing else — skills arrive as files, so there is no runtime to install and no agent setting to edit by hand.

Install the CLI

The CLI runs on macOS and Linux, on x86-64 (amd64) and ARM (arm64). There is no Windows build yet.

Install with asdf

asdf set arrived in 0.16. On 0.15 and older the last command is asdf global to11 latest, and asdf --version says which applies. Both write the pin to $HOME/.tool-versions; the directory-local forms leave to11 resolving only under the current directory.

Manual installation

Each release carries one archive per platform, to11_<version>_<os>_<arch>.tar.gz, a checksums.txt, and that file’s cosign signature, checksums.txt.sigstore.json — keyless: the signature is tied to the exact CI workflow that produced it, not a key you have to trust or that to11 has to protect. Set the version, your OS (darwin or linux) and architecture (amd64 or arm64), then download, verify, and install:
Verified OK from cosign confirms checksums.txt came from that exact workflow, in that exact repository, unaltered — checked first, because a checksums.txt an attacker also rewrote would otherwise pass its own checksum line for a replaced archive. The greps isolate $ARCHIVE’s own line rather than checking every entry in checksums.txt: shasum -c’s --ignore-missing flag would otherwise report overall success as long as whatever files happen to be present match, even if $ARCHIVE itself was never named or never actually checked - a leftover archive from a prior download in the same directory could satisfy it without $ARCHIVE being verified at all. On Linux, use sha256sum in place of shasum -a 256. Both the grep guard and the checksum line must succeed for your archive; if any check fails, nothing after it runs — nothing is extracted or installed. The last step runs the installed copy directly, so it reports the version you just installed. Use the newest version from the releases page. To run to11 by name, ~/.local/bin must be on your PATH — it is not by default on macOS — or install into another directory that is.
On macOS, download with curl as shown, or use Homebrew or asdf. The binary is not notarized, so a copy downloaded through a browser is quarantined and macOS refuses to run it. If you downloaded the archive, checksums.txt, and checksums.txt.sigstore.json that way, cd into the folder that holds them, set VERSION, OS, ARCH and ARCHIVE as above, and run xattr -d com.apple.quarantine "$ARCHIVE" before the verification step. Skip the three curl lines.

Configure this machine

Run to11 outside any git repository — your home directory will do:
to11 links your home to a project and then fetches its skills. It asks only what it cannot work out, one question at a time:
  1. Sign-in — when nobody is signed in, it says First, sign in. and waits for Enter before it opens your browser. Ctrl-C stops without storing anything.
  2. Organization — asked only when you belong to several.
  3. Project — Which project?, from the projects you can read. You receive every skill the project has.
  4. Skills — All skills are installed, including ones published later: names the skills the project publishes on latest. OK receives them all, and every skill the project publishes later. Customize opens Which skills?, all checked, with the highlighted one’s description under the list: uncheck the ones you do not want with space — type to search by name, and space on Select All checks or clears every one. To pick without the list, name them: to11 link --skill code-review --skill incident-triage. They are disabled in your file (disabled: true) — in your home file, that turns them off in your own directories only; a repository that asks for one still installs it there, unless you write enforced: true beside the disable. Then Install new skills automatically? asks whether a skill published later arrives too: Yes (the default) keeps following latest, No keeps exactly the skills you checked.
  5. Targets — Skills are installed for: lists the coding agents it writes skills for and the directory each one reads. Customize opens Which agents?, to choose Claude Code, Codex, or both. A standard target already in your file is kept.
  6. Plugin — Install the to11 plugin for …?, for Claude Code and Codex where they are on your PATH without it. It carries the refresh points that keep skills current while a session is open, and the skills that set up this CLI. It is installed for you, in every project. Decline it and nothing is wrong — your skills update when you run to11 skill sync.
  7. Auto-sync — Sync your Claude Code sessions to to11 automatically?, defaulting to No. Yes sends each Claude Code session to the project you linked after every response, through the plugin’s hooks; to11 session autosync changes it later. The project is written to ~/.to11/sessions.yaml, where you can point the sessions at another project.
Once the project is settled it writes ~/.to11/skills.yaml and prints ✓ Linked skills from <project> @ latest, and Saved to with the file; Ctrl-C before that leaves your file as it was. The sync that follows lists each skill it installed. Every later to11 in your home, or in any directory outside a git repository, is that sync, and asks nothing. Inside a repository that is not linked yet, to11 offers to link the repository instead — see below. To link without syncing, or to answer each question as a flag — to11 link --project sre/runbooks --yes — use to11 link. Inside a repository, to11 link --global links your home. If a published skill would land on a directory name you already use, set prefix in skills.yaml — acme delivers acme-<slug> instead of <slug> — and every delivery moves out of the way at once. to11 does not ask for it, and keeps it when it saves; to11 link --prefix acme sets it. to11 ui opens an overview of what is set up, marks anything that no longer holds, and lets you change any of it.

Configure a repository

To decide which skills apply to work in a repository, run to11 inside it:
Inside a repository to11 links the repository, not your home. When the repository’s folder has the name of a project you can read, it offers that project first; otherwise it asks Which project?. A repository that already has a .to11/skills.yaml is linked: to11 syncs it and asks nothing. to11 link re-links it, taking the file’s project when it names one, and a project you choose is added to the file, keeping the entries your teammates added. Linking the repository writes <repo>/.to11/skills.yaml, which is committed. It also writes <repo>/.to11/sessions.yaml, which names the project for your own Claude Code sessions there and stays out of git. Your own configuration still applies — both are in effect at once, each writing into its own directories — so a repository’s skills are added to a colleague’s own. The plugin is still installed for you, never into the repository’s agent settings.

Skills you already have

If the directories your agent reads already hold skills, the link takes them in right after ✓ Linked, before the first sync:
  • A folder identical to a version the project publishes is adopted without a question. This is how skills to11 delivered come back after ~/.to11 was deleted.
  • A folder the project does not have is offered in Upload local skills to <project>?, with nothing selected. An upload stores it in the project as its newest version, which is latest, so this location receives it without a pin; everyone following the project receives it on their next sync. It needs a description in the front matter of its SKILL.md.
  • A folder with the name of a skill the project has, and other content, gets one question: keep mine disables the published skill for this location and leaves your folder alone — unless another of your agents’ directories already holds the published skill, in which case your folder is left as it is and that directory keeps receiving it; upload stores your folder as the next version; take replaces your folder with the published version and deletes your files.
Folders installed by skills.sh, symbolic links, single <name>.md files, and folders for a skill the project has but this location does not receive are left alone. If folders you adopt, upload or take are committed to the repository, the link’s import step ends with one git rm -r --cached command that stops the repository carrying them. It never runs it, because committing them may be what your team wants. To answer later, or one folder at a time, run to11 skill import — to11 skill import --skip lists what it found. Inside a repository it lists the repository’s folders and your home’s, each going to its own location’s project. A bare to11 in a linked location does not look at these folders again: the sync reports each one in a delivery’s way as blocked.

Configure without a terminal

Without a terminal — or when a coding agent runs it — to11 asks nothing. What it still needs comes back as one action_required JSON object, whose next commands, such as to11 link --project acme/web --yes, finish the link without a prompt. When the targets already hold skills to11 did not deliver, the link is written and then stops once with unmanaged_skills, whose next commands are to11 skill import lines. Signing in still needs a person at a terminal. For CI, a container, or a provisioning script, where nobody signs in, write the configuration yourself and set TO11_API_KEY. API keys are for machines like these; nothing stores one any more, and the credential order says which one a command uses:
Inject the key from your CI provider’s secret store rather than writing it into the command or the script — a value on the command line reaches your shell history and the environment of everything the script starts.

Check what you received

One row per skill, with its version, its state, the target it went to and where it came from. A skill your configuration names but that did not arrive is a row too, and its state is the reason. If something needs putting right, to11 skill sync runs an explicit sync and reports what changed, what it left alone, and what it could not place.

Next steps

CLI overview

What the CLI puts where, how refresh works, and what it never does.

Configuration

The file that decides what you receive — including how to disable a skill.

Publishing skills

Writing a skill, and storing a version everyone who follows the project receives.

Errors & exit codes

What a failure looks like, and what keeps working when one happens.