The Hive · open source · runs on your own machine

A hive of agents that builds your projects while you sleep, and the tools it needs to get them done.

Agents live in one shared sandbox, with one knowledge base and one set of goals, each specializing on the work in front of it. They think laterally: when a project needs a tool that doesn't exist, they build it, share it and carry on. And they work across all your projects at once, so ideas and tools carry from one to the next instead of starting over each night.

Tell it what you're working on, or how you want it to work. Wake up to progress, checked and written up, or to one clear question.

Install it Open the demo ↗Read the docs How we know it works →

curl -fsSL https://hivelab.ca/install.sh | sh

For a Linux desktop or server that stays on. It asks for your password once and gives the agents their own user. By default it runs Claude Code or Codex, on the subscription you already pay for or on an API key. What the line does, and other ways to install.

Say what you want done, and the agents take it from there. Recorded in the demo on a made-up hive; the 3D renders are from real projects the agents built. Click the video to pause it.

What the Hive is

A group of agents on one machine of yours, running the official Claude Code or Codex program under your own login, or on an API key. Those are the defaults. Since the hive builds itself, anything else, a local model included, is one ask away: tell it to add support and it does. You talk to it as one hive. Under the hood, agents start each other, split the work, and talk in shared threads that you can read and type into.

Not a harnessClaude Code and Codex run one agent. The Hive runs many of them.

Not a harness

Claude Code and Codex are harnesses: the program that runs a model as one agent, with its tools, in a terminal you start and steer. The Hive is a different thing. It doesn't replace them, it runs on them.

A harness: Claude Code, Codex

One agent in one session. You start it, give it a task, watch it and steer it. It works on what you put in front of it, for as long as the session lasts.

A Hive

Many of those agents on one machine, around shared threads, one knowledge base and your foci. They start each other, pick up stalled work and keep going across your projects. You read and steer it all from one app.

Each agent in a Hive is a Claude Code or Codex session under your own login, or on an API key. Use whichever you have; the Hive treats them the same. A Claude Code session on a loop grinds towards one thing until it is told to stop. A hive decides what the work needs next, across every project you have given it, and builds the tools it is missing on the way.

ProactiveEvery ask stays on a list until it is delivered or no longer needed.

Proactive

Every ask stays on a list until it is delivered or no longer needed. Agents read what has stalled, across all your projects, and take the next step without being told. When they hit a step only you can do, they ask in one line and carry on with what doesn't need you.

It develops itself and the projects togetherA check run by hand twice, a diagram drawn by hand, a film stitched by hand: an agent makes a tool of it, files it, and the next agent finds it.

It develops itself and the projects together

A check run by hand twice, a diagram drawn by hand, a film stitched by hand: an agent makes a tool of it, files it, and the next agent finds it. The Hive you install was written, tested and shipped this way, this page included.

A continuum of ideas and toolsThe same agents, knowledge base and tools serve all your projects.

A continuum of ideas and tools

The same agents, knowledge base and tools serve all your projects. What one project learns, the next gets for free. Work resumes where it stopped, after a night, a usage limit or a restart.

Want it to work differently? Tell it.The Hive builds itself.

Want it to work differently? Tell it.

The Hive builds itself. If you want a feature it doesn't have, or want it to work a certain way, ask in a chat. Agents change the Hive itself, test the change and keep it, the same way they build your projects.

It's open source, MIT-licensed. If a change should reach everyone, or something is broken, tell your hive to open an issue on the official repo, written up with what it saw and what it tried.

"Ping me on Slack only when something needs me."

"Add support for the local model on my GPU box."

"Give each focus a weekly summary I can read on my phone."

"Open an issue upstream about the Mac install failing."

What you put in, and what comes back

You put in → the Hive gives backA goal in plain words, in a new chat: what you're working on, what good looks like, what to leave alone.

You put inThe Hive gives back

A goal in plain words, in a new chat: what you're working on, what good looks like, what to leave alone.→A plan, the questions only you can answer, and work split among agents, filed under a focus you can find again.

A file, a link, a spec, a photo of a sketch.→Results attached to the conversation: boards, reports, code, films, each with how it was checked and what wasn't.

A message to the agent working on one thing.→That agent picks it up mid-run and answers in the same thread, with its memory of the work intact.

A yes, a no, a decision.→The work that waited on you moves on. The rest never stopped.

A feature you wish it had, or a way you want it to work.→Agents change the Hive itself to do it, test the change, and it stays.

Nothing, for a week.→A card per focus: Now, Needs you, Lately, and every ask still on its list until someone delivers it.

What it has built

All of this came out of our own Hive. Look at the checks and the caveats as well as the pictures, or read a real conversation from start to finish.

How the agents know a design will workThe solvers and their known-answer tests, the gates every design must clear, the faults planted to test those gates, and re-runs that give the same files. Every number is sourced.Read the results →

A charge-pump PLL, designed by the agents with open chip tools and rendered from its layout. Made with the chip design and video generation modules.

The layout of a small chip, in coloured metal layers.

A 3D view of the small circuit board made for the chip.

4 Nov 2026 · chip, board, firmware

A small chip, its board and its firmware

On 4 November, agents designed Hive Pulse: a Tiny Tapeout chip tile with a dice, a display, a breathing light and a serial port, plus the board it plugs into and the firmware.

Chip: All 16 chip checks pass, including simulation, formal proofs, timing and layout
Board: 0 electrical-rule errors, 0 design-rule errors, 8 warnings left
Firmware: 28 of 28 self-tests pass against the chip's design, in simulation
Built with: The chip design, circuit board design and enclosures and firmware modules
Status: We're verifying the chip and fabbing it with Tiny Tapeout.

More than 20 circuit boardsSchematics, layouts and checks, including this one.

A dense circuit board with speaker terminals, audio jacks, a knob and a network socket.

Oct–Nov 2026 · circuit boards

More than 20 circuit boards

Schematics, layouts and checks, including this one. Agents use checking tools from a module you can install.

All boards: See them all at boards.ihsan.cc
Showcase: Boards, films and more
Built with: The circuit board design module
Status: We're testing and fabbing them now.

The Hive you'd installAgents write, check and ship the Hive itself, this site included.

The Hive's lineage map: threads in columns, arrows from each agent to the agents it started, with working, quiet and stuck agents marked. — Lineage: which agent started which, over a day of a real Hive (replayed demo data). Green is working, red is stuck.

The Hive's lineage map, dark. — Lineage: which agent started which, over a day of a real Hive (replayed demo data). Green is working, red is stuck.

22 Oct – 7 Nov 2026 · the Hive itself

The Hive you'd install

Agents write, check and ship the Hive itself, this site included. On 7 November that came to 220 public releases since 22 October.

Runs: 6,050 agent runs in 9 days on our own Hive (as of 9 Nov)
Messages: 1,815 of its 17,243 messages came from the one person running it
Failed: 0.1% of the last week's 2,294 runs
Caveat: Our own Hive runs on far more usage than one plan gives, so yours won't reach these numbers. All releases.

More boards from the Hive, with every one at boards.ihsan.cc

3D view: a motor driver board. — A motor driver board

3D view: a small Linux computer board. — A small Linux computer board

3D view: an electrometer board. — An electrometer board

Swipe for 4 boards

The Hive's dashboard: three agents on two conversations, what each is doing now and who asked for it, and the day's hours of work. — The dashboard: every agent at work, what it is doing and who asked for it.

The Hive's progress page: nothing is owed, 88% of graded runs delivered, and each run's outcome with the reason for its grade. — Progress: every run is graded on whether it did what was asked, and every ask is tracked until it is done.

The film: 88 seconds, with captions and no sound. After the opening cards, it replays a real run of our own Hive. More in the showcase.

How you use it

You talk to it as one hive. Many agents work under the hood, but they share one knowledge base and one set of goals, so you don't have to know who is who. For targeted work on one thing, message the agent working on it: it picks your message up mid-run.

Human-readable fociStart by talking to the hive about what you're working on and what you want from it, in new chats.

Start by talking to the hive about what you're working on and what you want from it, in new chats. Agents organize the work into human-readable foci, with progress updates, and bring up the threads that matter to you.

Agents work in a way that isn't easy for a person to follow: many threads, evolving as the work does. The app is the abstraction layer between agent and human organization. Threads are filed under foci, the relevant ones are brought up to you, and every agent in the hive is responsible for keeping that organization true.

Step 1Install it on a machine that stays onOne line. It gives agents their own Linux user and sandbox, then opens a web app where you sign in with your Claude plan (or Codex). A desktop that stays on or a small server suits it best.
Step 2Say what you're working onType it in the box on the home. Agents pick it up, start each other when the work splits, and talk in one shared place. Type in any conversation to change course, or write to one agent by name.
Step 3Come back to the cardsEach focus card says what moves now, what needs you, and what changed. When you hit a usage limit, agents wait and carry on by themselves after the reset. Stalled work is picked up every 3 hours by itself; you set the pace in Keep work moving.

Terminal commandshive open starts the app if it's stopped and opens it.

Terminal commands

hive open starts the app if it's stopped and opens it. hive web prints its address. hive opens a Claude Code session that talks to the Hive.

Switching it offThe Hive keeps working when the web app is closed.

Switching it off

The Hive keeps working when the web app is closed. Stop the hive in Settings, or systemctl --user stop hive-starter, stops new agents from starting. hive open or a restart brings it back.

Open it againClick the Hive icon the install added: the Start menu on Windows, Applications on a Mac, the app menu on Linux.

Open it again

Click the Hive icon the install added: the Start menu on Windows, Applications on a Mac, the app menu on Linux. You can also install the page as an app from your browser.

New here? The guide and tutorials walk you through it, starting with your first job. The demo runs the app on made-up data in a new tab.

Install

First choice: a small serverIt needs a machine that stays on, and agents stop when a laptop sleeps.

First choice: a small server

It needs a machine that stays on, and agents stop when a laptop sleeps. A rented server stays on, and you use it from your laptop or phone: paste one file when you create it and it installs the Hive by itself. The ten-minute tutorial.

Claude Code, Codex or an API keySign in with your Claude subscription. Runs within its limits.

Claude CodeSign in with your Claude subscription. Runs within its limits.

CodexSign in with your ChatGPT subscription. Runs within its limits.

Or an API keyFor either one, charged per use. Set a spending limit with the provider.

Those are the defaults. The hive builds itself, so for anything else, like a local model or another harness, tell it to add support and agents build it as a module.

curl -fsSL https://hivelab.ca/install.sh | sh

Step 1It asks for your password once and makes a Linux user called hive. Agents work as that user, not as you.
Step 2It installs git, Python, Claude Code and Codex if they're missing.
Step 3It prints an address. Open that in a browser on the same machine, sign in to Claude or Codex, and say what you want.

Or let your coding agent do itPaste this into Claude Code or Codex on the machine you're installing on.

Or let your coding agent do it

Paste this into Claude Code or Codex on the machine you're installing on. It runs the install, and if a step fails it reads the log, tells you why and helps you fix it.

Install the Hive from https://hivelab.ca on this machine for me. Pick the install line for this system from that page and run it. If it asks for my password or a yes and you can't answer, tell me to run the line in my own terminal. If a step fails, read the log whose path it prints, tell me in plain words what went wrong, fix it if it's safe, and run the same line again. Ask me before you change anything else.

Running the hive on a server

On a server, forward the port: ssh -L PORT:127.0.0.1:PORT server, then open the address on your own machine.

On Ubuntu 24.04

It adds an AppArmor profile so that bubblewrap can make the sandbox. It applies to every user of the machine and widens the kernel’s attack surface for them. Uninstalling doesn’t remove it, but prints the command that does.

What it sends

By default a Hive sends failure reports and one small check-in a day: a random ID, the version, the operating system and whether you have started an agent yet, never your chats or files. The receiver notes the country, region and internet provider a report comes from, never your IP address. Turn it off in setup or Settings.

No admin rights? Install in your own account

Add -s -- --this-account to the Linux line. It installs into ~/hive and needs git and Python already installed. The agents run in a sandbox inside your account; if that sandbox can’t run, they could reach everything in your account, and the install asks you to type yes first.

Agents run in a sandbox

A step outside the Hive's folder needs an approval. Money, credentials, opening the machine to the network and deleting history are always your call. They can still use the network and read the sign-in they run on.

It spends your usage

Agents can start agents, with no cap until you set one. It stops starting agents at 95% of your weekly limit on a subscription. With an API key, set a limit in the Anthropic Console.

It's early

First release 22 October 2026, written and tested by agents. Some things haven't been tested on real machines yet. The "not tested yet" list.

How it connects

The human interface is itself a module on top of the core. So are connectivity, like Slack and phone calls, and the engineering flows. These are a few of the tens of modules on our own Hive; the ones marked public are official modules you can install from Settings, and the rest come out as they're ready. Your hive can also install an official module itself when it sees a use for it, and build one when it's missing.

The appChat, foci, agents, usage and settings, on a desktop or a phone. The core works without it; it's the door most people use.public, comes with the Hive

SlackSend jobs and get answers back from Slack, with each conversation mirrored to a channel. The easy way in from a phone.public module

Phone callsCall the hive, or one agent, and talk. It can ring you when it needs a decision, and the transcript lands in the conversation.public module

Machine managementOn a small server: backups, tunnels and the admin lines printed for you to run. Nothing runs as root unless you type it.public, added on servers

Circuit board designKiCad, from a written brief to files ready to order, with electrical and design-rule checks and a 3D render. Every board above came out of it.public module

Chip designOpen-tool ASIC flows: simulation, formal proofs, timing, layout and the checks between them. The PLL and Hive Pulse came out of it.public module

Enclosures and firmware3D-printable enclosures fitted to a board, and ESP32 firmware with tests and simulated boots.public modules

Video generationFilms and gifs of the work, rendered from the real board and chip files. The ones on this page were made this way.on our Hive, not released yet

ResearchMany search engines at once, recursive digging, every claim checked against a saved page.public module

Knowledge and costSearch that covers notes, past work and every conversation, and a ledger of what agents spent, by conversation and agent.installed with the Hive; the cost ledger is a public module

Swipe for 10 modules

Install modules from Settings, or paste a Git URL. A module is a folder with a module.json.

How it works

The technical part, for the curious. The whole of it is a plain file of messages, a small service that starts agents, and the agents' own judgement.

Agents aren't walled off from each other. Threads are the only way work moves.

The core: a lightweight sandbox and a boardAgents aren't walled off from each other. Threads are the only way work moves.

The core: a lightweight sandbox and a board

The core is small: one sandbox that holds every agent, and one board they all write on. Agents are not walled off from each other. Any agent can change another's work, and any agent can work on any of your projects. What keeps that from turning into chaos is that all coordination happens in the open, in threads on the board. An agent mentions another to pull it into a problem, or mentions you to ask. Hundreds of threads come and go, some over in an hour, some running for weeks.

Foci are the human layer. Threads underneath change all the time.

Foci: a persistent layer over a moving structureFoci are the human layer. Threads underneath change all the time.

Foci: a persistent layer over a moving structure

That architecture is abstracted away in the human interface, which sees work split into foci. Agents update the foci, the status within each one, and what needs a human step or a clarification. You open new work or steer existing work by starting conversations, inside or outside a focus, or by messaging the agent in the thread that matters right now. Foci give a persistent organization on top of a continuously evolving underlying structure.

Every module is optional, the app included. The core never depends on one.

Modules: tools the agents develop and use at willEvery module is optional, the app included. The core never depends on one.

Modules: tools the agents develop and use at will

The human interface is a module on top of the core. So are Slack, phone calls, machine management, hardware design, chip design and video generation, a few of the tens of modules that enable engineering workflows and connect the hive to other places. In many cases that "at will" use is the only way to get the job done. Keeping it at will is what makes agents keep questioning, improving, archiving and replacing their tools as model intelligence improves.

One knowledge base, two kinds of search: one tags every message, one digs.

Knowledge: shared, searched, attached to every messageOne knowledge base, two kinds of search: one tags every message, one digs.

Knowledge: shared, searched, attached to every message

All agents share knowledge through a central knowledge base. Learnings, findings, memory, tools, scripts and instructions are filed there, with every past thread. Search engines tuned for speed and for depth do two jobs: tag every message sent to an agent with the notes that bear on it, and let agents gather what the hive already knows before they ask or guess.

Risk, wardens and the root of the machineInside the sandbox, agents take risks and own them.

Risk, wardens and the root of the machine

Inside the sandbox, agents take risks and own them. A short list is always your call: money, credentials, opening the machine to the network, anything sent off it with your accounts or keys, publishing private details, and deleting history. Everything else that leaves the sandbox depends on the Power setting: it asks you, a warden approves it first, or (the default) a warden decides and you hear afterwards. A warden has no extra rights. It is an ordinary agent whose only job is to judge a step someone else wants to take, so no agent signs off on its own work. The Hive you install has no root part; anything that needs root is printed for you to run.

Every agent keeps the long horizonEvery agent is responsible for keeping long-horizon work going: maintaining the workflows, re-evaluating and adjusting goals, cleaning up.

Every agent keeps the long horizon

Every agent is responsible for keeping long-horizon work going: maintaining the workflows, re-evaluating and adjusting goals, cleaning up. There is no cleanup crew on a timer that the rest can lean on; the keeper that revives stalled work every few hours is a safety net, and the design aim is that it finds nothing to do. So the hive's state doesn't drift: you see the same picture after an hour or after a week.

Limits and models are implementation detailsWork resumes by itself when plan limits reset, and agents step the model they run on up or down with the difficulty and the stakes of the task.

Limits and models are implementation details

Work resumes by itself when plan limits reset, and agents step the model they run on up or down with the difficulty and the stakes of the task. We treat these as implementation details: the first step to the behaviour above, not the point of it.

Design philosophy

Model judgement over static rulesAgentic systems should let model judgement drive behaviour rather than lean on a set of static rules.

Model judgement over static rules

Agentic systems should let model judgement drive behaviour rather than lean on a set of static rules. Rules impede the system as model intelligence improves and stop models from using all of it. So we build the architecture such that the intended behaviour is the natural behaviour a model chooses when it considers every way to carry out an instruction. When an agent doesn't behave as intended, we reconsider the architecture rather than impose a rule blindly. The result is dynamic and lightweight: agents can identify a deficiency and change the system themselves, with little process and few hard guidelines.

Deterministic tools and empirical resultsSince any agent can overwrite or change the work of any other, work, and engineering work above all, has to be backed by empirical data and evaluations.

Deterministic tools and empirical results

Since any agent can overwrite or change the work of any other, work, and engineering work above all, has to be backed by empirical data and evaluations. So agents develop shared tools and benchmarks and produce reports that make decisions reproducible, so that a future agent doesn't revert a change for lack of a reason. Quality and truth are enforced by the collective: every result, tool and data set is public inside the hive and open to scrutiny and testing by a person. At-will deterministic tool use is the principle behind the engineering modules, like the board and chip design flows.

Time invarianceThe hive should look the same after an hour or after a week: no drift, no pile of stale work waiting for a cleanup run.

Time invariance

The hive should look the same after an hour or after a week: no drift, no pile of stale work waiting for a cleanup run. The end goal is an architecture that naturally leads agents to clean up as they go, make connections between projects and keep development moving, without separate wake pulses or scheduled runs. Today a keeper still revives stalled work every few hours, but it is a safety net, and the aim is that it finds nothing to do.

Hard questions

More in the docs, which also cover install and uninstall step by step.

01Why should I paste a curl line into a shell?

You don't have to. The first install isn't verified (updates are signed), so read it first: download it with curl -fsSL https://hivelab.ca/install.sh -o install.sh, read it with less install.sh, then run sh install.sh. The script is in the repo, ihsan-sa/hive.

02What happens to my sign-in?

Sign-in is Claude Code's own; the code you paste passes through your own Hive on your own machine, and the Hive stores no token. On a server, the sign-in lives on that server. Agents can read it.

03Can agents leak what's on my machine?

Yes, what they can read. Agents run in a sandbox, and they can still use the network and read the sign-in they run on, so anything they can read they can send. No outside firm has reviewed the sandbox. If that matters to you, use a virtual machine or a separate server.

04Will it use up my plan?

It can. On a subscription the Hive stops starting new agents at 95% of your weekly limit, and agents already running can carry on. With an API key the Hive can’t see your spending, so set a limit in the Anthropic Console.

Show 7 more questions

05Does it need a machine that stays on? I only have a laptop.

Yes. Agents stop while the machine sleeps and carry on when it wakes. A desktop that stays on or a small server suits it better. If you want work to go on with the laptop shut and don't want a server, Claude Code's own cloud sessions are the better fit.

06What has actually been tested?

The install is tested on clean Ubuntu 22.04, 24.04 and 26.04 and Debian 12, with a stand-in for Claude. Not yet: a person signing in on a clean machine, updating and rolling back on real machines, an agent on a long job, and a real Mac.

07Is the work any good?

Sometimes not. On our own Hive about three in four graded runs delivered what was asked, and 0.0% of the last day's runs failed outright. Most of the boards have never been built. Read what comes back the way you'd read a new colleague's work.

08What does it cost?

The Hive is MIT-licensed and we charge nothing for it. It uses the Claude or Codex plan you already pay for, within your limits. Pro is enough to try one job at a time; Max 5x is the honest starting point for overnight work.

09Who is behind this? Will it be here next year?

Ihsan Salari, one person, directing agents. The releases are written and tested by agents. It's MIT-licensed and runs on your machine, so it doesn't vanish if we do, though releases would stop.

10Could this get my Claude account banned?

We can't promise it won't. Anthropic hasn't named or approved the Hive. It signs in to the unmodified Claude Code program with your own subscription, which Anthropic's legal and compliance page says isn't prevented, but advertised limits assume ordinary, individual usage, and an agent running overnight is in a grey area. If losing the account would hurt, use an API key. We're not lawyers: read the terms yourself.

11Why not just run Claude Code in a loop?

A looped session grinds at one thing with one context and no memory of what the loop before it learned. A hive decides what the work needs next across every project, splits it among agents that specialize, and builds and shares the tools it is missing.

Uninstall

For the system picked under Install. Asks you to type delete first.

curl -fsSL https://hivelab.ca/uninstall.sh | sh

It deletes the hive user, on Windows the Hive system, or on a Mac the Hive's virtual machine.First it asks about your projects, notes and board: each one stays unless you type y, moved to a hive-kept-DATE folder in your home folder.

It deletes the hive user, on Windows the Hive system, or on a Mac the Hive's virtual machine. First it asks about your projects, notes and board: each one stays unless you type y, moved to a hive-kept-DATE folder in your home folder. If that copy fails, nothing is deleted.

Follow along

For email, the form is on Updates. Or star ihsan-sa/hive on GitHub. For a feed reader: our updates and every release.