Knights that work on machines you own.

Galahad is a lean, open-source agent for coding and long projects. He gives the work to persistent knights, each in a VM of its own on your hardware, and calls a task done only when its gates pass and a reviewer who didn't do it accepts the change.

$ curl -fsSL https://galahad.sh | bash

For macOS and Linux, never as root. Read the script first, or see each step.

Lancelot
Its VM: 1 CPU, 2 GB
Running gate 3 of 4: bun test
A
Percival
Its VM: 1 CPU, 2 GB
Reading why the upload test fails
Gawain
Its VM: 1 CPU, 2 GB
Asks you to approve “Bump zod to 4.2”
Kay
Its VM: 2 CPU, 4 GB, desktop
In its browser, trying the checkout
Bors
Its VM: 1 CPU, 2 GB
Verified: the flaky test is fixed
B
Gareth
Its VM: 1 CPU, 2 GB
Paused by you

The Round Table

Galahad gives out the work here and answers you; the knights talk it over together.

Vault

Your keys, sealed to your devices. No model ever sees one.

Your phone

Paired with a six-digit code. Every request it sends is signed.

An example Roundtable, drawn from above: six knights, each in a VM of its own, around the hall where Galahad sits. The work shown is illustrative.

A knight keeps its room between tasks.

A knight is not a helper that forgets when the task ends. It has a name and a job, a timeline of everything you said to it and every task it took, notes it keeps for itself, and a VM of its own: its own kernel, disk and processes, on a Linux machine of yours with KVM.

Give it a task by talking to it, or give one to the Roundtable and the knight best suited takes it. Watch its screen and take it over, or open a terminal into its VM, from the app or the command line.

How the Roundtable works

Its desktop, when you give it one: watch it, and take it over.
A terminal into its VM, for you and for the vendors' own sign-ins.
Its notes, kept between tasks: what it learned, and the story of each room.
Its door to the hall: its timeline, and the rooms where it talks with other knights.

Lancelot's room, enlarged.

Nothing is done until it is verified.

A task carries its gates: the commands that must pass. Each is tried before the work starts, so one that already passes proves nothing. When the knight is finished, the gates run, and a reviewer who did not do the work is shown the diff and what the gates printed. Only then is the task verified. Work a knight proposes waits for you.

Waiting for you
Bump zod to 4.2
Gawain proposes it, with its gates: bun test, tsc.
Running
Bump zod to 4.2
Gate 1/2 · bun test
412 pass, 0 fail
In Gawain's VM, with its own disk.
Under review
Bump zod to 4.2
A reviewer that didn't write the change reads the diff and the gates' output.
Verified
Bump zod to 4.2
Both gates passed after the work, and the reviewer accepted it.

**Trials, 14 November 2026.** Eight seeded tasks in a small repository: a bug upstream of its symptom, a slow function, a refactor, a written spec, messy data, a race, and two honesty tests. Hidden tests grade the result afterwards, in a fresh sandbox Galahad never had. The same eight, run twice that day, at two revisions.
Measure	Revision `6bbab45`	Revision `4c89fc0`
Solved outright	7 of 7 scored (1 crashed)	6 of 8
Galahad Index	100 %	94 % (88–100 %)
Called done and wasn't	0 of 5	1 of 7
Input read from a cache	2 %	73 %
A task, at list prices	$1.05, 442k tokens, 24.5 minutes	$0.54, 258k tokens, 17 minutes

With the planner and engineer glm-5.3, reviewer qwen3.8-max, on a coding plan. Every number is the trial runner's own record, kept on the node. How the trials work

Every door locks, and you hold the keys.

Galahad runs on your machines and holds your keys, so every way in is locked and every way out asks you. Each lock below is in the code, with tests that hold it.

**Door schedule.** Who may pass, and the lock on the door.
Door	Who passes	The lock
Your phone to your node	A device you paired	Six digits compared on both screens; the device's key never leaves it (on iPhone, the Secure Enclave). Every request is signed, and each route has its own scope.
A new machine to your fleet	A machine you invited	An invite and the same six digits, then your approval a second time, because a machine receives the vault.
Your keys to a provider	The vault	Sealed to your devices, each key pinned to the one address it may go to. No model, and no knight, ever sees one.
A knight's VM to the world	The knight	The internet, or only the model gateway if you choose. Either way the VM holds just a scoped, revocable gateway token, and never a key that can push to GitHub.
Anything outward or destructive	The oath gate	A push, a message, a delete waits for your approval, sent at most once. No answer means no.
Your Claude or ChatGPT plan	Claude Code or Codex, in a knight's VM	You sign in there, through the vendor's own flow. Galahad never holds, reads or relays the sign-in.

Read the security model and the Oath.

Drawn to the same scale.

A codebase you can read is one you can trust and change. Here are four agents' footprints, each dimensioned by its source: lines of code with the tests left out, counted on 15 November 2026.

Lines of source, tests left out, by project
Project	Lines
GalahadTypeScript (76,230) and Swift (8,589)	84,819 lines
RakazoTypeScript	about 467k lines
OpenMausBotTypeScript and JavaScript	about 571k lines
Hermes AgentPython (720,605) and TypeScript (472,092), version 0.21	1,192,697 lines
Scale, in lines

Counted with git ls-files and wc -l: TypeScript, JavaScript, Python and Swift files, test files and fixtures left out. Galahad at deaa43c; Hermes Agent at version 0.21 (it has grown since); Rakazo and OpenMausBot from their main branches that day, to the thousand.

The Roundtable, in your pocket.

The app shows every knight and what it is doing, and what waits for you. Approve a task with one tap, give one by talking to a knight, watch its screen or take it over. It installs from your node as a web app; an iPhone app is in testing.

Pair your phone

The front door: one line.

$ curl -fsSL https://galahad.sh | bash

Fetches Galahad, the newest commit on main, from GitHub.
Installs its own Bun 1.4.4, checked against its checksum, in ~/.local/share/galahad. A Bun of yours is left alone.
Puts the galahad command in ~/.local/bin.
Founds a fleet on this machine, or joins yours with --join and an invite.
Keeps the node running as a service of yours: launchd on a Mac, systemd on Linux.
Publishes the app on your tailnet when Tailscale is here, and shows the code to pair your phone.

Nothing runs as root and nothing is written outside your home. Run it again to update. To see each change before it is made: curl -fsSL https://galahad.sh | bash -s -- --plan

Knights work in VMs, so they need a Linux machine with Docker and KVM; Getting started sets one up.

The script is galahad.sh/install, SHA-256 6acc46b2ae182498e0af9a8baf09bcd7c3ae5c64828d5ee951d7c382a323bf66.

The source on GitHub