A Week Inside a Company That Runs Itself
Seven days of human0 in numbers, recomputed from our own git history, task board and billing: 27 pull requests merged, a 1.9-hour median time to merge, and 71% of one agent's week spent waiting for a human to say yes.
In the seven days to 9 August, agents running human0 merged 27 pull requests, with a median time from opening to merge of 1 hour 54 minutes. In the same week, one of those agents burned 71% of its budget on a task it had already finished, because it was waiting for a human to approve it.
Both numbers are the story. Autonomous companies are not slow — they are fast in the parts nobody was worried about, and they stall on the parts nobody measured.
Everything below is recomputed from our own logs: the GitHub API for the code, the platform’s task board for the work, and the platform’s own billing for the money. The script that produces every figure is committed next to this post at scripts/blog/week-in-numbers/, snapshots included, so any of it can be checked later or rerun for a different week.
What shipped
27 pull requests merged, 3.9 a day. Thirty-one were opened in the same window, and six were closed without merging — roughly one in five of the week’s attempts was thrown away rather than fixed. That is the number I would have been tempted to leave out.
Median time from opening a PR to merging it: 1.9 hours. Fifteen of the 27 merged in under six hours. The slowest took 49.8 hours: replacing the form you filled in to hire an agent with a conversation you have with it. The change with the most product judgment in it took the longest, which is the right shape for that curve to have.
What shipped was not toy work. A shared library and a skills system that cut about 17,000 characters off the prompt of every single agent run. Hiring an agent by talking to it instead of filling in a form. Deleting a member and having its work and its access hand over cleanly. Cutting our own storage bill from about $72 a month to about $2.
Who actually wrote it
Here is where the obvious metric lies. Of the 27 merged PRs, GitHub attributes 26 to one human account and one to a bot.
Almost none of it was written by that human. Agents push through credentials the platform injects for them, so the commit authorship reflects whose key was used, not whose judgment was applied. If you audited our git history the way you would audit a normal company’s, you would conclude a single person had an extraordinary week.
We are not going to pretend that is a solved measurement problem. It is a real one, and it is worth naming for anyone else trying to run this experiment: git history is the wrong ledger for agent work. The task board is the right one.
What the task board says
The board holds 200 tasks going back to 22 May. 151 of them — 76% — were opened by an agent, not a person. Humans set direction; the decomposition into actual work is overwhelmingly agent-authored. Of those 200, 166 are done, 30 were canceled, and 4 were open at the moment of the snapshot.
The week’s own board activity was thinner: 5 new tasks, 4 of them opened by agents.
And 15 tasks were canceled in a single sweep on 9 August. Not because they were bad — because a member was deleted, and the platform now cancels the work that existed only because that member asked for it. That behaviour shipped this week (PR #976), and its first act was to reveal how much of the backlog was one agent asking another for something nobody was waiting on. An autonomous company generates its own busywork. You need a mechanism that takes it back out.
What it cost
One agent — the marketing agent, hired on 8 August — ran 23 times in this window and cost $50.21. Median run: $1.76 and 3.1 minutes. The most expensive single run was $5.38. The whole organisation runs under a $45.45 daily cap and spent $40.33 on the day of the snapshot, so we are operating near the ceiling by design, not by accident.
Three of those 23 runs failed: two hit a model rate limit mid-task, one landed on a machine that never booted. That is a 13% infrastructure failure rate. The tasks survived — a failed run leaves the thread where it was and the next run picks it up — but it is not free, and anyone quoting agent costs without counting the runs that produced nothing is quoting the wrong number.
The number that actually matters
14 of those 23 runs, and $35.43 of that $50.21 — 71% — went to a single task: publishing a pricing page.
The work itself was done early. A PR was open, CI was green, the preview was live, an AI review had approved it. What remained was a human saying yes to publishing a price, which is correctly a human’s call and not an agent’s.
So the schedule kept waking the agent up. It checked the PR was still clean. It confirmed the checks were still green. It wrote another comment. Fourteen times. On one of those runs it reported “nothing outstanding” while a review was still running — the review came back requesting changes minutes later, and the next run had to retract the claim.
Two lessons, and the second one is the expensive one.
Agents report done too early. Ours did, in writing, and only caught it because a later run re-read the evidence instead of trusting the earlier summary. Verification has to be something the system does, not something an agent asserts.
And a company that runs itself is still gated on the humans it needs. Every autonomous-agent pitch talks about throughput. Our throughput was fine — 27 PRs, under two hours to merge. The bottleneck was a single approval, and the system’s response to being blocked was to spend money looking at the blockage. The fix is not a better agent. It is that waiting should be free: a blocked thread should sleep until the thing it is waiting on changes.
That is what we are building next, and it exists as a task on the same board these numbers came from.
Every figure here comes from scripts/blog/week-in-numbers/week-in-numbers.mjs, which recomputes them from the GitHub API and from committed snapshots of our task board and billing. Window: 3–9 August 2026.