node banner.jsa release crossing the line, live

regatta

Pre-alpha: two modules are in the public repo, the core and helloworld. The rest are moving in, one by one.
macOS first: the night jobs run on launchd.

Ideas in. Releases out.
Every decision in git, signed.

regatta is an open framework for a business run by agents: Claude Code plugins, one per module, that take an idea to a release and keep the records. A voice memo becomes an idea, the idea a plan, the plan a branch, the branch a release, and the release a number someone checks a month later. Every step is Markdown in git, with the name of whoever decided it. Take one module, or the fleet. A 220 Labs tool.

The core moved into its repo on 17 October 2026, and the repo went public on 19 October. Each module below says what it does today and what is planned.

See the course Read the code

The course

Clockwise from sparks, the build: which to sail, the water ahead, the plan, build and launch, runs by itself, and the finish under the blue flag. Then the run: the public door, measure, decisions, remember, the night, and round again to the next idea. lighthouse keeps every machine lit.

Why regatta

The whole lap, not only the launch. Most frameworks for a business run by agents stop at the release, or at running agents on a schedule. regatta gives the run home the same five marks as the build: the public twin, the numbers, the decisions, the lessons and the night watch. The run home has no fireworks; it gets the marks anyway.
Your attention is the budget. Questions reach you batched in one doc, each with a recommendation. You answer inline, and the answers come back as commits. Nothing waits on you in a chat window.
Git is the only state. Ideas, plans, decisions and releases are Markdown in git, signed by whoever decided. The log is the audit trail: read it, revert it, fork it.
Work lands itself, behind gates. A finished branch goes out through a pull request once the project's check, a review and, for anything public, a privacy scan have passed. When the week's budget runs low, it waits.
Lessons have one home. What a session learns is filed once, where the next session looks first; the night job reads the week and proposes what to change.
One module at a time. Each is a Claude Code plugin of its own: take one, or the fleet. No server, and no new platform to learn.

Pre-alpha, plainly: most of this runs in the authors' own setup today, and each module joins the public repo as it is cut out. The list below says which.

What it needs

Claude Code, git and Python 3.9 or later. Nothing else is installed.
GitHub: a release launches through a pull request, and the public door is a public repo.
A Mac for the night jobs, for now.

Modules · take one, or all thirteen

sparksAn idea, spoken or jotted, becomes one note in the right placetool moving in

You say an idea into your phone, or type a line into a note, and by the time you sit down it is one note per idea, in plain words, filed where it will be read, committed. It reads the audio and the notes you point it at; nothing else.

It decides nothing about what to build. That is sextant's job, and sparks is sextant's intake.

Principles

One note per idea, never a transcript.
Filed where it will be read, not where it arrived.
Redacted before it is written down.

Today

Runs in the authors' setup: voice memos, written notes and Apple Notes in.
Audio transcribed on your machine with whisper.cpp; a redaction pass before filing.
Each note committed to a knowledge vault or a project's docs.

Planned

Moves into the sextant plugin as its ideas intake, the next build step.
An install script: the launcher, the schedule, the two macOS grants.
A note sent to a chat, with polyrhythm installed.

sextantA north star in one file; the week's ideas and numbers read against itframework moving in

Your north star, goals, priorities and budgets in one file. Every week the module reads the numbers, the ideas pool and your ventures against it, turns kept ideas into proposals and the best proposals into candidates with a verdict. A candidate that is safe to build starts on its own, inside the budget you set.

It does not set your goals, and it never launches past a question only you can answer.

Principles

The mechanism is public; your strategy stays private.
A candidate names its goal, its estimate and its verdict.
Nothing unattended past a Reversible: no question.

Today

Runs in the authors' setup: a weekly pass writing proposals from ideas and numbers.
Goals live in no file yet; every launch is still by hand.

Planned

north-star.md: goals, priorities and budgets, parsed and checked.
Candidates, a queue, and launches armed only after one dry week.
A sounding before each launch, checked against the charted shoals.

navigatorThe meeting watch: a brief before, a page during, notes filed aftertool being built

The meeting watch, on sparks' pipeline. Five minutes before: a brief from your calendar. During: one page, half a screen wide, with what to say, the context, the transcript tail and research on a question you mark, with URLs. After: notes filed where they belong, follow-ups seeded. Nothing starts before the disclosure line is said.

It never joins the call or speaks in it. It records, and the other side's words reach a model only under wording you chose; a call that forbids listening is refused.

Principles

Nothing listens before the consent line.
Spend per meeting is tracked; over the cap, it says so.
Each organization gets its own wording, login and storage.

Today

Being built, 1 of 8 steps done: the mic transcript on a local page.
No model in the loop yet; audio and transcript archived outside git at stop.

Planned

A brief before each meeting, from the calendar you point it at.
Live suggestions in 1-3 seconds; a 120-second research run on a marked question.
Notes filed through sparks; organization profiles with their own disclosure.

helmA big idea becomes ships, blocks and tasks; skippers keep them movingframework moving in

A large idea arrives as one doc. helm breaks it into ships, blocks and tasks, hands each task to wharf, retries what stalls, relays the one question that needs you, and keeps a board that shows what waits on whom. Skippers, the manager agents, run a ship each.

It builds nothing itself and runs no session: wharf does. There is no bare helm command either; Kubernetes owns that name, so the verb is regatta helm.

Principles

One skipper per ship; you answer only Reversible: no.
A stall is retried before it is reported.
The board shows what waits, and on whom.

Today

Runs in the authors' setup: blueprints, the tick, asks, the board.
Moves into the repo after the build and run modules.

Planned

Skippers as agents, one per ship.
A ship starts itself once its course is answered.
Groundings counted; a cause seen twice is charted as a shoal.

wharfOne session, one worktree, every turn committed, a clean landing by PRframework moving in

One session, one worktree, on its own branch. Every turn that changed a file is committed, with the prompt quoted. A finish curates the branch into clean commits, proves nothing was lost, runs the review gate and lands it through a pull request. main is never written by hand.

It needs git, GitHub and a terminal, and it runs while someone is in the session. Starting work with nobody there is wharf-runs.

Principles

main moves only through a pull request.
Every turn that changed a file is a commit.
Git is the only state.

Today

Runs in the authors' setup: the hook, /finish, /todo, the review gate, seven agents.
Needs git, a GitHub remote and gh.

Planned

Moves into the repo in two steps, the hooks first, then the tools.
A word scan on each commit message before it reaches main.

wharf-runsA branch with a brief, started with nobody at the keyboardframework moving in

A branch seeded with a brief starts on its own at the time you set, in a fresh session, and ends in a pull request. A chain starts the next step itself. A branch left idle and green lands about forty minutes later, every gate run, the week's budget first.

It needs wharf, and today macOS: the schedule runs on launchd. It does not choose what to build; a brief does.

Principles

A run starts fresh, from a brief in git.
Every gate stops it; the week's budget first.
Idle and green lands itself.

Today

Runs in the authors' setup: dispatch, chains, the lander, two harnesses.
macOS only: launchd runs the schedule.

Planned

Moves into the repo after wharf.
install.sh --schedule for the jobs; hosts from config, never a literal.

regattaThe committee boat: what every module shares, and nothing elsecore in the repo

Every module needs the same few things: one library, a table that says which model and effort each task gets, a price shown as list and effective, a secrets check, and one command that says what is installed. The core is those things once, so no module carries its own copy.

It runs no business by itself. Install it alone and you have a config directory and a CLI; the work starts with the first module beside it.

Principles

One library; no module keeps a copy.
A model and its effort are a table row, not a prompt.
Hosts, logins and people live in config, never in code.

Today

In the repo: the library, the model gate, cost, secrets, the CLI.
install.sh names the clone in the config directory; check says what is missing.
Needs Python 3.9, git and Claude Code; macOS first.

Planned

regatta helm, the verb for the project module once it is installed.
A contract check every module passes before the marketplace lists it.
Config in one directory, so a second machine is one install.

helloworldThe public door: name it, then publish it behind a privacy scantool in the repo

The door from a private repo to a public one. Name the project first: handles, domains and packages probed, then a decision doc. Then publish: the allowlisted files go to a public twin behind a privacy scan of every path, word and commit message, and the scan fails closed. The first push and every merge are yours.

It will not make a repo public for you, and it has no opinion on your code. It gates words, paths and names.

Principles

What goes public is an allowlist, never everything-but.
A private word never reaches a twin; the gate fails closed.
The public history should read like the private one.

Today

In the repo: name-check, /name, publish, and check as the source repo's gate.
This repo's own twin is published through it, since 2026-10-19.
A publish is one squashed commit today.

Planned

Replay: each curated commit becomes one public commit, scanned on its own.
A failing commit folds into the next that passes.
The word scan at the source, before a commit reaches main.

plumbUsage, cost and interruptions, counted, with the command behind eachtool moving in

What the agents cost, in dollars and in attention, counted. Usage and cost per project and per week, list and effective; how much of the week is left and a tier hint at the first prompt; how often a session stopped to ask you. Every number comes with the command that made it.

It measures; it does not throttle. The gates that read its numbers live in the modules they guard.

Principles

Every price: list and effective.
Count what cost attention, not only what cost money.
A number has a command that reproduces it.

Today

Runs in the authors' setup: usage, cost, the week, interruptions, a status line.
Benches for decisions, sessions and redaction, run by hand.

Planned

Moves into the repo with its benches.
Groundings per week, for helm's board.
Limits per login, from config.

keelYour questions in one doc, answered inline, taken back as commitstool moving in

Every question a session has for you reaches you in one doc: a numbered list, each item with its options and a recommendation, on its own branch, with a page you can read on your phone. You answer inline. The answers come back as commits, and the session carries on.

It asks only what you must answer: an irreversible choice, two good options, money, or a third party's say. The rest is built and reported. A Reversible: no item is always yours.

Principles

One place to answer, each item with a recommendation.
Ask only what is irreversible, costly, or a real fork.
An answer is a commit, never a chat line.

Today

Runs in the authors' setup: the D-list, keel lint, the page, answers as commits.
A reply-ending lint that blocks a question asked outside the doc.

Planned

Moves into the repo in the build step after sparks.
Reads the other modules through guards, so it works on its own.

atlasWhat was learnt goes to one home, and the next session finds itframework moving in

What a session learns outlives the session. A fact gets one home: the bulletin every session reads this week, the rules every session loads, a project's docs, the knowledge vault. Promotion moves it up; the records and charts keep the long story. The next session finds it without being told.

Plain files in git: no index, no embeddings, no search service. It remembers what a session filed, nothing it did not.

Principles

One home per fact; the others point at it.
Short-lived things expire; rules are dated.
A lesson that failed twice becomes a mechanism.

Today

Runs in the authors' setup: the bulletin, /share, /promote, vault commits, the docs index.
Transcripts archived; records and charts kept by the night job.

Planned

Moves into the repo after the build and decision modules.
A vault commit lands through a pull request when wharf is installed.

auroraAurora Borealis, the night job: the week read, charted, digestedframework moving in

Aurora Borealis, the night job. While you sleep it reads the week, memory, bulletin and transcripts, and writes one reviewed diff of what should change in the rules; it updates the charts, digests the week and tends the branches. Monday starts with the reading done.

It changes no rule on its own: the diff waits for you. It needs atlas, wharf and plumb; without numbers it has little to say.

Principles

One reviewed diff a week, never a silent edit.
The night reads; the morning decides.
Every rule change is dated.

Today

Runs in the authors' setup: the weekly loop, the dream, the charts, the digest.

Planned

Moves into the repo right after atlas.
Its schedule under install.sh --schedule.

lighthouseHealth, declared settings and logins on every machine you runtool moving in

The machines stay in shape without anyone remembering to. Settings are declared in a file and written to each config directory; a health check runs daily and names its fix; logins, trusted projects and windows are set the same way. Drift is reported, never quietly repaired.

It writes only what a declared file says, and it keeps one machine at a time. There is no fleet view.

Principles

Declared in a file, applied by a script, drift reported.
A finding names its fix.
Nothing a person must click twice.

Today

Runs in the authors' setup: health, declared settings, the login walk, trust, tiling.
macOS: the schedule and the window tiling are Mac tools.

Planned

Moves into the repo after measure.
Shoals, the causes of a stuck run, kept as items here.

Install

claude plugin marketplace add 220labs/regatta
claude plugin install regatta@regatta
claude plugin install helloworld@regatta

Each module is a plugin of its own and needs the core. Two are in the marketplace today; the others join as they move in.