Rent the Factory or Own It?

On November 4, HumanLayer’s hosted users got a notice. The platform would stay up for a transition period of at least 30 days. In that window they could export their data, move to Factory or run the open-source version themselves (HumanLayer).

That is a generous exit. HumanLayer also said it would refund paying customers for the last several months. Nobody did anything wrong. But if your team ran its agents through HumanLayer, the way you build software just got a deadline you didn’t choose.

That is the question for every team building with agent swarms right now. You can rent your software factory, or you can own it.

What happened

Factory acquired HumanLayer on November 4, 2026. Co-founders Dex Horthy and Kyle Mistele and their team joined Factory, and Factory said it will open source HumanLayer. No price was disclosed.

It was Factory’s third acquisition in under a month. On October 9 it bought Mentlio, which routes models and compresses context inside the harness. On October 30 it bought Typedef, which maps how data models, pipelines and dashboards depend on each other.

On the same day as the HumanLayer deal, Meta acquired Conductor, a Mac app for running several coding agents such as Claude Code and Codex at once. Conductor stopped new sign-ups, made its cloud read-only on November 13 and shuts it down on November 20, when deletion of cloud user data begins (InfoWorld, SiliconANGLE). That window was 16 days.

Two tools for coordinating many agents changed hands in one day. The market is consolidating.

What Factory and HumanLayer offer

Factory sells a hosted platform for what its home page calls “your software factory.” Its agents are called Droids, and they run from the command line, the desktop, the web, mobile, Slack, Microsoft Teams, Jira, Linear and CI (Factory). It raised $200 million at a $5 billion valuation on September 15, five months after a $150 million Series C at $1.5 billion (Factory, Factory).

Its pricing is per person: Free if you bring your own inference, Pro at $20 a month, Plus at $100 and Max at $200, with about 5 and 10 times Pro’s usage. Teams is $60 a month plus $40 per person, for up to 10 seats. Business and Enterprise are by contract, and Enterprise includes on-premise options.

To be fair to Factory: this is a serious product. It is model-neutral. It lists customers like Nvidia, Adobe and T-Mobile, and it offers air-gapped deployments for regulated industries (Factory). If you want a software factory working by Monday, you can have one.

HumanLayer started in 2024 as an SDK for keeping a human in the loop. Its require_approval decorator blocked a function call until a person said yes, and human_as_tool let an agent ask a person a question (README, early 2025). By September 2025 it had become CodeLayer, “an open source IDE that lets you orchestrate AI coding agents” (README, September 2025). Today its repository, under the Apache 2.0 license, runs Claude Code, Codex, OpenCode and Pi on your machines and syncs tasks, sessions, plans and reviews across a team.

Two models

Both companies are solving the problem I work on every day: how to coordinate many agents with humans in the loop. There are two ways to answer it.

Rent. A vendor runs the factory. You get the queue, the dashboards, the review flow, the integrations and support. It’s fast to start and polished. But your factory is their product. They choose its roadmap and its price, and if they are acquired, the new owner chooses.

Own. The factory lives in your own git repository. That’s how I work. The rules are in an AGENTS.md file. Each role (issues, code, review, deploy, images) has a skill, a Markdown file every agent reads. A Nushell tool, rxc.nu on this site, hands out work as claims with leases, opens pull requests, records verdicts and enforces the merge rules. Claude Code, Codex and Grok all work from the same files at once, and a pull request is always reviewed by a different session from the one that wrote it. I described the whole setup in Building Multi-Harness Multi-Agent Swarms.

Disclosure: I build an owned factory like this at Astrohacker.

Side by side

	Rent (Factory)	Own (a repository factory)
Time to start	Minutes	Days to weeks to write the rules and tool
Harnesses	Factory’s Droids, with many models	Any harness that reads files and runs Git
Human approval	Autonomy levels and admin controls	Labels, holds and approval comments you define
Review	The platform’s review flow	Your rule, e.g. independent session per PR
Parallelism	A fleet of Droids and sandboxes	Worktrees, claims and leases
Hosting	Factory’s cloud, or on-premise for Enterprise	Your git host and your machines
Cost	$0 with your own inference, $20 to $200 a person	Your harness subscriptions and your time
Support	A vendor	You
If the vendor is sold	You get a transition period	Nothing to move
Forkable	No	Copy the repository

The code was never the moat

Here’s the turn. Factory is open-sourcing HumanLayer, and the code is already on GitHub under Apache 2.0. Anyone can run it.

So what did Factory buy? Not the code. It bought the people, the users and the ideas about how a team should work with agents. And what did HumanLayer’s hosted users stand to lose? Not the code either. They could self-host it. What they had to move was their process: the way their team plans, reviews and approves agent work, which lived in someone else’s product.

This is what I argued in Own Your Memory: when agents do the work, a company is its context. That post was about data. This one extends it to process. Your factory’s process is memory too. The rule that a different session reviews every pull request, the order a cover and its post merge in, who may deploy: that is how your company works. If it lives in a vendor’s settings page, it is the vendor’s.

When the process is a file in your repository, it is versioned, reviewed and forkable like any other code. When a better harness ships, it joins by reading the same files. When a vendor is sold, you lose a vendor, not your factory.

Who should rent and who should own

Rent if you need a working factory this week and have no one to build one. Rent if your company already buys its developer tools as managed services, if you need SSO, audit logs and a support contract more than you need control, or if you’re evaluating whether agent swarms work for you at all. Factory is a reasonable choice.

Own if the way you build software is your advantage. Own if you want to switch models and harnesses as they improve, if you can’t afford a 30-day or 16-day deadline on your workflow, or if you are building software for agents and expect your own agents to be the customers of your tools.

You can also do both. Rent a harness, and keep your process in the repository. Factory’s Free tier runs on your own inference, and its Droids read AGENTS.md like any other agent. Then a vendor is something you use, not something you live in.

How to start owning

1. Write an AGENTS.md with your hard rules and roles. Keep it short enough that every harness reads all of it.
2. Write one skill per role: issues, code, review, deploy. Each says what that role does step by step.
3. Make review independent. The session that writes a change never approves it.
4. Put coordination in Git: one worktree per issue, a claim per worker, and a pull request for every change.
5. Write a small tool for the commands every agent runs, so the rules are enforced, not just written down.
6. Run two harnesses. If the second one can’t do the work from the repository alone, you’ve found process you don’t own yet.
7. Change the process by pull request, like code.

Factory and HumanLayer are building good tools, and I expect the consolidation to continue. That is a reason to make sure the next acquisition in this market is news to you, not a deadline.