One terminal. Every agent you have. Working at once.
Claude Code, Codex, and OpenCode are very good at running one task deeply. Medulla is what runs a hundred of them. It decides what work to hand out, places each piece on an agent that can do it, streams back what every one of them is doing, and keeps a live picture of the whole operation in front of you.
Fleets with everyone.
Ask a coding agent to coordinate other coding agents and the same thing happens every time. The orchestrator is just another model with a transcript, and every agent it manages writes into that transcript. Accuracy falls off well before the context window fills, so an orchestrator that reads raw fleet traffic stops scaling at a handful of agents. It runs out of judgement long before it runs out of room.
A chat model manages one thread. An orchestrator has to hold an operation in its head: agents in flight, work being decomposed and delegated, results streaming back, decisions being made continuously. Medulla is built for that job instead of adapted to it.
macOS and Linux:
curl -fsSL https://raw.githubusercontent.com/tinyhumansai/medulla/main/install.sh | shWindows:
irm https://raw.githubusercontent.com/tinyhumansai/medulla/main/install.ps1 | iexEither script downloads the prebuilt binary for your platform, checks it against the release manifest, and installs it to ~/.medulla/bin (%USERPROFILE%\.medulla\bin on Windows). If it updated your PATH, open a new terminal, or run exec $SHELL, so that medulla resolves.
Then:
medulla login # browser sign-in
medulla # start the orchestratorNot ready to sign in? medulla --mock runs a full offline demo, with no account and no network.
Prebuilt binaries ship for Linux (x86_64, aarch64), macOS (Apple Silicon), and Windows (x86_64). Building from source, pinning a version, and embedding the SDK are covered in Getting Started.
Running a lot of agents has meant one of two workarounds: split the terminal into panes and be the scheduler yourself, or wrap the harnesses in another agent and hope it can read everything they produce. Medulla is one process, in one terminal, built for the job instead.
Opening another agent is Ctrl-T — pick a harness or a shell, pick a directory, it is running. There is no ceiling on how many you keep open. Each gets its own terminal, kept live in the background whether or not it is the one on screen, and Medulla reads all of them for the things that need a human: a permission prompt, a blocking error, a dead session, a turn finished and waiting on review. Those arrive as ⚠ 3 waiting on you, not as three panes you were supposed to have been watching.
Your whole fleet, legible. One lane per agent, live. You can see what each agent is doing, answer the one that has a question, and cancel the one that has gone wrong, without losing your place in everything else.
Any machine, in two steps. Your laptop runs work by default. To add a build box or a server, paste one line into an SSH session; it prints an address, and you paste that back.
Repositories it understands. Point Medulla at your projects once. It writes a short profile for each one and routes work by what the repository actually is, instead of guessing from a directory name.
Plans that actually run. A workflow is a saved multi-step plan whose steps each run as a real agent session, with parallel branches and approval gates where a human has to say yes. Ask for one in plain words and an agent will build it for you.
Small surface, low spend. Most of your fleet's output never reaches the orchestrator's context. It reasons over a distilled, current picture, so the volume you pay orchestrator rates on stays small however much is running underneath.
Full documentation lives at tinyhumans.gitbook.io/medulla.
Start with the product pages:
- Workers and Sessions: capacity, threads, and what survives a restart.
- Workflows: authored multi-step plans and their runs.
- MEDULLA.md Workspace Profiles: telling the orchestrator what a repository is.
- Orchestrator Routing: cognitive tiers, harness selection, and strategies.
- Token Efficiency and Budgets: small surfaces and enforced budgets.
Building on Medulla, or running it yourself? Everything technical is in Developers: the TUI, the CLI, configuration and environment variables, worker daemons, authentication, architecture, the Rust SDK, the harness contract, the host-link protocol, testing, and troubleshooting.
Medulla is in early alpha and access is gated. It is rolling out to a small group of OpenHuman subscribers first, alongside gated API access for teams building agentic systems. Alpha partners get direct access to the team, and their workloads decide what we build next. See Pricing and Availability for rates and how to ask for access.
The client is the Rust workspace at tinyhumansai/medulla-src: the medulla SDK and the medulla-tui crate that ships the binary, both under GPL-3.0-only. The orchestrator is gated; this code is not. Read it, build it, and run the whole client offline against the mock runtime. Start with Contributing.
This is Medulla's documentation and distribution surface:
docs/— engineering specs, protocol documents, and plans.gitbooks/— the sources behind tinyhumans.gitbook.io/medulla.install.sh/install.ps1— the installers the commands above run.- Releases — every published binary, its checksum, and the
latest.jsonmanifestmedulla updatereads.
The Rust workspace that produces those binaries is developed in medulla-src; its release pipeline publishes here.