// long-horizon work, on hardware you own

Stop prompting Claude directly.

hev factory orchestrates a crew of coding agents on a Mac you own. You approve a plan, and it opens the pull requests.

The whole machine is Apache-2.0 and free. Pro is that machine provisioned, on hardware that never sleeps.

one command, one mac via homebrew
$ brew install hev/tap/factory
$ factory
factory: cloning into ~/workspace/factory
reception-up: receptionist on duty in 'reception'

  ↓ the picker opens. reception is the top row.
acme   ↵ attach   ^d details   ^g tell gaffer   ^x stop one   ·   type to filter

💁 reception      the front desk — ask anything
── sub-agents ──
●  gaffer-acme          acme                          claude  working   dispatching the index worker
●! worker-acme-index    acme              ~index      claude  working   npm test has failed the same way …
○? worker-acme-search   acme     HEV-14   rfc-search  claude  waiting   asks which index to rebuild first

🚨 stop the line  3 agent(s) in 3 sub-agent(s)

Everything the factory is doing is a row. A dot says whether an agent is streaming output or sitting idle, a ! marks the worker in trouble and a ? the one waiting on an answer from you, and Enter drops you into any of them mid-task. The last row is the andon cord.

Four concepts.

Everything in the repository is one of them made concrete: a Go binary for the picker, a markdown charter for reception, a markdown file in plans/active/ per RFC, and a markdown contract plus a launchd plist per gaffer. All durable state is a file under ~/.factory.

The session picker

The front door, and most days the only screen you need. It lists every session the factory owns, with the plan step each one is on and what it is doing right now. Enter attaches to a row, typing filters the list, and the last row stops every agent in the factory.

Read the docs
Pixel-art receptionist in a headset at a front desk with a service bell, one hand raised in welcome.

Reception

The desk you talk to. On the first run it walks you through your first factory, then answers for the whole floor. Bring it a half-formed idea and it argues back until there is an RFC worth approving. It never dispatches, never merges, and never approves.

Read the docs
Pixel-art document with a folded corner, text lines, a bold green checkmark, and a ribbon seal.

The RFC

The unit of approval. Every change starts as a markdown RFC you wrote with reception or by hand, and you approve it by merging the pull request that adds it. Connect Linear and the RFC is an issue instead, approved by moving it into one state, which is a tap from a phone. Either way, nothing gets dispatched that does not trace back to an RFC you approved.

Read the docs
Pixel-art gaffer in a hard hat and high-visibility vest, clipboard in one hand, the other pointing off to dispatch a worker.

The gaffer

The parent agent for one factory. Each beat reads the plans you approved, breaks them into tasks, dispatches a worker per task into its own tmux session, and reports what needs you. Its instructions are a markdown file you edit.

Read the docs

Many repos, one harness.

Multi-repo from the jump

A factory's scope is a list of repositories. One approved RFC becomes issues and pull requests across every repo it touches, and each repo gets its own concurrency lane so two agents never work the same tree at once.

This is the case a single agent session handles worst. A feature that spans an API, a client, and a docs site is three working trees, three test suites, and an order the changes have to land in.

One harness, and one thing to install

Every agent runs claude: the desk, the gaffer, and every worker it dispatches. That is one thing to install and one subscription to hold. What the gaffer chooses per task is the model and the reasoning effort, reaching for the heaviest model where the shape of the work is unclear and a smaller one where the answer is already known.

It ships no model and never sees your API keys. Every agent is a tmux session, so you can attach to any of them mid-task and take over by typing.

You approve going in. You review coming out.

  1. Talk to reception about something you want, or skip that and write it up yourself.
  2. The RFC lands as a pull request you merge, or as a Linear issue you move into your team's approved state.
  3. The gaffer's next beat reads the approved plan, breaks it into tasks, and dispatches a worker for each one.
  4. Workers open pull requests. You review and merge them, or the gaffer does inside the narrow band you granted it.

Every worker runs interactive in its own named tmux session, so you can attach to one mid-task and take over.

Get your factory

The open version needs a Mac that never sleeps, and it runs every agent as you, on the one GitHub account gh auth already is. Pro is that machine, provisioned: a mini that stays awake, an account per role so the gaffer is not you, and your own subscriptions signed in on it. Leave an email and we will take it from there.

Pixel-art shipping box with its flaps open, a small silver computer packed inside on foam.
esc