the words, in plain language.

colony

an isolated sandbox where agents work

one task, in a microvm of its own on a fresh worktree. a settler works here; your credentials never enter it, and the work comes back as a pull request opened by the mothership, not from inside.

mothership

the colonizer app on your computer

it holds your credentials and your git, runs the mesh's control plane, and publishes the results. one per machine.

outpost

a second mothership, on another machine you own

planned. run one on a home server or a spare box, and colonies can run there instead of on your laptop.

fleet

motherships paired together, sharing one view

pairing ships: a single-use invite code, a confirmation code on both screens, one fleet view with a health state per member. not built: a member hosting another member's colonies, and one board of every colony across machines. outposts are what would carry the work; they are planned.

mesh

the private network a colony reaches the mothership over

bundled headscale, or a loopback port on a mac. it is separate from any tailnet you already run, and it is not the public internet. a colony never reaches another colony.

microVM

a throwaway virtual machine, one per colony

a whole virtual machine with its own kernel, started fresh for that colony and thrown away with it. a shared-kernel container would not be enough — but the audit found ways a colony could still cross into the host, and they are open.

settler

a worker agent, one task at a time

takes one task and works in the colony's worktree. the pull request is opened by the mothership, not from inside. there are several kinds, named for what they do.

swarm

several settlers on one goal at once

so a repository gets read from more than one angle instead of one pass down the middle.

hunter

a settler that goes looking for bugs

works in a target repository, reproduces what it finds, and brings back a report with the steps to trigger it.

scout

a settler that reads first and reports

finds where the work is in a repository and says so, before anything is changed.

inspector

a settler that reviews changes and reports

reads a diff or a set of recent changes and reports what it found, rather than writing any.

orchestrator

the colony's main agent

the agent that reads what you asked for and does the work itself, sending out subagents for the parts it delegates. it gets its own model, separate from theirs.

subagent

a settler started for one part of a task

named for the role it was sent out for — scout, inspector, tester and so on. a settler, like the one that started it, and it gets its own model.

nest

every colony live on this mothership

the cockpit draws the nest: one chamber per live colony, dug under the mothership, joined by a tunnel. a red-team raid launches only while the nest is empty — no colony live anywhere on this machine.

harness

the open-source core: mothership, in-vm daemon, agent modules, web ui, mesh

the whole of the mit-licensed thing on your machine — what colonizer itself is. for the part that drives one coding agent inside a colony, the word is agent module.

raid

hunters pointed at a repository, hunting bugs

the red-team run: point a swarm at a repository and see what comes back reproduced.

red team

pointing the swarm at your own code to find problems

the feature area for it. the point is to find the bugs before somebody else does. shipping, but covered by tests only: no raid has run on a real machine yet.

frontier

a system to send work to

your backlog: the issues and repositories a colony can settle. github issues and repositories today. gitlab, linear and jira are named and not built.

forge

the system that holds the code

a frontier sends work here; a forge is where the code lives and the pull request goes. github is the only forge today, and the only source and publisher.

router

what picks the model for each kind of work

picks the orchestrator's model from the issue — its labels, length, checklist and the paths it names — by a rule with no model behind it. picking a model by reading the request is planned, not built.

cockpit

the web ui the mothership serves

colonizer's browser front end, on 127.0.0.1:7878 by default, behind a per-install token. no accounts: the sign-in link the mothership prints is the way in. the cli does the same work from a terminal.

autopilot

the mothership opens the pull request for you

a setting on the publish module, on by default. when the agent finishes cleanly and has written its pull request description, the mothership commits, pushes and opens the pull request itself. --no-autopilot turns it off. it is about publishing, not about picking up the next task.