How it started
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.
Why horned
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.
Agents work, code orchestrates
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, and who does what at each: an agent, horned or a human.
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, and the author decides where it goes: to the fleet now, or to the backlog for later.

The ticket lands in Linear
horned files the drafted ticket 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 horned moves the ticket’s status through every stage. When something is unclear, an agent asks in a comment, and horned resumes the work 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. When it falls short, horned sends it back to the worker. |
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. Each one only reports a verdict on its stage, and horned’s code decides what follows: the next stage, another round for the worker, or a stop for a human. 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.

Autonomous maintenance
Not every ticket starts with a human. horned also finds what to fix, both in the projects it maintains and in its own code, and files the tickets itself.
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.
Simple parts, 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 Plus, $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 }}Results: 250 PRs a week
Simple as those parts are, horned delivers, with a single person using it: me. 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.
Here are its last 30 days in the web dashboard, counted in finished runs rather than PRs. The table leaves out four projects with six runs between them, but its totals count them.

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 figures come from GitHub and horned’s own run records, which start in April 2026. They are as of 18 November 2026.
** 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.
Advantages: deterministic process and offload
Those numbers come from the choices above, which make horned strong in four ways:
- Every ticket gets the whole process. Refinement, code, audit, build and test, review and merge happen for each one, in that order, whether it is a one-line fix or a new feature. No stage is skipped because a ticket looked easy.
- Planning comes first. Before any code is written, every ticket is refined and split into smaller chunks that can each be delivered on their own. The refinement never works from the ticket alone: it reads the repository’s code, its decision records and whatever other context the project keeps. It is still an agent doing it, so it does not catch everything, but having that for every single problem is already a huge value.
- The model fits the problem. A hard ticket gets a smarter model, and an easy one a faster and cheaper one, while refinement, audit and review always run on a smart one. That keeps the quality where it matters and the cost down everywhere else.
- The heavy work happens elsewhere. 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, which makes working on several topics at once gruelling on a main computer.
horneddoes all of it 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.
Disadvantages: can’t be left alone
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, again, 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.
- It needs looking after. I watch it every day, maintain it, and step in when something breaks. It keeps improving, and I have a few ideas for how to take it further, but the hardware it runs on now sets a limit too.
So, sadly, horned does not replace a developer, or a technical co-founder (btw. if you need one, let’s talk). No tool does today, and none will for quite some time.
Someone still has to understand the problem being solved, most of all in real engineering challenges such as performance, security or design. Models, and the tools built around them, are getting much better at applying known patterns. But they do not know which pattern to use. They only guess. They are very good at guessing, though.
Still, I love it
Despite every limit above, horned is a huge improvement. It creates problems of its own, and from time to time it is a pain in the ass, but I would not give it up.
The reason is simple: the work I hand over, complex challenges included, no longer needs me. It follows the same predictable flow every time, kept on track by strong guardrails and battle-tested prompts, and it bothers nobody on the way.
It does not need my computer either, because the heavy builds and tests run on the Mac mini.
So my attention and my machine are free for the work that does need a person. Claude Code is still open in my terminal all day, but for the problems that need me. The rest gets horned.
See real tickets
Six tickets from the fleet, with their full history. Where a ticket started as a request of mine, the comment that holds it is outlined in blue. It begins with <!-- horned:original-body -->, so the original wording can be compared with what horned made of it.
The ticket bodies do not all look alike. Their structure has been tightened over the months, so the older ones also show how the format matured.





