Private alpha Maia OS for design partners · Maia Cloud planned
Agent coordination for engineering teams using Claude Code and Codex
Coordinate your team's coding agents on machines you control.
Maia OS runs each Claude Code or Codex worker in its own Git worktree, through one Maia Node: a program on your machine that checks each request and keeps a receipt for every accepted command. Your agents use your own AI accounts. We sell no model usage. source-implemented candidate
Recorded with Maia OS 0.1.0-canary.52, 3 Nov 2026
maia --profile capture integration plan claude-code
claude-code planned plan_claude_code_13af41d1bf7eaa0fe3ba98132cce953adac9f44211a2de08 2026-11-03T16:32:33.970Z /tmp/maia-capture/home-state/xdg-state/maia/state/2b738a3c0b3a86fe/integrations/claude-code/60d7eb7f12fbb28a52533fe8be5884097403562aa02dc73991a021c7067e29a5/claude 60d7eb7f12fbb28a52533fe8be5884097403562aa02dc73991a021c7067e29a5
next: maia integration apply claude-code --plan plan_claude_code_13af41d1bf7eaa0fe3ba98132cce953adac9f44211a2de08
maia --profile capture integration apply claude-code --plan plan_claude_code_13af41d1bf7eaa0fe3ba98132cce953adac9f44211a2de08 --command-id capture-approve-claude-code
claude-code active 1
maia --profile capture integration status claude-code
claude-code active 1 none
maia --profile capture receipt show capture-approve-claude-code
receipt_7543632d5c3b4aec94390e5a4ccabf99 succeeded integration-authorization:claude-code
Later in the same session
maia --profile capture receipt list
COMMAND METHOD STATE TARGET TARGET ID
capture-guard-greet-2 project.guard.confirm succeeded project_guard project_67acfbdac85c4e48ac5486424fae30fa
capture-register-greet project.register succeeded project project_67acfbdac85c4e48ac5486424fae30fa
capture-approve-claude-code integration.apply.claude-code succeeded integration-authorization claude-code
Notes on the recording
source-implemented candidateA person approves each agent program first. The plan line records the path and SHA-256 of the Claude Code executable. Its state, "planned", is the plan's state, not a status label.
The local user applies the plan with a command. The result line says "active". By default, workers get a scoped credential that cannot approve executables, and the coordinator MCP server cannot either. Host-authority mode, off by default, runs a worker as you. A retry with the same command ID replays the first result instead of acting twice.
The Maia Node keeps a receipt for every accepted Node command. Read it back by its command ID: the receipt says "succeeded".
Three accepted setup commands, three receipts. Each row says "succeeded": an approved executable, a registered repository and a changed fan-out limit.
Parallel agents need separate checkouts and one record you keep.
Running Claude Code and Codex side by side raises three questions: where each agent works, which ports it takes, and who approved what. Maia OS answers each one on your own machine: source-implemented candidate.
Where each agent works.
Each Session gets its own Git worktree, so agents on one repository do not share a checkout.
Which ports it takes.
A Session can lease up to eight TCP ports for its dev servers, so parallel agents stop fighting over them. The leases are advisory.
Who approved what.
The Maia Node records who ran each accepted command and keeps its receipt on your machine.
Approve, register, limit, then let the workers run.
Four steps from a running Maia Node to agents at work: source-implemented candidate. The recording above covers steps 1 to 3; no worker ran in it.
Start a Maia Node on your machine.
It checks, authorizes and stores every operation. The
maiacommand, the SDK, the MCP server and the desktop app all talk to it.Approve each agent program.
A person plans and applies the approval for Claude Code or Codex, and the Node pins the executable by its SHA-256.
Register a repository and set its limits.
Register a Git repository as a Project, then cap how far agents can fan out. You preview the change, confirm it and get a receipt. The preview names the revision it expects and expires after 30 seconds.
Run Claude Code and Codex workers in parallel.
Each worker gets its own Git worktree and signs in with your Claude Code or Codex account. Watch them with
maia session observe. Not in the recording.
Maia OS: the core you run yourself.
Maia OS is the software in the recording. It runs on your macOS or Linux machine, keeps its state in your home folder and answers only on 127.0.0.1. source-implemented candidate
| Item | Status |
|---|---|
Maia Node, maia CLI, TypeScript SDK, MCP server | source-implemented candidate |
| Claude Code and Codex workers | source-implemented candidate |
Maia's own agent, maia agent | source-implemented candidate |
| Maia's own agent as a general swarm worker on the Node | planned |
| Desktop app (macOS first, Linux second, unsigned) | source-implemented candidate |
Installer, background service, maia update | planned |
| Windows hosts | unsupported |
| Open source at launch, together with Maia Cloud | planned |
Open source at launch: planned. The repository is private today and publishes no licence. Maia ships canary builds; no stable release is planned. Public launch happens when its evidence gates pass; no date is set.
What the status words mean
- source-implemented candidate
- built in the source, not release-qualified
- planned
- not built
- unsupported
- not supported
Run Maia OS from source. Private repository access required. Read the setup guide
Maia Cloud: the same Maia OS, run for you.
plannedMaia Cloud is the managed offer we plan to build on Maia OS. The hosted product still awaits approval.
A Maia Node per organization, never shared.
Each customer gets its own Control Node, machine or container, volume and encryption key, in EU regions first.
No cloud-only features.
Maia Cloud would run the same Node, CLI and Desktop that self-hosted Maia OS runs.
Leave when you want.
Export at any time and restore on a self-hosted Maia Node with the same state digest, a fingerprint that shows the copy matches.
Support access on your terms.
A customer admin approves it, it ends on a timer, it covers operations and never content, and it shows in your audit log. No standing staff access.
Rejected by design: a cloud-only fork, cloud-only operations, and one Maia Node shared between customers. unsupported
What protects your work today, and what does not yet.
Every line below states its status. We hold no security certification.
Protections in Maia OS
source-implemented candidateThe Maia Node answers only on 127.0.0.1. It checks the exact Host, rejects requests from browser pages, and uses a bearer token in an owner-only file that changes at each restart.
A person approves each agent program. Maia records its path and SHA-256 before any worker can use it.
Some steps stay human-only. Workers get a scoped credential that cannot approve executables or confirm previews, and the coordinator MCP server cannot either. Workers run in the vendor's sandbox by default; host-authority mode, off by default, runs a worker as you.
Preview, confirm, receipt. Consequential changes show a preview first, name the revision they expect, and leave a receipt.
Limits and a stop switch. Per-Project fan-out guards cap depth, live children, messages per minute and leases. An emergency hold on a Project or account makes new work fail with
held.Containment by default. Default worker launches require the vendor's sandbox and, on Linux, Maia's native process host (cgroup v2 and Landlock).
Secrets stay where they belong. Vendor sign-ins stay in the vendor CLI's config. API keys never travel as command arguments.
Diagnostics stay on the machine. The local diagnostics stream writes a file; nothing leaves it.
Registration refuses to proceed without hard limits
Recorded with Maia OS 0.1.0-canary.52, 3 Nov 2026
maia --profile capture project register . --name greet --command-id capture-register-greet
maia: The Maia native process host reported prepare/path_invalid: cgroup_delegation_unavailable
The Node's status named the fix. The user restarted the Node in a cgroup delegated to its user, then checked again.
maia --profile capture status
Maia node ready
profile: capture
pid: 318422
instance: instance_6c6d94fd053543558e77ea7b03ff39ed
storage: ok (wal)
host authority: disabled
events: 0 bytes over limit, oldest 0 h
process resources: healthy (hard_containment; hard limits enforced)
capacity: 0/128 process trees in use
observations: none yet
bubblewrap: found
socat: found
user namespaces: allowed
maia --profile capture project register . --name greet --command-id capture-register-greet
project: project_67acfbdac85c4e48ac5486424fae30fa
workspace: workspace_73d9bd17806b41359b26b3a91fe46a92
repository: repository_8a61eef70abf42a6b4b14e08844f6cd3
next: maia session create --project project_67acfbdac85c4e48ac5486424fae30fa --base <branch> --executor codex-cli --message '<task>'
Limits, in Maia OS's own words
- Workers run as your operating-system user: a worktree is not a sandbox. Stronger containment through OpenShell: planned.
- The coordinator mark is self-asserted. The Node cannot tell a person from a worker that holds the operator credential. Separating requester and confirmer: planned.
- No tamper-evident audit log yet: receipts and events exist, with no hash chain, signing or export. Audit export: planned.
- Organizations, members, roles, SSO, MFA, multiple users, encryption at rest, signed releases and updates, public vulnerability reporting: planned.
- Exposing a Maia Node beyond 127.0.0.1, or sharing one Node across a team: unsupported. Use SSH between Nodes.
- Security certifications: none held. Compliance work for Maia Cloud: planned.
Hosted plans would charge by concurrent agents, not by seat.
Everyone is free during private alpha. Hosted plans are planned, and we publish no prices yet.
Personal
1 person, a few agents
Freelance
up to 3 people, about 20 agents
Business
up to 15 people, about 75 agents
Enterprise
contract, 250+ agents, annual only
A concurrent agent is one agent working at a given moment: three Claude Code workers running at once count as three. You bring your own AI, so model usage never appears on our bill.
Every hosted plan includes a hosted Maia Node, a shared agent pool, storage and sandbox-hours.
Request accessQuestions engineers ask first.
Is Maia OS open source?
Not yet. Open source at launch, together with Maia Cloud: planned. The repository is private and publishes no licence. The @maiaos packages on npm carry no licence either, so they are not open source.
Which AI do I bring?
Your own. Claude Code and Codex workers use your Claude Code or Codex sign-in (maia login claude, maia login codex) or an AI gateway you connect with its base URL and API key: source-implemented candidate. Maia's own agent, maia agent, stores one credential per model provider: source-implemented candidate; using it as a general swarm worker: planned. Other harnesses: planned. We sell no model usage.
What does private alpha mean?
Design partners run Maia OS from a source checkout of the private repository, on macOS or Linux. Maia OS has no installer, hosted signup or stable release. Every built part is a source-implemented candidate and nothing is release-qualified, so do not rely on it for production work.
Where does my data live?
With Maia OS, on your machine. The Maia Node keeps its records in a local database under your home folder, listens only on 127.0.0.1, and keeps its diagnostics local: source-implemented candidate. Your agents still send prompts and code to the AI provider you sign in with, under that provider's terms. Maia Cloud (planned) would give each customer its own Node, volume and key, in EU regions first.
Does Maia Cloud exist?
No. Maia Cloud is planned, and no tenant feature exists. Registering lets you tell us you want to join its design-partner programme (planned).
How are workers contained?
Default worker launches require the vendor's sandbox and, on Linux, Maia's native process host: source-implemented candidate. Workers still run as your operating-system user: a worktree is not a sandbox. Stronger OpenShell containment: planned.
Which machines does it run on?
macOS on Apple silicon and Linux x64: source-implemented candidate. Windows hosts: unsupported. You can drive Maia Nodes on Linux servers over SSH: source-implemented candidate.
What will it cost?
Nothing during private alpha. Hosted plans, priced by concurrent agents: planned. We publish no prices yet. See pricing
Bring your agents to the private alpha.
What you can ask for
- Private repository access to run Maia OS from source on your own macOS or Linux machine. Admission is by invitation; no admission date is promised.
- Free use during private alpha.
- Register your interest in the design-partner programme for Maia Cloud. planned
What we ask of you
- A real repository, the Claude Code or Codex accounts you already use, and a macOS or Linux machine.
- Tell us what broke, what was missing and what you would pay for.
Register for the private alpha
We save your request and it stays pending. Email confirmation is not available yet.