The Premise One operator, a real machine
You coach me on the business, so it is only fair you see the business. Everything in this orb was generated by a system I have been building since the start of the year: a Claude Code orchestrator wired to a library of skills, specialist agents, hard rules, a private knowledge brain, and a set of quality gates. It is not a chatbot answering prompts. It is an operator that reads context, fans out work to many sub-agents at once, verifies its own output, and ships files.
Below is what that machine actually is. The numbers are pulled from the live system, they are versioned, and I have kept the honest caveats in plain sight at the bottom. No marketing rounding.
The Receipts The year in numbers
Eight measures of the machine as it stands today. Each one is a real count from the system, not a projection.
Git commits since January
Every change to the machine is versioned. So what: there is a full audit trail, nothing lives only in a chat thread.
Reusable skills
Named, repeatable workflows the orchestrator can run. So what: an audit like yours is a command, not a from-scratch effort.
Specialist agents
Narrow agents for citation strategy, security, code review, discovery and more. So what: the right specialist is dispatched per task.
Operating rules
Hard guardrails the machine obeys every run. So what: client data is never invented, nothing ships without a verify pass.
Paying retainer clients
Local service businesses run through this machine monthly. So what: it is a working agency, not a lab experiment.
RAG knowledge chunks
Courses, intel, frameworks, ops docs, all searchable. So what: the machine answers from a private brain, not just the model.
Audits live on ONE project
All on a single Cloudflare project, not 158 of them. So what: the infrastructure is deliberately lean and cheap to run.
Session reflections
The machine reflects after work sessions and learns from each. So what: mistakes become rules, so they do not repeat.
These figures are read straight from the system: git history, the skills and agents directories, the rules folder, the RAG vault counts, and the reflection log. They move up every week.
The Shape The operator OS
The leverage is not one big AI doing everything. It is one operator plus a Claude Code orchestrator that fans out 6 to 11 sub-agents in parallel, each on a non-overlapping slice of the work. For a job this size, that is roughly the output of an 8-person team, run by one person.
How a job actually runs
The orchestrator reads the relevant client context and rules, decides the approach, then dispatches a wave of specialist agents at once: one pulls AI citation data, one crawls the site, one runs the keyword and backlink pull, one checks the tech stack, one drafts each report page. They all write to their own files, so they never collide. Then a verify pass and the quality gates run before anything is called done.
The five building blocks
- Skills are the repeatable workflows, 247 of them.
- Agents are the 65 narrow specialists dispatched per task.
- Rules are the 24 hard guardrails enforced every run.
- A 3-vault RAG brain is the private searchable memory.
- Leverage gates stress-test the plan before work starts.
The leverage gates
Before a real piece of work ships, it can be run through gates that pull in opposite directions on purpose:
- /sss scores structure, stability and speed.
- /gaps finds what the plan is missing.
- /10x expands the high-leverage moves.
- /simplify strips out the over-building.
- /council runs a multi-perspective review.
The point of the gates is honesty under pressure. One expands the work, one cuts it back, and the plan that survives both is the one that ships. That is the same discipline you teach: do less, but do the right less.
The Systems Built this year
Seven of the systems inside the machine, with the proof of each. Status uses an honest four-label scale: Landed built and in active use, Scaffolded core exists, Designed specced not started, Not Built roadmap only.
| System | What it does | The proof | Status |
|---|---|---|---|
| WP-to-Astro cutover machine | Moves a slow WordPress site to a fast static build without losing search rankings or breaking forms. | A 12-section playbook (Rule 21) with a hard pre-flip gate. Written after a real client cutover dropped calls, so the gate exists to never repeat it. | Landed |
| Five audit engines | Full, AI-deep, deep, quick and diagnostic. Each tuned to a different depth and purpose. | This orb came out of them. 158 audits live on one Cloudflare project, all produced by these engines. | Landed |
| The RAG brain | A private, searchable memory of courses, intel and operating knowledge across three vaults. | ~14k knowledge chunks, queried with a closed-loop contract that scores whether each retrieval actually helped. | Landed |
| Verify-before-assert discipline | The machine never says done, fixed or live from assumption. It checks the authoritative source first. | A standing rule (Rule 19) found in 24 of 27 reviewed work sessions. It is the single most load-bearing habit in the system. | Landed |
| Monthly-report automation | Drafts a styled, data-driven monthly SEO report for every retainer client, in plain English. | A skill that runs one client or all nine in a batch, scheduled for the 5th of each month. | Landed |
| Cost discipline | Every direct AI call estimates its spend and refuses to run past a hard cap. | A cost-preflight wrapper and a ledger, written after one expensive month so it can never happen blind again. | Landed |
| Parallel fan-out engine | Dispatches 6 to 11 specialist agents at once, each on its own slice, with a self-verify built into every agent prompt. | The pattern behind this orb. A self-verify gate took the broken-agent rate from 4-in-a-batch to zero in ten. | Landed |
Several of these were born from a real failure. The cutover gate, the cost wrapper and the verify rule all exist because something broke once and the machine was taught to never repeat it. That is the reflection loop working.
The Partner Tony's side
The machine does not run alone. It sits next to a platform partner who works one layer deeper, on the agent infrastructure itself.
Anthony O'Connell, the platform side
Tony authored a 50-page McKinsey-grade agent strategy doc for the ASI Alliance and Fetch.ai, the network building the open agent economy. He runs 22 agents live on Agentverse, a network of roughly 2.7 million agents, and is building the one BaaS substrate, the shared backbone agents can be deployed and billed on.
Plainly: I run the agency machine that does the marketing and delivery work. Tony runs the deeper platform machine that the next wave of agents will live on. The two sides reinforce each other.
The Honesty What this is NOT
The bragging only counts if the caveats are louder than the claims. So here they are, plainly.
- The 65 agents are orchestrator-run scaffolding, not fully autonomous. A person still drives the machine and makes the calls.
- The leverage is structured fan-out, not magic. It is many small jobs run in parallel on non-overlapping files, then verified. The discipline is the product, not the model.
- The numbers are versioned and real, not marketing. They come from git, the skills and agents folders, the RAG counts and the reflection log. If anything, they are slightly stale, because the machine grows weekly.
- It is not a guarantee of results. Search and AI visibility are probabilistic. The machine makes good work faster and more consistent, it does not promise a number.
I would rather you trust the caveats than the claims. The reason the machine works is that it is built to catch its own mistakes, not to look impressive.
Why You Soft close
I showed you this because you coach me on the business, and this is the business. The whole orb you have been reading was one run of this machine pointed at your site, as a thank-you. If any of it is useful to you, take it. If you ever want a closer look at how a piece of it works, the door is open. No pressure, no pitch.
Built for Mads Singers by Online Optimisers. Every figure on this page is read from the live system and moves up each week.