PhosphorInstall

A desktop surface for the pi coding agent

Same agent.
Your surface.

Your models. Your subscriptions. Your extensions.
The agent, the code and the result in one window.

Install Phosphor Explore the surface
macOS / Linux / WindowsOpen source · MIT
SURFACE / VARIABLE
π
pi coding agentpi --mode rpc
CONSTANT
ToolsSkillsMCPArtifacts
Native providersAPIs + account sign-in
Claude Codevia pi-claude-cli

pi owns the loop, the project context, the skills and the tools. A provider extension can put Claude Code underneath it.

How Claude runs under pi ↗
BUILT BY ENGINEERS / FOR ENGINEERS

Not another agent loop. A place to work with the one you already chose.

01 / IDE view

Keep the session.
Change the surface.

Conversation first, like Claude Desktop. Task first, like the Codex app. Or an editor next to the agent. The layout is a preference. The engine is not.

Choose a layout study for the same Phosphor session
Same session / 3 arrangements
Phosphor / actual captureExplorer + Monaco ↔ transcript
The real Headroom Optimization session: file explorer and Monaco with TopBar.tsx docked left; Claude Opus 5 transcript and results table right; composer showing pi-claude-cli, Max thinking and 35% context usage.
Claude Desktop–like / layout studyConversation first. Work beside it.
Explorer
Same transcript + composer
Same Monaco editor
Codex app–like / layout studyProject in view. A focused workspace.
Explorer
Same transcript + composer
Same Monaco editor
UNCHANGEDpi’s agent loop+your extensionsLayout moves. Work stays.

Arrangements, not integrations. The two app-inspired views are crops of the one capture above, rearranged. They are not screenshots of Claude Desktop or Codex, and not presets Phosphor ships.

What ships: one pane, docked left or right, resizable, or fullscreen. Saved per session. How panes work ↗

Headroom Optimization · Claude Opus 5 via pi-claude-cli · Max thinking · 35% context at capture. Open the full IDE capture ↗

01

The project is right there.

Browse the tree and edit in Monaco without leaving the conversation.

02

The reply has structure.

Text, tables and tool activity in a readable transcript, not a terminal dump.

03

The controls stay close.

Model, thinking level and context usage sit beside the prompt.

02 / Models & accounts

Use the plan
you already pay for.

Sign in. Don’t paste keys. Every account login pi can drive is a button in Settings, next to every provider you have installed.

SUBSCRIPTION

ChatGPT

Plus or Pro

pi’s native Codex OAuth. No CLI bridge in the way.

SUBSCRIPTION

Claude

Pro or Max

The Claude Code provider drives your signed-in Claude Code CLI.

SUBSCRIPTION

GitHub Copilot

Copilot subscription

Sign in through pi. Enterprise Server uses pi’s terminal login.

SUBSCRIPTION

Kimi

Kimi For Coding

Sign in with your Kimi For Coding plan through pi.

Plan limits and billing are your provider’s, not ours. Claude subscription sessions run through @saccolabs/pi-claude-cli, not native Anthropic OAuth. Sign-in routes ↗

Not tied to one provider

Pick the model
for the next turn.

Search what you have access to. Star what you use. Switch mid-session and the conversation comes with you. Thinking levels appear when the model has them.

API keys and custom or local endpoints work too. The list is whatever your pi install can reach.

Model controls ↗
Phosphor’s searchable model menu over a real conversation, grouped by provider.
The model menu, in the composerReal session ↗
PI SPEAKS TO
  • Anthropic
  • OpenAI
  • Gemini
  • Vertex AI
  • Azure OpenAI
  • Amazon Bedrock
  • Mistral
  • Groq
  • Cerebras
  • xAI
  • OpenRouter
  • Cloudflare AI Gateway
  • Vercel AI Gateway
  • Custom / local endpoints
Provider overview ↗
Thinking levels and sign-in, in the app +
The thinking-level menu above the composer in a real Phosphor session.
Effort is a model controlReal session ↗
The Accounts settings screen with subscription providers and sign-in status; account email is redacted.
Provider sign-in statusReal session ↗

03 / The gateways

Know what’s connected.
Know what it costs.

Accounts run out. Tool schemas take space. Long conversations fill the window. All three are facts on screen, not surprises at the end of a turn.

A / ACCOUNT

Which account
is this lane using?

Keep several Claude logins. Send new sessions to one, in order, or round-robin. Open an account to see its usage windows and which sessions are spending it.

A running session keeps its account. Moving it respawns from the saved session, and the next turn re-reads the thread.

Account gateway ↗
M / MCP

Connect tools.
Load detail on demand.

One proxy tool per server. The agent fetches a tool’s schema when it needs it, instead of carrying every schema in every request.

pi→MCP gateway→Server tools

Direct tools opt out of that, and pay for it. OAuth and tokens live in the adapter, never in Phosphor.

MCP gateway ↗
C / CONTEXT

Full of what,
exactly?

Open the meter: messages, system prompt, tools and MCP schemas, with token, cache and cost counts beside them.

pi’s total AuthoritativeComponent sizes EstimatedProvider overhead Unmeasured

Claude sessions add the account’s usage windows and plan limits. Missing telemetry shows as missing, never as zero.

Read the context meter ↗
A real context popover showing estimated composition, MCP server attribution, tokens, session cost and Claude plan usage.
Context, with the source of each numberReal session ↗

Tools from your actual stack

Your services.
In the same session.

Mount a curated connector, or add any MCP server by URL or command. Inspect it, sign in, reconnect and test it. No model runs, so no tokens are spent.

  • Linear
  • Notion
  • Braintrust
  • Datadog
  • Supabase
  • Questrade
  • Fellow
  • Slack

Some services want more from you. Slack needs your own registered app and its scopes.

Connector setup and permissions ↗
Open the connector settings capture +
Phosphor’s real Connectors settings screen with available MCP services.
Connectors are configuration, not a second agentReal session ↗

04 / Lanes, not loose chats

Several tasks.
Separate branches.
One place to look.

A lane is a session, its branch, its worktree and its PR on one row. Every live session is its own pi process. None of them manages the others.

01Session→02Branch→03Worktree→04PR status
Phosphor home, showing the project’s real lanes and the new-session composer.
Home is where you see what needs youReal session ↗
01

Start in a separate checkout.

A new task gets a worktree and a branch off the remote trunk by default. Pick a prefix, let the first turn name it, or work in the main checkout on purpose.

02

See the next action.

Home groups lanes by what they need: waiting on you, ready to merge, needs a push, in review, running. The ledger shows spend, tokens and live processes.

03

Keep Git in sight.

Search by title, branch or PR. See checks and review state. Update from trunk, then merge locally when it is ready.

The board is drawn from state you already have. No model runs to organize it. PR badges read gh and never write. The merge is local, not a GitHub merge. Lane behavior ↗Worktree safeguards ↗

05 / The transcript

Read the work.
Not just the answer.

Text streams in. Thinking gets its own block. Tool calls become steps you can open. An edit shows its diff, not a sentence saying it went fine.

A real agent turn with the activity expanded to show an edit diff and the Changes pane alongside.
The edit, its diff and the files it changedReal session ↗

A transcript you
can inspect.

  • Open the activity. Arguments, output, exit codes. Tools Claude Code ran itself show up as steps too, with what came back.
  • Review what changed. Per-file diffs against the session baseline. Revert a file from Changes.
  • Read rich output. Tables, highlighted code, Mermaid, charts and KaTeX render as content.
  • Keep your place. Scroll back while it works. Jump to the tail when you are ready.
Transcript behavior ↗

A small input. Several ways in.

Keep working while it works.

Enter steers the running turn. A follow-up waits for it to finish. Two queues, kept apart. Drafts survive session switches and restarts.

@
Mention a workspace file
/
Commands, prompts and skills
!
Run a shell line in the conversation
!!
Run it without adding it to model context
File mentions and commands, in the composer +
The @ file mention menu, resolved against the real workspace.
Reference the file, not a pasted guessReal session ↗
The slash-command menu listing commands in a real Phosphor session.
pi commands and extension commandsReal session ↗

06 / The rest of the desk

Use your hands, too.

The agent is not the only one allowed to edit a file or run a command. The tools beside the conversation are real tools.

FILES / MONACO
Workspace explorer and Monaco editor docked to the right of the transcript.
Explorer + editor tabsReal session ↗

Open. Read. Edit. Save.

Create, rename, move, copy and import. Multi-select and drag. Monaco tabs, dirty markers, and a conflict bar when an outside change meets unsaved work.

Files and editor details ↗
TERMINAL / PTY
A real terminal tab open beside the Phosphor conversation in the workspace.
Your shell, next to the sessionReal session ↗

Run it yourself.

Real shell tabs with search, clipboard and scrollback, separate from the agent’s bash. “Run in terminal” pastes the command. You press Enter.

Terminal behavior ↗
Give a pane the whole session region +
Monaco and the file explorer fullscreened in the main session area, with the sidebar still visible.
Fullscreen does not discard your split layoutReal session ↗

07 / Artifacts

The result deserves
its own surface.

A plan, a diagram or an interactive page should not scroll away into chat history. Artifacts give deliverables a versioned pane of their own.

A real long-form document open in the artifact pane beside the session that created it.
A deliverable you can open, read and reviseReal session ↗
v1 Create→v2 Edit↔Diff Compare

HTML, Markdown, SVG, Mermaid, code and charts. Diff any two versions. Reopen the session and they are back. The Artifacts page indexes every open session.

Model-authored HTML runs on an opaque origin with no network. That protects the app from the document. It does not sandbox the agent’s tools. Artifact tools and versioning ↗

08 / Built on pi, extended by you

The surface is flexible.
So is what runs in it.

Install pi packages from npm, Git or a local path, global or per project. Tools, skills, prompts and themes all arrive through the same system.

NOT A FORK OF THE ENGINEPhosphor
↕ typed IPC
Electron main
↕ JSONL / stdio
pi + extensions

Phosphor talks to pi over RPC and imports none of its code. The bundled extensions run inside each session’s pi process.

Claude Code can run under pi.

The provider drives the official Claude Code CLI and streams it back into pi’s session. pi supplies project instructions, skills and extension tools. Claude keeps its native tools, your subscription and one persistent process.

The Claude provider boundary ↗

Skills get their own page. Web access, MCP and subagent packages are one install away.

Read the extension contract ↗

Six extensions ship with Phosphor

01

artifacts

Versioned deliverables in their own pane.

02

context-breakdown

Estimates what is filling the context window.

03

headroom

Losslessly shrinks big tool results through a local proxy. Opt-in.

04

mcp-status

Per-server MCP state, straight from the adapter.

05

tool-name-guard

Repairs a malformed tool name before it bricks the thread.

06

worktree-paths

Refuses a file tool that wanders into the wrong checkout.

09 / Pick up where you left off

Real sessions.
Room for your habits.

A session is a pi session file, not a format invented for a UI. Phosphor adds the controls to move through it and a layout that remembers how you work.

HISTORY

Take another branch.

See the session tree. Jump to a point, bookmark it, fork it or clone it. Export the conversation as HTML.

CONTINUITY

Leave. Come back.

Resume saved sessions. Panes and drafts stay where you left them. Background sessions keep streaming while you look elsewhere.

CONTROL

Manage the long run.

Steer, queue follow-ups, stop, compact, auto-retry. Session files are written when a turn ends, not on every token.

Choose an appearance capture

Dark. Light. Your eyes.

Light, dark or system. UI scale, fonts, and separate chat, editor and terminal sizes.

Phosphor’s dark graphite theme on a real artifact session.
Graphite and amberReal session ↗
The same Phosphor artifact session in the light theme with cool paper surfaces.
Cool paper and emberReal session ↗
Sessions and pane persistence ↗Appearance settings ↗

10 / Run it on your machine

Open a folder.
Give it a task.

Install pi, then Phosphor. Sign in, pick a model, open a folder, start a session.

Download a release

MIT licensed. Provider subscriptions and API usage are separate.

01 / THE ENGINENode ≥ 22.19
npm install -g @earendil-works/pi-coding-agent
02 / THE DESKTOP — macOS & Linux
curl -fsSL https://github.com/agustinsacco/Phosphor/releases/latest/download/install.sh | sh

The installer verifies the download against the release checksums. Piping to sh is a trust decision, so the script is short and public. Read install.sh ↗

Setup, updates and a few useful limits +

pi must be on PATH. Until it is, Phosphor shows a setup screen with the command. Sign in by running pi in the built-in terminal and using /login, or put keys and endpoints in ~/.pi/agent/.

Claude is a separate package. Subscription sessions need the signed-in Claude Code CLI and @saccolabs/pi-claude-cli ≥ 0.7.1. Provider setup ↗

Updates match the install. Packaged apps check at launch and every 30 minutes. AppImage and eligible macOS installs restart to update. Package-managed or read-only installs link to the release. Let the current turn finish first. Update paths ↗

A coding workspace, not a cloud service. No sync, no orchestrator agent. Monaco is an editor, not a language server or a debugger. Product scope ↗

The feature map, with sources +

Current behavior is documented under docs/. The layout studies above illustrate it; they do not add features.

Transcript & composer ↗

Streaming text, thinking, tool steps, rich output, file mentions, shell lines, steering and follow-ups.

Files & terminal ↗

Explorer transfers, Monaco tabs, dirty-buffer conflicts. A real shell beside the chat.

Sessions & layout ↗

Independent concurrent sessions, per-session pane placement, fullscreen, global pages.

Install & updates ↗

pi on PATH, per-platform release assets, update checks that match how you installed.