Agentic coding platform · Desktop · Built on pi
A full coding agent with a workspace around it: helpers in parallel, jobs that run for hours without you, and a design system it reads before it writes. Built on pi — your keys, any model, the meter in plain sight.
Open source, MIT · Any provider, your own key · Nothing leaves this computer
What you actually get
pi is a serious coding harness and deliberately ships without sub-agents or plan mode. Graphe is what it becomes with both, plus everything else an interface makes possible.
01
One request can become a board of pieces — each in its own copy of the project, four running at once, the rest waiting. Reviewer, researcher, and a builder that writes inside a copy of its own. Set a job going and close the window: it carries on, and you come back to a board of what finished, what's waiting, and what it cost.
02
Colours, spacing and type are read as a spec before a file is touched, so the work lands inside your system instead of on top of it. Figma frames come in as pictures and variables as tokens. Every change is checked at phone, desktop and wide, and anything that drifted from your own styles is named out loud.
03
pi does real work to keep a prompt cacheable — one stable session, cache points where the provider needs them, every read and write recorded. Graphe puts the result on screen: how much of each turn came back from cache, what the sitting cost in your own currency, an estimate before a big job, and a ceiling that ends it.
The rest of it
pi ships lean on purpose and expects you to bring the rest. Every one of these is in the window the moment you open a folder — nothing to install, nothing to switch on, nothing behind a tier.
Facts kept per project on your machine, ranked by meaning, loaded at the next start.
Reviewer, researcher, and a builder that writes — each in a copy of its own, several at once, under a budget.
Ships, needs work, or do not land — findings ranked, with file and line, and one press posts them to the pull request.
Attaches lldb, dlv or debugpy to a stuck program. Reads frames, steps, evaluates.
Your MCP servers plug in through one file. Started on use, stopped with the sitting.
An arxiv address comes back as words — title, authors, abstract, then page by page.
Mermaid fences become pictures in your own palette, or stay code when they can't.
A file that changed underneath is refused before a single byte is written.
Frames as pictures, variables as tokens, and drift detection that keeps you in step.
Phone, tablet, desktop and wide — photographed, so you never decide from one size.
Every turn accounted for, and a split that separates your work from our own retries.
@skill brings in craft you installed; /command expands a prompt you wrote.
Queue it behind the turn or steer it into the turn. Asked quietly, never an error.
The whole timeline drawn out — short ids, parents, branches — for when you want it.
Walk it, see what changed, open anything in the editor you already use.
Name a conversation, mark a moment worth returning to, fork a direction and try both.
Goes at the same thing finish side by side, with what each cost. Keep one; the rest are thrown away.
It names the files a change would touch, and what it would take, before it makes it.
Folders by size, what each reaches into, where the styles are — read before a request is broken up.
One file per check in .agents/checks — a project says what every review must look at.
The whole record under a name of its own, opened straight away — no going back, no losing the direction.
The page lives in the window
Not a screenshot of your work, and not a tab you go and find. The running project sits in the window next to the agent building it — which is what makes the four things below possible at all.
A dev server, an API, a watcher — several at once. They keep running after the turn that started them and say where they can be reached, with a band above the composer showing what is up and a press to stop it.
Click anything and write what should change, right where it is. It goes to the agent as an instruction carrying the element and the line it was written on — no describing which button you meant.
Which component made it, which of your tokens it uses, what drifted from them, and where it was written — read off the running page rather than guessed from the source.
Phone, tablet and desktop without resizing anything. One press hands the same address to Chrome when you want the devtools you already know.
How a sitting goes
No config file, no setup wizard. Open a folder and it is a project — recent ones sit on a shelf with what each cost you last time.
Type it, paste a screenshot of it, or drop in a Figma frame. Speak it if your hands are busy. There is no syntax to learn.
A numbered plan, an estimate of what it will cost, and a wait for “Go ahead”. Small jobs just get done.
The file tree marks what changed. The rail names what it is doing right now, what it looked up, and what it has made so far.
Before and after, at phone, desktop and wide. Let it in, or set it aside — setting aside keeps the work reachable rather than throwing it away.
A write-up with the before-and-after pictures in it, a properly named line of work, and a request ready for whoever reviews. Or a page of what changed for somebody who is not a developer at all.
The foundation
pi is a serious coding harness: any provider, any model, real extensions, and prompt caching engineered properly rather than hoped for. It ships deliberately without sub-agents or plan mode, and it ships in a terminal.
Graphe is everything around it — sub-agents and plan mode among them, plus the window, the guard, the version history, the design panel, the memory, the money and the handover. One module owns every pi import, so an upgrade breaks one file rather than fifty.
pi gives you
Graphe adds
Work that outlasts your attention
A job that takes four hours does not need you watching it for four hours. Set it running in a copy of your project, close the window, go to lunch. It carries on.
Background work · 3 pieces
On step 4 of 9 — rewriting the cards against your spacing scale.
It wants to add something from the internet that runs its own setup steps. It has not.
Eleven pages, each photographed before and after. $0.41.
Two, three, four jobs run at the same time without treading on each other, each in its own checkout, and the work comes home when it is done. Running at once is the point, not a queue.
Some work should happen without being asked — a nightly pass over the design system, a weekly check that nothing drifted. Set it once.
Hand it a PRD and it comes back as a build plan with acceptance and a tracked checklist. Say “get on with it” and it runs the whole thing without stopping to ask.
Long jobs are where money goes quietly. There is an estimate before it starts, a running total while it works, and a ceiling that ends the sitting rather than the month.
Both audiences, one app
A designer never has to learn what a branch is. A developer never has to guess what just happened. It is one switch, in the row where your hand already is.
What you read
What it ran
Sent. Your team can pick it up from here.
gh pr create --head feat/pricing-cards-2f9x
Four changes are waiting to be saved.
git status --porcelain
Saved before a big change — you can put it back.
git commit -m "save point before restore"
The line of work this sits on.
build-from-main → origin/main
It read your colours and sizes before it started.
read src/styles/tokens.css · 66 properties
One switch in the composer moves every line in this project from the left column to the right. Nothing is hidden from the person who wants it, and nothing is imposed on the person who doesn't.
Your code, your keys and your pictures stay on the machine. Exactly one feature in the whole app sends anything anywhere, it says so before it does, and it refuses outright if a private key is written into what would be sent.
deny by default · tested against prompt injection · a snapshot before anything destructive
An estimate before a big job, a running total while it works, and an end-of-sitting split that shows what your work cost and what our own retries cost. In your currency, not in tokens.
your key · your account · no subscription in the middle
Where it is up to
Everything on this page works today — it is what the app does, photographed from the app. What beta means here is that the rough edges are mine to find and yours to report: the interface still moves, the first release is recent, and the fastest way to change something is to say so. The whole thing is MIT, so nothing about it is a black box.
Apple silicon and Intel · macOS · bring your own model key