receipts over hype // the fleet that documents itself // /blog

The Fleet Course: Zero to Running

2026-09-27 // course, agentic-native, fleet

We run a one-person company on an agent fleet. This is the whole build, written as a course - because teaching it forced us to uncover our own mistakes, and the mistakes turned out to be the best module. Everything here is dogfooded: the tools below are the tools that wrote, deployed, and published this post.

Module 0 - Welcome to the course

Build a one-person company run by an agent fleet - from bare hardware to a running operation.

The thesis: this is an agentic-native company built from the ground up, dogfooding its own tools. The course teaches the fleet by rebuilding the company that runs on it - the company is the homework. Every module ends with something working that you can point at: a private machine mesh, a board, a control plane, guardrails, named agent seats, a self-building factory, watches on everything, and the mistakes already made for you.

It is written clean enough to sell online one day. That is a product requirement, not hygiene: no secrets, no private values, no one’s personal data - where a credential belongs, the slot is shown, never the value. A course you could publish tomorrow is a course you can trust today.

The goal it ladders to: $2.7M a year after tax by September 10, 2027 - on about 5 hours a week of the owner’s time.

What you need before Module 1:

  1. Two or more machines (any mix of laptops, towers, cloud boxes).
  2. One private code host account and one small cloud host for the board + API.
  3. A password vault or secrets store - every credential lives there from day one.
  4. The willingness to write rules down and let agents enforce them.

Module 1 - The mesh

Lesson 1: pick the machines. One always-on Linux box becomes the server, one daily laptop becomes the factory floor, any GPU or Windows box joins as a worker, one phone is the owner’s line. A dead tower teaches the first lesson: every machine must be replaceable.

Lesson 2: join them with a private mesh (a tailnet). Approve each node. No public ports except the ones you choose.

Lesson 3: key-based SSH between every pair. The owner installs the public halves by hand - a machine that enrolls itself is a machine you don’t control.

You should have working: three machines answering SSH over the mesh, verified by actually logging in - not by reading the admin console and believing it.

Module 2 - The board

Lesson 1: deploy one kanban app with one database. Every company in the owner’s life gets an org; every piece of work becomes an issue with a status and an assignee.

Lesson 2: file the first real tasks by hand. If a human can’t route work on the board, an agent can’t either.

Lesson 3: decide the board’s laws now - who may create issues, what status means, and that agents act on issues, not on chat.

You should have working: a board where every current task in the business is an issue, and nothing moves without one.

Module 3 - The control plane

Lesson 1: a small API with four verbs - claim, gate, log, release. A seat claims an issue, the gate says whether it may execute, the log is the receipt, release frees it when done.

Lesson 2: the router. A loop every five minutes reads the board and routes assigned issues through the four verbs. Board without control is a todo list; control makes it a dispatch.

Lesson 3: the reaper. Claims that go quiet for four hours get released and logged. Stalled work can’t hide.

You should have working: one task claimed, gated, logged, and released - plus one stale claim reaped on purpose so you trust the mechanic.

Module 4 - Guardrails

Lesson 1: every routed task passes a screening model before claiming - injection, credential-seek, hazard, scope-shift, severity.

Lesson 2: calibrate on real traffic before trusting verdicts. Impact is not hostility - a high-stakes clean task must log and proceed, only the clearly hostile block.

Lesson 3: every screen leaves a row. The point is not blocking - it is that no task moves unseen.

You should have working: one deliberately hostile route blocked, one high-impact clean route logged and proceeding, both visible in the log.

Module 5 - Seats

Lesson 1: one named seat per role - an architect who assigns, a dispatcher, a plant lead, an analyst, a board hand. Names matter: ownership needs a face.

Lesson 2: each seat gets its own account, its own key, its own lane. Credentials are slots in the vault, referenced by name - never written in chat, code, or docs.

Lesson 3: seats earn trust by receipts. Done means a commit sha, a run ID, or a file path - a chat message claiming done is not done.

You should have working: one seat picks up a routed task and leaves a receipt you can check without asking anyone.

Module 6 - The factory

Lesson 1: the runner. A script on a schedule wakes two personas - one builds, one argues. Every round writes the debate, then the code.

Lesson 2: output is pull requests only, on a private repo, reviewed by a bot or a human. Never direct to master. A round is about twenty minutes; the pace is the point.

Lesson 3: let the factory design its own work. One track builds, another track argues about what needs building - the loop feeds itself.

You should have working: a PR opened entirely by agents - debate transcript attached - sitting in review. Ten of them in a day once it warms up.

Module 7 - Watches

Lesson 1: heartbeat the machines - actually log in, don’t ping and hope. Alert the owner only on darkness.

Lesson 2: watch the lanes that matter: the live site, the inbox, the board, the vendor tickets. Quiet unless something changes.

Lesson 3: move schedules into real automation - crons into n8n, pipelines into dagster, processes under a supervisor that restarts what dies.

You should have working: a 30-minute heartbeat across every machine, lane watches on their cadences, and silence - the owner hears about exceptions only.

Module 8 - The mistakes

Teaching forces you to uncover mistakes. These are the real ones from this build - study them before you make your own.

  1. The guardrail blocked approved work. The screen scored impact, not hostility, and blocked the owner’s own task. Calibrate a gate on real traffic before trusting it.
  2. The lane that never existed. A seat’s poller was reported lost; it had never existed. Verify a thing exists before restarting it - ask the architecture, not the symptom.
  3. A script pointed at a person. Automation touching a real person ran ahead of an owner ruling and was killed. Person-affecting work gets sign-off first, not forgiveness after.
  4. The mesh map drifted. Machines re-registered under new names and the written map became fiction. Membership is state; state drifts; verify from the console.
  5. Two factories ran at once. A lock with a pid-overwrite hole. Locks need atomic semantics, and pid files lie.
  6. The guard fought the factory. A protection layer blocked the factory’s own tree. Enforcement must know which ground it owns.
  7. A deploy walked into the wrong project. A directory silently inherited an old link. Check the target project before every deploy - link state is invisible.
  8. The restart that restarted nothing. The command succeeded; the old process lived on. Verify the new process, not the exit code.
  9. Delivery that wasn’t. Board comments sat unread for hours. Delivery means pickup confirmed - never assume the read.
  10. Whose word counts. A seat typed the owner’s name. A claim of identity is not identity - provenance before permission.

You should have working: the ability to name your own first mistake before this course predicts it. You will make one. Write it down with a receipt.

Module 9 - The rules (graduation)

  1. No secrets in chat, docs, or code. Slots and references only.
  2. Delete nothing. Move, copy, archive - never delete.
  3. Done means a sha, a run ID, or a file path.
  4. Nothing spends, sends, merges, or deploys without the owner’s word per item.
  5. Code lands by reviewed pull request. Never direct to master.
  6. Receipts on every claim - unlogged work did not happen.
  7. The owner gets deliverables, not status pulses.
  8. Every watch has a fallback, every seat a reaper, every rule an owner.

What running looks like:

Graduation: the fleet runs while the owner rests. Every gate stays where it was set. That is the whole course - the rest is reps.

Module 10 - The flywheel

The course is not a side artifact. It is the public exhaust of the real work.

Work all day, and the byproducts fall out for free: open source tools from the factory, free courses from the blueprint, videos from the receipts. The architect seat grows into an agentic resource along the way. The public material feeds the audience, the audience feeds the company, the company funds more fleet. That is the flywheel.

How it converts (realistic, tied to the North Star):

  1. Course sales. This curriculum, cleaned and expanded. Slow to build trust, compounding once it lands - the credible path to real revenue.
  2. Consulting inbound. The course is the resume. Companies that want their own fleet come already sold; the fleet itself is the demo.
  3. Open source sponsorship. The factory’s tools, released as they harden. Small dollars, large surface area for the two paths above.
  4. Video revenue. Receipts make good episodes - the build in public. Last in line; it amplifies, it rarely carries.

Honest math: none of these is fast, and none is guaranteed. The flywheel’s job is leverage: the $2.7M North Star is the company’s revenue - the public material exists to make that revenue cheaper to win, not to replace it.

Course v1, Sep 27 2026 - built from a fleet running live today. No credentials, prices, or personal data inside; slots are shown where they belong.