Keelokit

Open source · two plugins for Claude Code

Many sessions that can’t see each other. One harbor that brings them to main.

Keelokit makes one Claude Code session work like a disciplined team. Keelokit Harbor is the meta-orchestrator of releases, the powerful part for when orchestrating gets complex: sessions in Claude Desktop, in the CLI and in the cloud, across several accounts, none of which can see the others. Each one finishes its work; Harbor brings it together onto main as coordinated, verified releases, in order.

Both come from hundreds of hours, thousands by now, of developing many projects in parallel, with many sessions on several accounts that had to keep delivering software with almost no intervention, around the clock or unattended.

a convoy heading for main

What each one does

Two plugins, two jobs.

Keelokit looks after the work inside each session. Harbor looks after the work between sessions. They don’t overlap.

Keelokit

v0.13.0 · released

The method for every session.Start here

  • From idea to monorepo: interview, short PRD, stack, skeleton with CI, backlog.
  • A team, not one agent: a verifier writes the tests, a builder makes them pass, a reviewer reads cold, a breaker attacks.
  • Every rule has a check, and a doctor tells you when one is lost.
  • Lands one story on main after a local verify, and stops where a person is needed.

Keelokit Harbor

v0.1.0 · released

The meta-orchestrator of releases.

  • Convoys: many branches are merged into one, verified once and pushed once.
  • A logbook on a git branch that every session, account and machine reads with git fetch.
  • Seals: a branch enters a convoy only with a verify result for its exact commit.
  • One harbormaster at a time, and a cap on sessions per account.

Harbor is built on Keelokit. It runs Keelokit’s verify, reads its state and uses its tiers. Keelokit decides what a story has to prove; Harbor decides when proven stories reach main. Without Keelokit in the project, Harbor does nothing.

Three ways work reaches main

Sailboat, cargo ship, convoy.

Keelokit alone

The sailboat: one small story

A session builds a story, Keelokit verifies it locally, and it lands on main by itself. One verify per landing. This is Keelokit’s default.

build-story · trivial or light tier · landing policy = direct

Keelokit alone · heavier checks

The cargo ship: a big branch

Many files, or a critical area like money or permissions. Same road, full process: more agents, the full verify. Alone, it still docks by itself. Harbor doesn’t measure size; it records the tier.

build-story · full tier or a critical area

Keelokit + Harbor

The convoy: several vessels, one arrival

Each session finishes on its own branch with a seal. They sail together, are verified once as a whole, and reach main in one push. Small and big vessels go in the same convoy.

convoy/<n> · one verify · one push

When to install which

Start with Keelokit. Add Harbor when this starts to hurt.

What decides it is how complex your orchestration is, not how big the project is or how many sessions you run. The signal for Harbor is sessions in Claude Desktop, the CLI and the cloud, on several accounts, that can’t see each other and have to be coordinated, or a whole team developing in the same repo, with work that has to reach `main` as releases that land together and in order.

Sessions that don’t depend on each other’s work, on one account and one machine.

Keelokit alonedirect landing

First time with agents, or building a first MVP.

Keelokit alonedirect landing

Several development CLIs and sessions to coordinate, local and in the cloud, that can’t see each other.

Add Harborone logbook, one convoy

Work that has to reach main as releases: together, verified once and in order.

Add Harborconvoys and the harbormaster’s ok

A whole team developing in the same repo.

Add Harborone logbook everyone reads

More than one Claude account, or more than one machine, the cloud included.

Add Harborshared logbook

Each landing costs a full verify, and every push to main starts a CI run you pay for.

Add Harborone verify and one push per convoy

Several branches keep touching the same files: schema, migrations, shared types, locales.

Add Harborhotspots, one at a time

Solo, one MVP

One laptop, one story at a time, a Claude plan. Keelokit lands each story as it’s proven. Nothing to coordinate.

A couple of stories a day, a helper now and then

A small team where two sessions sometimes run in parallel. Keelokit’s own coordinate skill is enough: the sessions don’t collide.

Desktop, CLI and cloud, across two accounts

Two Claude accounts, Claude Desktop on a laptop, the CLI and a cloud container. None of the sessions can see the others. Each one ends on its own branch; nobody sees the combination until a convoy is assembled and verified once.

A migrations folder everyone touches

Several branches add migrations in the same week and CI minutes are counting. Harbor keeps them out of the same open convoy and pushes once.

Harbor builds on Keelokit, so you start there and add Harbor when orchestrating the releases gets complex.

How they work together

Keelokit proves each vessel. Harbor decides when the convoy sails.

The sessions can’t see each other, so Harbor gives them one thing they all read: a logbook on a git branch. Each session fetches it when it starts, at each prompt and before a push to main, so none of them decides on stale state.

Each session finishes on its own branch with Keelokit’s verify and a seal. Harbor gathers them in a convoy, a skipper assembles it, the harbormaster, one at a time and on watch, gives the ok, and the convoy is verified once and reaches main in one push. Writing the logbook never moves main or starts its CI.

the port is main

harbormaster

The harbor master

One session keeps the watch: gives the ok to sail, renews a heartbeat. If it lapses, any session can take over; the first commit wins.

skipper

The skipper

The session that carries one convoy: merges main and the vessels into convoy/<n> and fixes the combination.

vessel

A vessel

One session’s branch, built with build-story. Big or small, it enters with its exact commit.

logbook

The logbook

The branch harbor/log: TOML files only Harbor writes, and pages generated from them. Everyone reads it with git fetch.

seal

The seal

A verify result for one exact commit. Add a commit and the seal no longer applies: the delivery is void until it is verified again.

hotspot

The narrow channel

Paths you declare as shared (schema, migrations, locales). Two branches touching the same one are never in open convoys together.

account · cap

The crew

Each Claude account has a cap on active sessions and a pause. At the limit, sessions hand over what they pushed, with hashes.

convoy approve

The owner’s yes

A convoy with a full-tier story or a critical area also waits for your yes, typed in your own terminal and tied to that commit.

Every image maps to one mechanism in Harbor’s code. The full table, and where each image can mislead, is on the technical page. The pictures, and what they stand for →

Try it

Install Keelokit. Load Harbor when you need it.

Keelokit

 claude plugin marketplace add leosimini/keelokit claude plugin install keelokit@keelokit

Then run /keelokit:project-new in an empty folder, or /keelokit:project-adopt in a repo you have. You need Node 22 with pnpm 10, Python 3.11+, uv, Docker and git, on macOS or Linux.

Latest release: v0.13.0 · Nov 2, 2026 · What’s new · Download .zip

Download the latest versionCode and license on GitHub

Keelokit Harbor v0.1.0 · released

 claude plugin marketplace add leosimini/keelokit-harbor claude plugin install harbor@keelokit-harbor

Then /harbor:adopt in a Keelokit project (0.12.0 or later). Needs Python 3.11+, git and a remote origin.

Or download harbor-plugin.zip: in Claude, Customize → Plugins → Upload.

Download the latest versionCode and license on GitHub