horned started as an experiment. I wanted to learn how a fleet of coding agents works, find out what a setup like Gas Town can do, and see whether agents could build a mobile app on their own.
It grew into the system that runs all my projects. It does a great job, but it is not perfect, and it does not replace a developer. Here is how it works, warts included.
It takes over the keyboard
A coding harness, such as Claude Code, Codex or OpenCode, still needs someone at the keyboard to start it, watch it, check its work and open the pull request. Mobile access only moves that keyboard into a pocket, as one more push to watch and answer.
There are three ways to take that job off a developer’s hands, or at least to lighten it. Think of them as three ways to travel, which differ in who does the work and who picks the route:
- A set of skills is a bicycle 🚲. Skills such as Addy Osmani’s agent-skills teach one agent a process: spec, plan, build, test, review, ship. They make the ride faster, but the rider still pedals and steers: someone has to start the session, watch it, and take care of all the work. Sometimes that control is exactly the point, and I still work this way from time to time.
- Gas Town is a taxi 🚕. The passenger names the destination, and an AI, the Mayor, picks the route and hands out the work, with each agent deciding when its part is done. It is the most agentic of the three, and in many ways the most ambitious.
- And
hornedis a train 🚆. It gets there too, but on fixed rails and by a timetable. There are no traffic jams and hardly any detours, and it goes a long way without stopping. Meanwhile the passenger can read a book, have a meal or sleep. It is a deterministic software house: AI agents do the work, and code decides every step.
The process is code, not a choice
In horned, code runs a ticket’s whole journey, from the first idea to the merge, the way rails guide a train. Here is the route, stop by stop.
An idea goes into the planning chat
Day to day, horned is operated through its web dashboard, and new work starts there, in a planning chat. The chat talks straight to a live session of a regular agent harness, such as Claude Code or Codex. An idea goes in, and that agent turns it into one ticket.
The agent leads the conversation itself. It grills the author with as many questions as the idea needs, a few for a small request and several rounds for a big one, until no decision is left open. Its questions show up as cards with answers to click. When no question is left, the agent drafts the ticket, ready to go to the fleet or to the backlog for later.

The ticket lands in Linear
The ticket drafted in the chat is filed in Linear, a superb issue tracker. From then on, it is the one place every agent works from.
Each agent leaves its trace there. The refiner writes its analysis into the ticket, later agents report in the comments, and the ticket’s status follows it through every stage. When something is unclear, an agent asks in a comment, and the work resumes once someone replies.
For a human, that makes the whole history of a ticket easy to read, review and comment on.
Code moves it through fixed stages
Once a ticket is in Linear, horned picks it up and takes it through the same stages as every other ticket, always in the same order. Each stage has one job:
| Stage | Who does it |
|---|---|
refine |
The refiner sharpens the ticket’s requirements. |
code |
The worker writes the change. |
audit |
The auditor checks it against the ticket and sends it back when it falls short. |
build & test |
The project’s own build and tests, with no agent involved. |
pull request |
An agent pushes the branch and opens the pull request. |
review |
The reviewer checks the pull request. |
fix conflicts & merge |
An agent fixes any merge conflicts, then horned merges. |
No agent decides what comes next. The order is written in horned’s code, so an agent cannot skip a stage, and none of them checks its own work. Every step is there for a human to see.
The web dashboard shows it all
All of this shows in the same web dashboard, on a desktop or a phone. What needs a human comes first: a question an agent asked, or a ticket parked until its base branch is green again. Below that are the workers, each with its ticket, stage and provider, then the queue, with the reason each ticket waits, and how much of each subscription is used. With all of it in one place, Linear is just the middleware underneath and rarely needs opening.

It finds its own tickets
Not every ticket starts with a human. horned also finds work on its own, both in the projects it runs and in its own code.
Bug hunts hounds 🐕🐕🐕 and code audits
horned hunts for bugs in the projects it runs with hounds: three agents, each named after a dog breed that fits its job. The beagle sniffs out a suspected bug. The terrier digs in and tries to disprove it. The heeler, a herding dog, makes the final call. A suspected bug becomes a ticket only if it holds up against all three.
While a project is quiet, a code audit also reads its whole codebase. What the hounds and the audit find becomes tickets in the backlog, like any other.
Self-improvement
horned is one of its own projects, so a change to horned goes through the same stages as any other ticket. Of the PRs merged into its repository, 97% came from the fleet itself.
It also finds its own faults, in two ways:
- A daily log audit. Once a day, an agent reads
horned’s own logs and files a ticket for anything that looks wrong. - Self-healing. When a ticket ends up blocked, a human has two options: fix it themselves, or put a
self-heallabel on it. The label sends an agent to find the root cause in the ticket’s history and the logs. It then files tickets that fix the problem in the project itself, and tickets that fixhornedwhenhornedwas the one that misbehaved.
The fleet picks those tickets up like any other. So horned monitors itself and fixes most of its own bugs, with nobody deciding in between.
It is not rocket science 🚀, on purpose
None of horned’s parts is rocket science. But each one is a deliberate choice that makes the whole process stronger: the vendors’ own command-line tools, a Mac of its own, and one narrow job for every agent.
The right model, from any vendor
Each role runs on a model that fits it. The refiner, auditor and reviewer always get a smarter model. A worker gets a model that fits its ticket: a smarter one for a hard ticket, a faster one for an easy one.
One ticket can pass through several vendors. The refiner might run on Claude, the worker on a cheaper model through OpenCode, and the auditor on Codex. Each runs on its own subscription, and horned reads their usage to send more work to the ones with the most room left.

To do that, horned runs each vendor’s own CLI, so every agent keeps the tools its vendor built. Claude Code, Codex, OpenCode and Mistral Vibe run over the Agent Client Protocol (ACP), and other CLIs, such as Gemini CLI, run directly. Over ACP, horned gets what an agent does as structured messages: its tool calls, its questions and the tokens it used.
Four subscriptions, $180 a month
Several vendors also balance the load, the outages and the bill. When Claude is down, or its usage limit is hit, the work moves to Codex or another model.
I used to run the fleet on Claude Max 20x. Now it runs on four subscriptions that add up to $180 a month: $100 for Claude Max 5x, $40 for OpenCode Go, $20 for Codex and $20 for Mistral. Running everything on Opus or Sonnet would be best, but it would cost several thousand dollars a month. Together, the four give far more power than their price suggests.
Unattended, on a Mac
horned is a command-line tool, and it runs on a Mac mini. One process runs every project, with an orchestrator for each, and they share one pool of agents. Nobody has to sit with them, because a watchdog checks on every running agent. It nudges one that goes quiet, and kills and retries one that stays stuck.
Each agent gets its own tmux session, and the whole fleet starts inside the logged-in user session, not as a background service. So the agents have every build tool on that Mac, Xcode and the simulators included.
Here is how that looks: horned as a process of the logged-in user in Activity Monitor, next to Finder, and the fleet’s tmux session in Terminal.

Running in the user session is what lets the agents work on an iOS app. They build it and run its tests, simulator snapshot tests included, before a pull request opens. When a ticket is done, horned also deletes the simulators its worktree created.
My Mac mini has 16 GB of memory, which is plenty for everything except Xcode and Android Studio. I upgraded its system drive to 2 TB by hand, because Xcode, the simulators and CI workers all live on the system drive and kept filling it.
One narrow job per agent
One agent, one job. Every agent in horned gets a single, narrow task, and a polished prompt that spells out exactly what is expected of it and nothing else.
Around that prompt there is little more: a model, a set of tools and a turn limit. The auditor, for example, only checks a change against its ticket, and it gets no tools to edit code.
An agent talks to horned in one way only. horned runs a small HTTP server of its own, and every agent gets a script with a fixed set of subcommands for it: read the ticket, post a comment, file a sub-ticket, and report a verdict such as pass, fail or block. That makes the exchange rich, and predictable too, because an agent can only say what the script allows.
Here is the terrier’s prompt as an example. It is a template: the parts in braces, such as {{{ beagle_findings }}} and {{> agent-guardrails }}, are filled in from elsewhere.
You are **Terrier** — an adversarial verifier in the Hound QA pipeline.
Your job is to challenge every finding from Beagle. You earn points for correctly disproving false positives, but pay double for wrong disproofs.
## Scoring
- +3 points per correctly disproved false positive
- -6 points per wrong disproof (finding was actually valid)
Be aggressive in challenging, but cautious before declaring a disproof.
## Beagle's findings
{{{ beagle_findings }}}
## Process
For each finding:
1. Navigate to the exact file and line cited
2. Read surrounding context (at least 50 lines each direction)
3. Check if the "bug" is actually handled elsewhere (try/catch, guard, etc.)
4. Verify the severity classification is accurate
5. Check if tests already cover this case
6. Mark each finding as CONFIRMED, DISPROVED, or DOWNGRADED (with new severity)
## Output
Build a JSON array — submit it via the Report Status block's `pass --description-file`
command:
```json
[
{"title": "Brief title", "description": "Detailed description", "severity": "low|medium|critical", "status": "confirmed|disproved|downgraded", "terrier_notes": "Why this is/isn't valid"}
]
```
{{> recorded-intent }}
{{> decision-records-immutable }}
{{{ comment_policy }}}
{{> agent-guardrails }}
- **NEVER modify any code** — you are a read-only verifier
- Drop any finding that targets a decision-record body or identity-bearing frontmatter (`id`, `date`, `title`, `areas`, `tldr`). Only forward-reference back-link gaps in `references:` are admissible (see the immutability rule above).
- **NEVER use Skill() or load any slash commands**Its agent file for Claude Code wraps the prompt with a model, its tools and a turn limit:
---
name: hound-terrier
description: Adversarially verifies Beagle findings for {{{ identifier }}} in the Hound QA pipeline.
tools: Read, Grep, Glob, Bash
model: opus
maxTurns: 30
---
{{> hound-terrier }}It shines on medium, build-heavy work
Two things make horned strong.
The first is planning. Every ticket, without exception, gets the same solid treatment before any code is written: it is refined, and split into smaller chunks that can each be delivered on their own. The refinement never works from the ticket alone. It always reads the repository’s code, its decision records and whatever other context the project keeps, so every decision rests on the deepest context available. It is still an agent doing it, so it does not catch everything. But having that process for every single problem is already a huge value.
The second is moving heavy work off the developer’s own computer. Mobile development is the best example. Building the app, starting simulators and running the tests takes a long time and eats a lot of resources. On a main computer, that makes working on several topics at once gruelling. horned does all of it on the side, on the Mac mini, for many tickets at a time. Each ticket gets its own git worktree and its own simulators, so the tickets do not get in each other’s way. That is not as isolated as a virtual machine for every task, but it is good enough, and far cheaper.
It now merges 250 PRs a week
And it delivers. A whole iOS app, this website and most of horned itself came out of it, and the numbers back that up. Across all eight projects, the fleet has merged 3,987 PRs. Its busiest week closed 306 tickets, its busiest day merged 109 PRs, and it has made 658 bug hunts, audits and self-heal runs.
The two biggest projects are horned itself and Les Gardiens of Silence, an iOS app with its backend:
| Metric | horned |
Les Gardiens |
|---|---|---|
| In development since | February 2026 | June 2026 |
| PRs merged | 2,458 | 1,312 |
| PRs merged by the fleet | 2,389 (97%) | 1,253 (96%) |
| Commits on main from the fleet* | 2,388 (70%) | 1,224 (62%) |
| Merged on the first attempt | 88% | 87% |
| Median time from pickup to merge | 45 minutes | 46 minutes |
| Lines of Swift | 136,833 | 44,119 |
| Swift tests | 9,797 | 2,448 |
| Architecture decision records | 1,841 | 1,027 |
* The rest are mostly ad hoc changes I push straight to the main branch, without a PR. Not every commit is code: many change docs, config or assets.
The figures come from GitHub and horned’s own run records, which start in April 2026. They are as of 18 November 2026.
It has its limits
An agent is fast, tireless and always confident, but it cannot tell when it is wrong. It produces a plausible answer whether or not it grasped the problem. horned’s stages and guardrails catch a lot of that, but not all of it.
Here is where it shows:
- It does not understand code. No model does. It writes code that looks right and passes the checks, without knowing why it works. So a fix often treats the symptom and misses the cause. The same problem then comes back and gets fixed again, sometimes several times, and each fix can bring a new bug with it.
- It outruns its human. It files its own tickets, decides what goes where and merges the result, all faster than anyone can read. So the codebase grows past what I actually understand. At times it is hard to tell what is going on, or why something was built at all, and I give up a lot of the ownership. How I work with that, running fast and breaking things, is a post of its own.
- It struggles with the newest technology. New devices such as iPhone Duo and new designs such as Liquid Glass trip it up. Skills help, but the result often needs a lot of manual work afterwards.
- Its feedback loop is long. A ticket takes most of an hour to go through all the stages. So it makes no sense for something very small, or where quick back-and-forth is needed. Claude Code in hand is better there.
- It is only as good as the project’s checks. Take a backend change that alters the database.
hornedcame up with a migration nobody had planned for, and went ahead without flagging it. The project had no check for migrations at the time, so the change shipped and the migration was never run. Once the check existed, it stopped happening. That is the price of running fast and breaking things. - It has no taste. Left alone, an agent rarely produces a great design. Designs from Figma are a very solid foundation, but they do not cover every case, and an agent cannot always carry them out. Claude Design is a decent alternative, but still far from a human designer.
So horned does not replace a developer, or a technical co-founder. Someone still has to understand the problem being solved. (Btw. if you need one, let’s talk.)
What it does is make me far more productive. It takes the repetitive work off my plate, and it does that better than a plain harness, because it is predictable, has strong guardrails and runs on battle-tested prompts.
It needs looking after: I watch it every day, maintain it, and step in when it fixes the wrong thing. But its traditional, deterministic approach fits me and the tools I already use, even if it is, from time to time, a pain in the ass.
See real tickets
Five tickets from the fleet, with their full history. Open one to see the work move through the stages.
HORN-7893 · A feature, from the request to a merged pull request and a hound's follow-up

DEL-43 · An agent asks for what only a human can do

HORN-7883 · A bug the hounds found, refined and fixed

HORN-7886 · A codebase audit and the tickets it filed

BD-61 · A fix for this site, with a failed run on the way
