The harborloop CLI: wire Harbor into your coding agents.

Start here, with no account

harbor context needs no account, no token and no network. It reads the files your agents already load on every turn, prices them, and says who put each one there. Run it before you decide whether any of the rest of this is worth your time.

npx harborloop context

  always-on budget on this machine   at least ~542 tok / turn
    skills index (6)                 ~219   0 managed by harbor · 6 unowned · 0 from other tools
    skill files not indexed (2)         —   no description — nothing can select them, and nothing here can price them
    agent definitions (2)            ~115
    agent files (4)                  ~208
    MCP tools (0)                       —   tool descriptions live on the server — connect to price them
    injected context                    —   varies per session — no on-disk record to read

  managed by harbor: 0 of 6 · unowned: 6 · other tools: 0
  2 more files in a skills root carry no description — write one, or they are shelf-ware

Three of those lines carry a dash rather than a number, and the dash is the point. A skill with no description cannot be selected by anything, so nothing here can price it. Tool descriptions live on the server, so a machine with no connection cannot count them. Injected context varies per session and leaves no on-disk record. A zero in those places would be a claim we did not measure, and it would be the flattering one.

--verbose lists every skill with its own cost and owner. --json prints the same measurement for a script.

Install

You need a workspace first, because init signs in to it: sign up and name one. Then, with Node 18 or newer. The install is two packages: a small launcher and the compiled binary for your platform, picked by npm from the optional dependencies. There is nothing else to install and no desktop app required.

npx harborloop init

init does three things: signs you in through your browser, installs Harbor’s MCP server and hooks for every agent it finds on the machine, and turns Harbor on in this repository, in your workspace’s only Space (it asks which when there are several). Run from npx, it also offers to install the harbor command, so the rest of this page works in any terminal.

On the way it may ask up to three questions:

• Which Space does this repo belong to? With more than one Space. Enter is none for now: Harbor is on in no Space, and what the repo’s sessions learn waits in Review until harbor bind --project <Space> names one.
• Turn Harbor on in https://github.com/acme/acme-api? Only in a workspace with other people in it and one Space, because what the agent learns here is shared with them. Enter is yes; --no-bind leaves the repo off without asking.
• Send their rules to your team’s review queue? When the repo commits a CLAUDE.md, an AGENTS.md, a .cursorrules, Cursor rules in .cursor/rules/*.mdc, or a .github/copilot-instructions.md: at most 10 files a run, 64 KB each, the text as committed. Enter is yes. --import-rules sends without asking and --no-import-rules neither asks nor sends. Every rule waits in Review for a person.

Which config files does harborloop change?

Each agent’s own user-level config, and its own folder, ~/.harbor. It writes nothing into your repo. init adds a harbor MCP server entry and Harbor’s hooks to the files below, and leaves every other entry in them as it was.

~/.harbor holds the hook scripts (in ~/.harbor/bin), your sign-in, and the list of repos Harbor is on in, which the hooks read before every prompt with no network call. Devin reads Claude Code’s hooks by default, so it gets Harbor through Claude Code’s entry; Gemini CLI and OpenCode run none of them, and harbor doctor says so.

harbor uninstall takes all of it back out: the hooks, the MCP entries and ~/.harbor. First it asks Harbor to cancel this machine’s sign-in and each agent’s key, so a copy kept anywhere else stops working, and it names any it could not cancel with the date it expires. Your config files keep everything else, and your workspace and its knowledge stay. If you installed the harbor command with npm, it ends by naming the one step it cannot run itself: npm uninstall -g harborloop.

Every command

harborloop has eighteen commands, in the order harbor help prints them.

Two more answer without a row of their own. harbor help prints this list, and --help on any command prints it without running anything. harbor version (or --version) prints the release.

What does harbor doctor check?

harbor doctor checks the whole chain, from the endpoint and your sign-in to whether a prompt in this repo actually received anything, and it is built to be able to say no. It is the one command worth running when something feels wrong.

  Endpoint        ✓ https://app.gethrbr.com/v1
  MCP target      ⚠ no harbor MCP server registered — tool calls reach no graph
                    ↳ harbor init
  Signed in       ✗ no credential on this machine
                    ↳ harbor init
  Token           ✗ no MCP bearer in ~/.claude.json or ~/.codex/config.toml or ~/.cursor/mcp.json or ~/.copilot/mcp-config.json
                    ↳ harbor init
  Hooks           ✗ not installed — nothing runs on a prompt
                    ↳ harbor init
  Codex           ⚠ installed on this machine, but not configured — its sessions get nothing
                    ↳ harbor init
  Cursor          ⚠ installed on this machine, but not configured — its sessions get nothing
                    ↳ harbor init
  Copilot         ⚠ installed on this machine, but not configured: its sessions get nothing
                    ↳ harbor init
  This repo       ✗ Harbor is off here: https://github.com/acme/acme-api is not bound
                    ↳ harbor bind (if this repo should use Harbor)
  Sent to harbor  ✓ once a day: this machine's id, hostname, OS and harborloop version, and the tools, scripts and deny rules each connected repo commits. Never file contents.
  Recording       · not configured
  Version         · not checked (--offline)
  Recall          · not checked (--offline)
  Fit             · not checked (--offline)
  Attribution     · not checked (--offline)
  Contributed     · not checked (--offline)
  Recall delivery · no prompts recorded yet

That is a machine with Claude Code, Codex, Cursor and Copilot installed and nothing set up, which is the run worth printing: every failing line carries the command that fixes it, and no line claims a state it did not check. A dot means not measured: Recording has nothing to record yet, and Recall delivery has seen no prompt.

--json gives the same checks as structured output, for a CI step that should fail when the loop is broken.

What does the receipt show?

The receipt is the short note Harbor prints into your own Claude Code or Codex session to say what it did. The agent does not write it. It comes in two places.

After an answer: the team rules it used. The rules Harbor hands your agent are numbered, and an answer that used any ends with a line like harbor-applied: #3 #7. At the end of the turn, Harbor prints what those numbers were, each with what kind of rule it is and where it came from:

⚓ Harbor: your agent used 2 team rules
   #3 Money is integer cents
      rule · via GitHub · acme/acme-api#312
   #7 Validate input with zod
      rule

It names up to five, then a line like + 2 more for the rest. Only rules this session was sent count: a number the agent read in a search result is left out rather than guessed at. A turn that used none prints nothing.

Under a save: where it went. When the agent saves a learning, the line under the call says what Harbor did with it:

⚓ Harbor saved a rule
   No default exports
   Your team's agents get it from their next session.

The other endings: It replaced an older rule. Your team’s agents get it from their next session.; held a rule for review with It reaches your team once someone approves it in Review. or It contradicts a live rule, so both wait for a decision in Review.; and saved your preference with Only your own sessions get it.

Both are on by default since harborloop 0.6.12. harbor off --receipt turns both off on this machine, and harbor on --receipt turns them back on. Recall and recording are not touched, and the reply says so:

This machine: the receipt is off. Rules still reach your agent, and its answers still end with harbor-applied.
This machine: recall on, recording on.

Read the count as an upper bound. It lists what the agent says it used, and agents claim more uses than really changed their work.

harbor status

status is the small, local, no-network answer to “is this repo wired up?” It reads files on disk and nothing else, so it is instant and it works on a plane. It prints one line per agent it finds, Copilot included.

  Workspace ✗ not signed in
              ↳ harbor init
  Repo      ✗ https://github.com/acme/acme-api: not bound
              ↳ harbor bind
  Hooks     ✗ not installed
              ↳ harbor init
  Codex     ⚠ installed here, but not configured
              ↳ harbor init
  Cursor    ⚠ installed here, but not configured
              ↳ harbor init
  Copilot   ⚠ installed here, but not configured
              ↳ harbor init
  Recording · not configured

Binding a repo

Harbor is on only in repos you bind. Run harbor bind inside a repo to turn it on.

With one Space in the workspace, the repo goes into it. With several, bind asks which, or you name one: harbor bind --project <Space>. If the repo commits rules files it asks the same question init does, once, before anything leaves the machine:

This repo commits CLAUDE.md and AGENTS.md.
Send their rules to your team's review queue? Harbor reads the text
with a model (keys and tokens are blanked first), and nothing reaches an
agent until someone on your team approves it. [Y/n] n
Harbor is on in https://github.com/acme/acme-api, Space "Backend".
1 repo in this workspace has Harbor on.
Rules: CLAUDE.md and AGENTS.md not sent, as you chose. `harbor bind --import-rules` sends it later

Enter is yes, and the summary then says how many rules wait in Review, with the link. On a repo that is already bound, naming a different Space moves it there. Moving a repo takes the repo.bind capability, which owners, admins and curators hold. Scoping rules by repo and team with Spaces has the rest.

In a repo Harbor is off in, Claude Code and Codex say so once, on the first prompt there: ⚓ Harbor is off in this repo, so your agent gets nothing from Harbor here. To turn it on, run harbor bind. An agent cannot run bind for you; it hands you the command.

Pausing a repo

Plenty of sessions are throwaway, and none of that belongs in your team’s graph. harbor off stops both halves: no context in, nothing recorded.

This repo (https://github.com/acme/acme-api): paused. No context in, nothing recorded.

--capture pauses only the recording, so you keep recall while you experiment.

This repo (https://github.com/acme/acme-api): recall on, recording off.

This repo (https://github.com/acme/acme-api): recall on, recording on.

--global applies the pause to every repo on the machine. The pause is read from a local file before any network call, so it takes effect immediately and holds with no connection. Only you can pause or resume: an agent’s harbor off or harbor on is refused.

In a folder that is not a git repo, harbor off pauses every such folder on this machine: Harbor is off in folders outside a repo on this machine. Run harbor on in one of them to turn it back on. In your home folder itself neither verb changes anything: Harbor is already off in your home folder.

Workspaces

harbor workspaces lists the workspaces this account can reach, with their ids, and marks the one this machine is using with a *. Switching needs no browser:

harbor login --workspace <id>

--no-browser prints a sign-in URL instead of opening a browser: open it on any machine, sign in, and paste the code the page shows back into the terminal. That is the path for a remote shell or a container.

Staying current

harbor update brings the machine to the latest release and re-points the installed hooks at it. That second half matters more than it sounds: hooks are recorded by path, so a binary that moved leaves scripts that are listed, enabled, and doing nothing.

harborloop 0.6.15 is the latest release.
The installed hooks do not point at this binary. `harbor update` re-wires them.
No agent on this machine is set up to run the hooks, so nothing is recalled or recorded.
`harbor update` re-runs `harbor init`, which registers them. `harbor doctor` has the detail.

--check reports and installs nothing, which is the form for a scheduled job or a shell prompt.

You also hear about a new release without running anything. When one is out, Claude Code and Codex show ⚓ harbor <version> is available. Run: harbor update when you submit a prompt. On a machine that did not install harborloop with npm, it names npx harborloop@latest init instead. harbor off --receipt does not hide it, because on a machine where nobody runs a harbor command, it is how you hear about an update.