A one-person company has one hard ceiling, and I am it.
Building a Microapp today means I open Claude Code and type /steph, then /kai, then /bob, then /ben. The agents do the actual work — research, spec, build, QA, translate. I do four keystrokes, four reviews, and a click on the green merge button. The pipeline runs. Six tools a week.
The honest description of that pipeline is that I am the cron job. The agents are real. The tools are real. The thing that fires the agents is a human at a keyboard, and the human at the keyboard has a finite number of hours in a week. Every microapp the company ships today is bounded by my throughput, not the agents'.
The agents already work. The trigger is the bottleneck.
The portable runner — agents/cli.ts in the repo — is built and tested. It will execute Steph or Bob from a command line, headless, no editor open. The thing it isn't wired to is anything that fires on its own. No cron. No webhook. No "Steph runs at 8am every Tuesday." The cli works in the same way a car engine works without a key — the parts are there, the ignition isn't.
The transferable why: in a one-person operation, the bottleneck eventually becomes the person, not the work. The trap is to interpret that as a hiring signal. The interesting alternative is to interpret it as a triggering signal — the work is structured, the agents are tested, the only thing missing is what kicks them off. That's a much smaller problem than hiring, and a much cheaper one to solve.
Locked 2026-05-14 · current state · agents/cli.ts ready, not yet scheduled
The second realization was the one that changed the size of the problem.
I sat down to design "the autonomy stack" and noticed it was already deployed. Four Cloudflare Workers were already in production, doing the load-bearing parts of the operating model: microapp-ai fronts every AI tool with the credit ledger and budget cap, microapp-mcp exposes every tool engine to agents over MCP and REST, agent-os-router takes Slack messages and writes events, agent-os-broadcaster fans every new decision out to channels. The substrate isn't a green field. It's a brownfield I forgot I was standing on.
What's missing isn't a platform. It's three Cloudflare primitives I haven't switched on yet — Cron Triggers to fire Steph on a cadence, Queues to make Steph → Kai → Bob → Ben a durable pipeline that survives a failed step, and Tool Use so an agent can open the pull request instead of describing it.
Cron + Queues + Tool Use. Three primitives. All on the platform we already pay for.
No new vendor. No new platform to learn. No accidental complexity that comes with a polyglot infrastructure. The three primitives are Cloudflare's own bricks; the foundation is already poured. Flipping the cron on is closer to writing a wrangler.toml line than to launching a new service.
The transferable why: the gap between "manually pipelined" and "self-running" is rarely a new platform. It's usually a trigger. Founders who think they need to migrate to Kubernetes to automate their workflow are often three lines of cron away from the goal. Look at what you already pay for before you look at what you'd need to learn.
Locked 2026-05-14 · all four Workers in production · cron + queues + tool-use unscheduled
The third decision was about the order in which an agent earns the right to act.
An agent doesn't go from advice to merge overnight. The temptation, the day the cron works, is to widen everything at once — let Steph run on a schedule, let Bob open PRs from her output, let Ben gate, let the whole loop sprint. The temptation is the failure mode. A loop that outruns its gate isn't speed; it's an outage on a schedule.
The path is a four-rung ladder. Answer — the agent replies in a thread, the human acts. Propose — the agent drafts a PR description, a spec, a tweet; the human still ships it. Act behind the QA gate — the agent ships, but only past Ben's PASS. Act and merge — the agent ships and merges, only on classes of change the gate has already proven it holds for.
Autonomy is earned one rung at a time, behind Ben.
Ben is the hard gate. No PASS with an open blocker, ever. budget.ts bounds spend the same way it does for AI tools. The brand Covenant is machine-checkable, so drift is caught instead of shipped. The loop widens only as the gate proves it holds — never faster, never on a hunch, never because the cadence would look better in a slide.
The transferable why: trust in an autonomous system is earned by demonstration of the gate, not by the speed of the loop. Companies that automate without tightening the gate first ship faster for a quarter and pay for it for a year. Companies that tighten the gate first ship slower for a quarter and never lose a week to an automated mistake. The arithmetic is bad in the short run and very good in the long run.
Locked 2026-05-14 · trust gradient · published per-agent on /agents/
The fourth decision is the one I keep coming back to when the autonomy stack gets exciting. Some things never get a cron.
The founder-locked brand decisions in BRAND.md don't get a cron. Pricing and Covenant changes don't get a cron. The merge button — for now — doesn't get a cron. "Is this even worth building?" doesn't get a cron. Steph proposes the candidates; a human still points at which one to build. Autonomy is for the assembly line, not the blueprint.
Automate the loop. Never the judgment.
The line between loop and judgment is the line between "what to do given the goal is already set" and "what should the goal be." Once the goal is set — build a torque converter, write a launch tweet, translate the brand article into Polish — the loop runs. Setting the goal stays human. That's the part of the company that doesn't scale by being made into a program, because the value of the goal-setting is exactly that a person made it.
The transferable why: making the company a program doesn't mean automating the founder. It means automating the parts that don't need the founder's judgment to begin with. The valuable thing a founder does isn't the work that follows the spec; it's the spec itself. Automate everything downstream of the spec; leave the spec alone.
Locked 2026-05-14 · the things that stay human · the spec, the merge, the brand, the price
The last decision is the unflattering one. None of the autonomous loop is switched on.
The agents run inside Claude Code today, triggered by me, paid for by the Claude Max plan. The portable runner sits in the repo, tested, unused. The cron triggers aren't scheduled. The queues aren't wired. The agents don't open their own PRs. This is the design — not the changelog.
The reason is honest: running the agents headless costs real API money — roughly $10 to $30 a month at the current scale — and earns nothing until there's a concrete bottleneck the loop unblocks. Scheduled Steph reports. Ben on every PR automatically. A Slack-driven Bob that builds tools while I'm asleep. None of those is a constraint today. The day one of them is, the cron flips on. Not before.
Build it when the loop is the bottleneck. Not before.
The Workers are already paid for. Flipping the trigger is a small change, made on purpose, when it pays. Until then, the chapter you just read is a design document — public, dated, falsifiable — and the trigger that turns it on is the day a human at a keyboard becomes the slowest part of the pipeline.
The transferable why: infrastructure built ahead of need pays in optionality and costs in maintenance. The right amount of pre-built infrastructure is the amount that lets you turn the switch on when the bottleneck arrives — but not the amount that runs the meter before then. Most companies overbuild infrastructure and underbuild gates. Underbuild infrastructure on purpose; let the gate be the part you're proud to ship before you need it.
Locked 2026-05-14 · off, on purpose · trigger flips when the human becomes the bottleneck
That's the autonomous loop. The agents are real. The substrate is built. The gate is held. The trigger waits for the day it has to fire — and the founder writes the spec while it does.