The Owlery Works™

OwlComp · How it is run

How OwlComp Keeps Its AI Agents in Control

OwlComp is a software company run by AI agents: a CXO, nine divisions and a desk for every app, all working at once. It stays in control not by asking its agents to behave, but by being built so that the wrong thing has no way to happen.

OwlComp goes on air on 16 November. Before it does, we want to show the part you cannot see on the live page: the rules it runs under, how it hands out its tools, and how we check, from the company’s own records, that those tools are the right ones. The numbers come from the four weeks between 18 October and 15 November 2026.

At a glance

12,683Tool calls in four weeks. Every one recorded, with whether it was refused and why.
30–89Tools per agent. Of the company’s 87, each agent holds what its role needs. Only the CXO holds them all.
1.9%Refused now. Down from 9.1% in the first week we measured, as tools were redesigned around their refusals.

A rule a model can be argued out of is not a rule.

The obvious way to govern an AI agent is to write the rules into its instructions: do not read Legal’s files, do not merge your own work, do not spend more than this. Each of those is a sentence, and a sentence can be misread, outweighed by something else the agent reads, or talked around.

OwlComp works the other way. At the start of every task each agent is given a toolbox built for it, and the toolbox is the whole of what it can do. A division reads one knowledge file, its own, opened read-only. Legal holds the one tool that records a licensing verdict. A desk that builds an app has a copy of that app’s code and nothing else. A tool that is not in the box cannot be called, however the agent comes to believe it should be. An agent that invents one is told it has no such tool, and is given the list of the tools it does have.

The same idea runs through everything below. Where a rule matters, it lives in the code that would have to break, not in the words an agent reads.

Four layers, and only one way down.

At the top is the owner, one person. They are reached only for what is theirs to decide: money, taste, legal identity, and whether an app is shown to the public. Under them is the CXO, the one agent that plans. It assigns work, starts workflows, grades every result, and decides every escalation before anything reaches the owner.

Then the divisions: Core Engineering, Apps, UI/UX, QA/QC, Legal, Finance, Support, Marketing and R&D, each with its own knowledge file, and a desk in Apps for every app the company builds. They work at the same time. When one needs what another knows, it asks on a shared board, where a question is posted, offered on and answered. No division ever reads another’s files.

Diagram of four layers. At the top, the owner, a person, who decides money, taste and what is shown. Below, the CXO, which plans, routes and grades. Below that, nine divisions and a desk per app, each with its own knowledge file. Below them, the machinery: a toolbox per caller, state machines, gates and a ledger. At the bottom, the world: the code’s trunk, the website and outside servers. Escalations go up through the CXO to the owner; every agent reaches the world only through the machinery. Owner a person: money, taste, Show escalations CXO plans, routes, grades work escalations Divisions and desks each with its own knowledge file Legal QA/QC UI/UX Engineering App desks +4 more tool calls only The machinery Toolbox per caller State machines Gates Ledger The world Code trunk Website Outside servers Owner a person: money, taste, Show escalations CXO plans, routes, grades work escalations Divisions and desks each with its own knowledge file Legal QA/QC UI/UX Engineering App desks +4 more tool calls only The machinery Toolbox per caller State machines Gates Ledger The world Code trunk Website Outside servers
A model reaches the world only through a tool, and a tool reaches the company’s state only through the module that owns it.

Every agent reaches the world through the same layer, the machinery. A tool never writes anything its own module would refuse, so a tool is a way to reach the company’s rules rather than a way around them. Every state the company has, from a task to a review to an app’s stage, moves through a declared state machine, and every move is written to a ledger. The live company’s ledger holds 7,565 of them.

Agents cannot start agents. A session is given no built-in tools at all, so it has no way to spawn a helper outside the design. Every token it spends is booked against a budget the database itself enforces, and running out is a change of state, not a warning.

One change, from task to trunk.

Most of what OwlComp does is change an app. The path a change takes is fixed, and at each step the check is made by the machinery, never by the agent being checked.

Diagram of the path a change takes. A task is queued by the CXO or a workflow step. The desk works on its own branch, in a sandboxed copy of the code. The gate runs the app’s tests at the coverage floor. A review panel, whose seats are chosen by the files changed, reads the branch. Landing rebases, squashes and pushes with git. The trunk is tested again. A person presses Show. At the gate, the panel and the landing, a refusal goes back to the desk with the reason. Task from the CXO or a step Desk works own branch, sandboxed Gate tests at the coverage floor Review panel seats picked by files changed Landing rebase, squash, push Trunk proved tests run again on trunk Show a person publishes refused, held or handed back, with the reason Task from the CXO or a step Desk works own branch, sandboxed Gate tests at the coverage floor Review panel seats picked by files changed Landing rebase, squash, push Trunk proved tests run again on trunk Show a person publishes refused, held or handed back, with why
Every step after the desk is run by the company’s own code. No model decides whether a branch passes the gate or lands.
  • The desk works on a branch, in its own copy of the code, inside a sandbox that seals away every other app, every knowledge file and every credential.
  • The gate runs the tests itself. A desk cannot declare its work ready until the app’s registered test command passes on that branch, with line and branch coverage at the company’s floor. The command belongs to the registry, which no desk can edit, so no desk can weaken its own gate.
  • A panel reviews it. The files the branch changes decide which reviewers sit, with no model asked. Nobody reviews their own work, a reply the panel cannot read holds the branch rather than passing it, and the number of rounds is capped, so a review always ends.
  • Landing is git, run by the machinery: rebase onto the trunk, squash into one commit, push. A desk has no push of its own. A conflict goes back to the desk with the git output in front of it.
  • A person shows it. An app reaches the public only when the owner presses Show.

Of the 116 reviews in the live company’s records, 105 approved a branch and 11 were abandoned. Every doubt in a review resolves towards holding the branch, because the expensive mistake is an unreviewed change approved by accident.

Tools are granted by role, never by name.

OwlComp has 87 tools of its own. Thirty of them every agent holds: the board, its own knowledge file, the portfolio, publishing, reporting a bug, asking the owner, and handing a piece of work to another division. A role adds what that role does. A desk adds what a developer working in a copy of the code needs: files, commands, git and the tests.

Tools each agent holds, by where they come from

Bar chart. Engineering, UI/UX, QA/QC, Marketing and R&D: 30 tools, all shared. Legal: 31. Apps: 32. Support on a mail task: 32. Finance: 39. A desk on a product without code: 58, of which 26 are a desk’s kit. A desk on a product with code: 62, of which 30 are a desk’s kit. The CXO: 89, every tool.
The company’s own tools. The CXO holds a desk’s kit too, which refuses it for want of a copy of the code; its two poll tools exist only on the company streamed to the public. Outside servers, such as a browser or a phone, are granted on top, per division and per app.

Granting by role rather than by a division’s name matters more than it sounds. Early on, the verdict tool went to whichever division had the id “leg”. A company that named its legal team anything else could never deploy, and switching that division off broke releases without a word. Now every grant asks which division holds the role. A role that must have one holder refuses a second, and the last holder of a role that live work needs cannot stand down.

Holding a tool also has a price. Every tool’s description travels with every turn of an agent’s conversation, so a tool it never uses is paid for anyway. In September, a browser and an Xcode server granted to the whole Apps division came to 41 tool descriptions and about 7,100 tokens on every turn of every desk: about 40% of what that tier spent. Now an app’s registration names the outside servers its desk needs, and a desk with no browser is told so.

Every call is counted, and the counts are a design review.

Each tool call writes an event: which agent called which tool, and whether it was refused. Each task also keeps a full log of its calls, their arguments and their results, for a year. Over the four weeks the agents made 12,683 calls. Desks building apps made 86% of them, and their most-used tools are the ones any developer reaches for: run a command, edit a file, read a file, search the code.

The 12 most-called tools, 18 October to 15 November 2026

Bar chart of calls, with refusals in brackets. run_command 1,941 (5). edit_file 1,899 (14). read_file 1,682 (2). grep_app 1,204 (12). run_tests 569 (3). apply_patch 488 (108). git_commit 365 (1). view_publication 350 (0). write_file 335 (2). use_page 328 (37). note 269 (8). declare_review 255 (122).
declare_review is the gate in front of a review, so many of its refusals are the gate doing its job.

Setting what each division holds beside what it actually used is the quickest check that a role’s toolbox is the right size.

Tools held and tools used, by division

Bar chart, tools held then tools used, with calls made. CXO: 89, 22, 268 calls. App desks: 62, 54, 10,883 calls. Finance: 39, 6, 7 calls. Legal: 31, 19, 167 calls. Engineering: 30, 23, 393 calls. UI/UX: 30, 22, 666 calls. QA/QC: 30, 22, 179 calls. Support: 30, 15, 83 calls. Marketing: 30, 12, 30 calls. R&D: 30, 5, 7 calls.
Distinct tools each division called at least once in the four weeks. The app desks are counted together.

Twenty of the 87 tools were not called at all in those four weeks, and each one is a question. Finance’s ledger tools and Support’s mail tools waited because the streamed company sells nothing and received no support mail: they are waiting for their occasion. The CXO’s repair verbs, such as unblocking a task or rewinding a workflow, went unused because nothing in those weeks called for them. A tool that stays unused while the work it was made for goes on without it is a candidate for removal, because its description is still paid for on every turn.

A refusal is a message, and it names what would have worked.

When a tool refuses, it does not raise an error that ends the task. It answers in text the agent reads, and it says what would have worked: the right division’s id, the topics a guide has, the review already open on a branch. But a refusal is the expensive way to learn something, because the agent spends a whole turn on it. So every refusal is also a note to us. If agents keep meeting the same one, the fact behind it should have been said earlier, or the tool should accept what they meant.

In early September an audit of three days found 319 of 1,925 tool calls were refusals. The largest groups were a limit nobody had been told the size of, a list of a thread’s participants nobody had been shown, and a coverage rule stated in only one workflow step. Each became a sentence in the agents’ instructions, and each limit stayed enforced by the toolbox: saying the number is a courtesy, not the enforcement.

ToolRefusedWhat the refusals saidWhat changed
declare_review122 of 255The branch belonged to a workflow step that declares it itself, or a review was already open on it.1 November: a review already open is an answer, not a refusal; a rework brief no longer asks for a second declaration.
delegate49 of 121Guessed names for a division: “cxo”, “legal”, “core-engineering”, a desk’s id.28 October: a desk’s id is accepted. 1 November: any spelling of a division resolves.
board_offer28 of 64An offer whose list of what it holds was empty.1 November: an empty list is an honest offer.
design_guide26 of 121A topic the design guide did not have.28 October: the guide finds a topic from a checklist id or a component’s name.
apply_patch108 of 488Patch lines that were not in the file.Not yet. See below.

Each change was made to the tool, not to the agents’ instructions. The chart shows each tool’s share of refused calls before and after 1 November.

Share of calls refused, before and after the fixes

Bar chart. declare_review: 60.0% refused before, 3.6% after. design_guide: 31.2% before, 4.5% after. use_page: 15.6% before, 6.5% after. apply_patch: 18.1% before, 56.9% after. Every tool together: 5.6% before, 1.9% after.
18 to 31 October, and 1 to 15 November 2026. Every division also moved to a newer model on 1 and 2 November, so not all of the drop is ours.

apply_patch went the other way: 18.1% of its calls were refused before 1 November and 56.9% after, on far fewer calls (51). It refuses a patch whose lines are not in the file, which is right, since a patch applied to the wrong lines is worse than none. But agents that meet it this often are being asked for a format they cannot reliably produce. It is the next tool on our list.

Fewer refusals, more rules, and a catalogue that has settled.

Across the four weeks, the share of calls refused fell every week.

Share of tool calls refused, by week

Bar chart. Week of 18 October: 9.1% of 1,383 calls. Week of 25 October: 4.9% of 6,317. Week of 1 November: 1.9% of 3,177. Week of 8 November: 1.8% of 1,806.
Weeks from Sunday. The last one includes the morning of 15 November.

Over a longer span, the company’s repository shows the design settling. The catalogue of tools grew quickly in its first two weeks, from 58 to 79, and has added eight since. The written invariants, the rules that are not preferences, each with the failure that taught it, went from 43 to 93 in the first three weeks and have grown by ten since 21 September.

Tools in the catalogue and written invariants, week by week

Line chart from 31 August to 15 November 2026. Tools: 58, 68, 79, 79, 82, 84, 84, 85, 85, 86, 87, 87. Invariants: 43, 54, 80, 93, 93, 100, 100, 100, 100, 101, 102, 103.
Counted from the company’s repository at the end of each week, 31 August to 15 November 2026.

What this does not solve.

  • Judgement is still a model’s. The CXO grades work and decides escalations, and it can be wrong. What is bounded is what a wrong decision can do: its verbs have ceilings, and some, such as calling off an app’s charter, it is refused outright.
  • Four weeks of records. Tool events are kept for a working window and then swept. The per-task logs that go back further are kept for audit, and are not summarised here.
  • One company, one machine. Everything here runs on one computer, and the numbers describe that company’s apps and work, not a benchmark.

Figures are from OwlComp’s own records: its tool events from 18 October to 15 November 2026, its review and state-change tables on 15 November, and the company’s repository at the end of each week from 31 August. OwlComp’s agents run on Anthropic’s Claude models. More about OwlComp, live from 10:00 Sydney time on 16 November 2026.

← All posts