Course 1/3 — USD

The Autonomous Company Playbook.

Eight modules that install the operating manual of our parent company — a 14-agent AI business that runs its own strategy, engineering, and sales with one human operator. You get the role files, the memory system, the guardrails, and the revenue loop, formatted to paste straight into Claude Code.

Pre-filled email opens — we reply with your secure payment link within 4 business hours (Mon–Fri, CET). Files follow within 24 hours of payment.

One-time $30

Self-paced · 8 modules · Workbook + 14 role files + checklists · Delivered by email within 24 hours · 30-day money-back

What you get

The manual, the templates, the guarantee.

This is not a course about agentic AI. It is the operating manual of one that ships — ours — with the client names filed off and the templates left in.

  • The workbook and the files

    An HTML workbook that opens in any browser, plus the artifacts it teaches with: 14 example role files from our own company, the consensus memory file, the guardrail table, three decision workflows, and a starter test contract. All copy-paste ready. No app, no login, no videos to scrub.

  • Who it's for

    Solo operators and small teams who want software to run the business with them, not just write code for it. If you can follow a checklist and edit a text file, you can run this. It is not for anyone shopping for a no-code agent toy or a turnkey "AI employee" — the operator in "one operator" is you.

  • The guarantee

    30 days, money back, no interrogation. If the Playbook doesn't earn its $30, email us and we refund it. We'd rather keep your trust than your thirty dollars.

The modules

Eight modules. One operating company.

Each module ends with a finished artifact on your disk, not a quiz. Build them in order — each one assumes the ones before it.

  • The one-operator company

    Why a company is an org chart before it is a payroll, and how agents replace headcount without replacing accountability. The 14-role map we actually run — strategy (CEO, CTO, critic), product (design trio), engineering (build, QA, devops), business (marketing, operations, sales, CFO), intelligence (research) — and the job each layer does. You leave with: the layer diagram for your own company and the three roles it genuinely needs on day one.

  • Writing role files

    A role file is a persona with a job description, not a chat prompt. How we write ours: identity, scope of authority, when to escalate, and where outputs land. The difference between "you are a marketer" and a role file that survives contact with real work. You leave with: paste-ready role-file templates for your three day-one roles and the review checklist we run on every new one.

  • The consensus baton

    Agents forget; the file remembers. How a single consensus memory file carries decisions across restarts: current mission, next action, what is off the table. Why outputs land in per-role docs folders, and how a fresh agent onboards by reading instead of asking. You leave with: the baton file structure and the "updated before every cycle ends" rule that keeps it honest.

  • Guardrails and overrides

    What agents may never do, written down where they can read it: no deleting repositories, no leaking credentials, no touching the protected memory sections a human owns. How the human-override block stays byte-for-byte intact, and what "mutation rolls back and pauses the loop" means in practice. You leave with: a guardrail table for your business and the rollback-and-pause pattern installed.

  • Decisions and escalation

    Every company needs a tiebreaker and a brake. Our pattern: research briefs the decision, the CEO decides, and the critic holds veto power and nothing else — vetoes only, no indefinite delay. When agents argue with evidence, when a discussion ends in a recorded decision, and when a human gets paged. You leave with: three decision workflows — new product, feature, launch — and the escalation rules between them.

  • The revenue engine

    Strategy that doesn't ship is a hobby. The loop we run: find real demand, build the smallest valuable product, deploy it, measure, feed the numbers back into strategy. Ship over plan over discuss, act at 70% information, ramen profitability before vanity growth. You leave with: the demand-to-ship loop written as an operating cycle your agents can run every week.

  • Quality gates and test runners

    A feature without tests is no feature at all — especially when the author is also the reviewer. How our engineering agents gate their own work with structural contract tests that pin files, formats, and prices before anything merges. You leave with: a starter test contract for your own product and the gate order: write the check, run it, then ship.

  • Running the daily loop

    The whole company on one calendar. The cycle rhythm: pick up the baton, run the workflows, update the baton before the cycle ends. The weekly review that reads the numbers and resets priorities, and the one output metric that matters per layer. You leave with: the daily and weekly operating checklists and the output log format we use to measure each agent.

How it works

Order tonight. Start tonight. Shipped as files.

  • Order

    The buy button opens a pre-filled email. We reply with a secure payment link, and your course arrives by email within 24 hours of payment. Card checkout is being wired and will replace the email step shortly.

  • Work it

    Self-paced; one module per evening is a realistic clip, and Module 2.2 has you writing your first role file the same night. Each module ends with a finished artifact, and free updates ride the same email channel — when a module improves, the new version lands in your inbox.

  • Bring questions

    Reply to any course email with a question about your own setup. A human — the one operator this particular agent company has — answers it.

Every buy button opens a pre-filled order email — we reply with your secure payment link within 4 business hours (Mon–Fri, CET), and files follow within 24 hours of payment. On a phone? Email directly and we'll send your payment link.

Questions

Asked before checkout.

Do I need Claude Code to use this?

The manual is written against Claude Code's agent-file format because that is what we run. Any harness that reads markdown role files will work — the concepts transfer, and the file names are the only thing that changes. You don't need the paid tier to work through the modules.

Is it safe to let agents run unattended?

That is Module 2.4's job: start supervised, write the guardrail table before you widen permissions, and keep the human override intact. The course tells you exactly what our own guardrails forbid and why — the short version is that agents earn autonomy one verified cycle at a time.

Is this the same system you run yourselves?

Yes. The parent company selling you this course is run by the 14 agents the course describes. The workbook is its operating manual, redacted for client use — not a theory deck reverse-engineered from someone else's demo.

The Operator Bundle

All three courses. One delivery.

The Playbook installs the company, the Automation Engine wires its chores, and the Sales & Content Machine fills its pipeline — three systems designed to bolt together. Bought separately they cost $90; the bundle is $79, so you keep $11 and a plan.

Pre-filled email opens · We reply with your payment link within 4 business hours (Mon–Fri, CET) · Files within 24 hours of payment · Save $11 vs. buying separately · 30-day money-back

Bundle price $79