Daniel Bauke
Posts / Horned

Inside horned, my mini AI software house

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.

You plan and watch the work in horned's web dashboard and open Linear now and then. horned runs on a Mac mini in the logged-in user session. It sends work to coding agents in tmux over ACP and gets their verdicts back. The agents use every build tool on the Mac, such as Xcode with its simulators, Gradle, and web and backend tools. horned keeps the tickets in Linear, takes pull requests through GitHub, and runs the agents on the AI providers' subscriptions. An animation follows one problem through it: a rough idea becomes a ticket, a spec, code, a build and test run, checked work and a merged pull request. You now and then Mac mini · your user session Web dashboard planning chat · fleet view horned fixed stages · rules in code work verdict agents in tmux, over ACP Claude Code Codex OpenCode Mistral Vibe every build tool on the Mac Xcode · simulators Gradle web · backend Linear tickets GitHub PRs · merges AI providers subscriptions rough idea ticket spec code build & test checked merged

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:

  1. 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.
  2. 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.
  3. And horned is 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.

Planning chat on the Thorough setting, with two answered questions and an open question card offering three choices, one marked Recommended.

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.

In progress board with tickets in lanes from Queue to Finished, two tickets waiting on an answer at the top, and threads joining blocked tickets to the tickets they wait on.

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-heal label 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 fix horned when horned was 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.

One finished run in the web dashboard's history: refining on Claude, working and completing on DeepSeek V4.1 Flash, auditing on Codex, and the pull request review on Claude again.

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.

Two crops from the Mac mini's screen. Top: Activity Monitor, with the horned process outlined, running as the logged-in user next to WindowServer and Finder. Bottom: the fleet's log in Terminal, with its tmux status bar outlined.

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:

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. It is only as good as the project’s checks. Take a backend change that alters the database. horned came 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.
  6. 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

Linear ticket HORN-7893, Show models under providers in the Stats pivot, with its refined analysis, the original request, a Hound QA comment and every status change up to Done.

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

Linear ticket DEL-43, Register the Google and Microsoft OAuth clients, with the agent's clarification comment: a short summary, the details, the trade-offs and three numbered options to reply with.

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

Linear ticket HORN-7883, Run teardown parser drops the last ps row, with its refined analysis, acceptance criteria, the hound's original report and the move to Done.

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

Linear ticket HORN-7886, Codebase Audit 2026-11-18, with its three sub-tickets and the full audit report: stats, findings by category, slow tests, test tampering and top findings.

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

Linear ticket BD-61, Let MDX posts build and appear in the RSS feed, with its refined analysis, a failed completion and its log, the hounds' follow-up tickets and the move to Done.