Drop in an idea. Shape the plan with AI. Let the agents build it.
PhanOS is a project OS for AI agents in Claude Code. It turns your idea into a plan you refine in plain words, then hands it to a swarm of low-cost agents that write the code, test it and get checked by an independent verifier. The expensive model only plans and decides.
Built around our proprietary Cyphor Engine™, PhanOS offers a wide range of tools, including a completely self-maintaining and accurate documentation base. It cuts the agentic cost of mapping, navigating and working on a codebase, a complex database, or any system that benefits from self-updating knowledge and staleness checks.
Runs inside Claude Code on Windows and Linux. Bring your own Claude subscription or API access; PhanOS includes no model access or tokens.
Invite-only beta. Testers use Pro free for the whole beta.
What PhanOS does for you
- From idea to working code, on autopilot.
- Describe what you want. PhanOS drafts a plan, you iterate on it in plain words, and once you approve it, agents build it step by step while an independent verifier re-runs the checks and reports what failed.
- Nothing is built before you approve the plan.
- A project memory that keeps itself current.
- Modelled on how your eyes and brain focus: agents see the part they work on in full and the rest as short notes. Every note is stamped with the code it describes, flagged the moment that code changes, and refreshed as the work goes on. It lives in your project, on your own machine. No more writing documentation by hand.
- Every note carries a fresh or stale verdict, checked against the file it describes.
- Expensive models plan. Cheap agent swarms execute.
- The strongest model writes the plan and makes the hard calls. Swarms of small, low-cost agents do the typing, one file and its test each, under locks that stop two agents from editing the same file. You pay top rates for judgement, not for keystrokes.
- A file is locked to one agent at a time; a second write is refused.
How it works
- Install. One command in a terminal. Sign in once in your browser.
- Plan. Tell PhanOS your idea. It drafts a plan; you push back, it revises, until the plan says what you mean.
- Build. Start the run. An orchestrator slices the plan into steps, squads of agents write the code and its tests, and an independent verifier checks the result.
Four modules, one project OS
Cyphor keeps the memory and the locks, Phanes runs the crew, Graft moves modules between projects, and the PhanOS UI lets you watch and steer all of it.
- The memory and the locks
Cyphor
A hash-stamped note for every file, so agents know what to trust, and leases so they never collide.
- Move a module with its tests
Graft
Copies a module with its tests and the code it depends on into another project. Nothing in it runs on load.
- The crew and the procedure
Phanes
A planner on the strongest model, squads of low-cost agents that write the code, and a verifier that never fixes.
- Watch and steer, per project
PhanOS UI
A desktop app that shows every agent and lock as it happens, and lets you take a command back before it runs.
Cyphor
The memory and the locks
Cyphor is your project's memory: a short, hash-stamped note for every file and a fresh-or-stale verdict before an agent trusts one. Its locks, called leases, give each agent its own files, so agents working in parallel never collide.
- Agents find their way by the notes instead of opening file after file.
- They know what a file does and what depends on it without opening it, so they open only the files they have to edit.
- They stop asking you questions the codebase can already answer.
src/auth/session.tsCreates and rotates session tokens; read by middleware.tsfresh3f9a1csrc/billing/webhook.tsVerifies the provider signature, then updates the subscriptionstale, file changedc41d9bsrc/billing/retry.tsRetries failed deliveries with exponential backoffleased by agent 29be210docs/architecture.mdService boundaries and data flowstale11fd07
- A verdict before they act
- Each descriptor is either fresh, so the agent trusts it, or stale, so the agent opens the file. Documentation that knows when it is out of date can be relied on.
- Leases instead of merge fights
- Before writing, an agent claims the area it needs. Other writes there are refused at the tool call and again at commit, so parallel agents cannot collide.
- A receipt for every change
- When an agent finishes it declares the files it changed. PhanOS compares that with what moved on disk, and tells you which test results no longer hold.
Graft
Move a module with its tests
Take a working module from one project into another, with its tests and the code it depends on, already mapped by Cyphor. Nothing in a graft runs when you load it.
- The code, the tests and the in-project dependencies are copied byte for byte, with a cited description of what the module does and needs.
- That description is read as data, never as an instruction, so loading a graft cannot run foreign scripts.
- The module
- Its code, its tests and its in-project dependencies, copied byte for byte.
graft.json- A manifest of where the module came from and what it needs.
GRAFT.md- A cited description of its purpose, API surface, dependencies and assumptions, written by an agent.
- Cyphor hashes
- Its content hashes and Cyphor mapping, so integrating it into a new codebase saves tokens, time and money.
How it connects
- Phanes
- It uses Phanes to extract a module, and through the skills it gives Phanes, the module drops into another project and is understood from the start.
- Cyphor
- It takes a module together with its Cyphor hashes and notes.
- PhanOS UI
- Generate and load commands are a click away in the PhanOS UI, so you can create a graft or load one into your codebase without typing a command.
Phanes
The crew and the procedure
Phanes is the crew that does the work: a planner on the strongest model, an orchestrator that slices the plan, squads of low-cost agents that write it, and a verifier that never fixes what it checks.
- Work is sized before it is sent out, and the cheapest tier that can do a job gets it.
- Several agents work at once, within a ceiling, each in its own non-overlapping scope.
- An independent verifier re-derives the results at the close. Its output is a graded flag, never a fix.
- Every finding carries an ID, a severity and a quoted source line, so it can be checked later.
- A self-improving memory: Phanes learns how you work and what you prefer, and remembers it.
| Role | Model tier | Job |
|---|---|---|
| Planner | strongest | Writes the plan with you and makes the hard decisions |
| Orchestrator | strong | Slices the plan into steps and sends each to the right squad |
| Squad lead | mid | Splits a step into one-file slices and reviews each one |
| Squad worker | cheapest | Writes one file and its test, under a lock |
| Verifier | mid, independent | Re-runs the checks at the close and flags problems; never fixes them |
PhanOS UI
Watch and steer, per project
A desktop app for Windows and Linux that shows every agent and every lock as it happens. Queue a command with a short timer so you can take it back, and stop one agent without stopping the rest.
- Every agent and every lease at a glance, with sub-agents nested under their session and several sessions per project.
- Commands wait in a queue with a timer you can change, so you can take one back before it runs.
- Stopping a single sub-agent revokes its lease. A stop button halts the whole turn.
- A live 3D map of the code, a leases panel showing region, cluster and cell, and a file browser.
- A fully customisable toolbar that holds PhanOS's own commands, other plugins' commands or ones you create.
- Panels collapse, resize and can be customised: tell an agent the feature you want in a window, and it builds it for you.
Coming next
- Collaborative mode
- Other people connect their own CLI tools to your codebase, or to one on a server, and work on it live with you. The locks still keep two agents off the same file.
- A library of grafts, plans and prompts
- One place to share module and app grafts, plans and prompts for free, or to buy and sell them.
- Cyphor templates beyond coding
- Cyphor's engine adapted to knowledge bases outside code, from clinical documentation to accounting and law: every change recorded, every lookup checked fresh or stale. Talk to us about Cyphor for your field.
Plans
PhanOS Basic is free and keeps your agents from false or colliding results. Pro makes them fast. Pro Budget is all of Pro for 24 active hours a week. Business is Pro for teams. Compare plans
Who builds PhanOS
I'm Founder Name, an LLM enthusiast from Austria and a former IBM employee. After years of building with AI agents, iterating, breaking things and starting over, I'm turning what worked into my own business. PhanOS rests on one idea: let the expensive model think, let cheap swarms do the work, and keep your project's memory on your own machine.
Install in a minute
In a terminal
npx -y github:Aloim/PhanOS-ClosedBetaMCP#v0.3.2 install It signs you in through your browser, installs PhanOS and registers it with Claude Code. Every install needs an account, Basic included.
Then open Claude Code in your project folder and run /phanos:install. Full install guide