# Leverage in your coding agent > Use Leverage on our servers without leaving your coding agent, so you can work with other people without changing environments. ## Harnesses | Harness | Connects over | Terminal | Desktop | |---|---|---|---| | OpenCode | HTTP | [x] | [x] | | Claude Code | Mod | [x] | [x] | | Codex | SSH | [x] | [x] | | Pi | Plugin | [x] | n/a | Every harness connects to Leverage Computer: - It hosts the SSH server, `ssh.leverage.computer`, so you don't run one. - Your workspace is the SSH user. - Sessions run in our sandbox, are shared with your team, and use accounts connected to the Leverage workspace. ## Codex Spaces show as projects, sessions as threads. ### Desktop In the Leverage desktop app, open Settings -> Integrations and click Sync into Codex. From a terminal instead: ```sh leverage login leverage ssh setup leverage codex setup # add another workspace leverage codex setup --workspace # after spaces change; quit Codex first leverage codex refresh # when you lose a device leverage ssh forget ``` ### Terminal ```sh leverage codex engineering ``` Opens the Codex CLI on the space `engineering`. ## Claude Code Plugin source: https://github.com/leverage-computer/claude-plugin The Leverage mod draws each Leverage turn with Claude Code's own cards and dialogs. Turns run in Leverage, so Claude Code needs no model sign-in. ### Desktop Claude Desktop's Code tab runs Claude Code, so the same Leverage mod works there. In Claude Desktop, open Customize -> Plugins, click Discover, then + -> Add from a repository. Enter `leverage-computer/claude-plugin`, click Sync, open Leverage and click Install. In a Code session, `/leverage login` signs in and `/leverage` opens the pane. Press a session to open it there with its whole history. ### Terminal Needs Claude Code 2.1.286 or later. ```sh # add the Leverage mod once claude plugin marketplace add leverage-computer/claude-plugin claude plugin install leverage@leverage # open a space leverage claude engineering # open an existing session leverage claude --session ``` In Claude Code, `/leverage` lists your spaces and sessions. Other Claude Code windows run a session's turns only after you open one there. ## OpenCode Leverage serves OpenCode's HTTP API, so nothing runs on your machine. Each space shows as a folder. ### Desktop In the Leverage desktop app, open Settings -> Developer tools and click Sync into OpenCode. If OpenCode is open, it closes and opens again with the workspace. From a terminal instead: ```sh leverage opencode setup ``` Mac only, OpenCode Desktop 2.0.15 or later. Sync again after you change spaces in Settings. OpenCode Desktop holds one workspace at a time. ### Terminal ```sh leverage opencode engineering ``` With no space, it opens the whole workspace. ### Other OpenCode clients Make a token in Settings -> Integrations -> OpenCode, then connect with: ```text server https://app.leverage.computer/api/opencode[/] password your token ``` ## Pi Plugin source: https://github.com/leverage-computer/pi-plugin Pi uses your `leverage login`, so it needs no token. ### Terminal Needs Node.js 22.19 or later. ```sh npm install -g @earendil-works/pi-coding-agent@0.99.1 leverage login pi install git:github.com/leverage-computer/pi-plugin pi --leverage-workspace ``` In Pi, `/leverage new` starts a session and `/leverage` opens one. ## Feature parity Each app reaches Leverage its own way, so the same session can do more in one app than in another. Legend: [x] works · [~] partial · [ ] not there · n/a the app has no such thing | Feature | Codex | OpenCode | Pi | Claude Code | |---|---|---|---|---| | **Turns** | | | | | | Live turns | [x] | [x] | [x] | [x] | | Tool cards, sub-agents and background commands | [x] | [x] | [~] | [x] | | Questions, plans and approvals | [~] | [x] | [x] | [~] | | Shared messages and images | [x] | [x] | [x] | [~] | | Stop, steer, queue and compact | [x] | [x] | [~] | [x] | | Model and context | [x] | [x] | [x] | [~] | | **Sessions** | | | | | | Session list | [x] | [x] | [~] | [x] | | Open, history and manage | [x] | [x] | [~] | [x] | | Unsupported actions refused | [x] | [x] | [x] | [~] | | **Files and tools** | | | | | | Files and outputs | [~] | [x] | [x] | [x] | | Shell and terminals | [~] | [x] | [ ] | [~] | | Git status and pull requests | [x] | [x] | [x] | [x] | | Skills and connectors | [x] | [~] | [x] | [x] | ### Details **Live turns.** The answer, thoughts, command output and tool progress appear as they happen. A stopped or failed turn keeps what it wrote, and the app shows how each turn ended. - OpenCode — **Cut-short turn:** shown on read; live only as streamed tokens - Pi — **Thoughts:** fold to "Thinking..." until expanded, in Pi's own component; **Cut-short turn:** the partial answer stays; **Done:** the working indicator clears - Claude Code — **Stream:** text and thinking; **Progress:** the status line shows the running tool and a Codex command's output tail; Leverage streams Claude's Bash output to no client; **Cut-short turn:** kept with an ellipsis; **Failed:** ends with its error as text **Tool cards, sub-agents and background commands.** Each tool call is its own card and a file edit is a diff. You can follow a sub-agent's steps on their own, and a background command, like a dev server, shows as running until it ends. - OpenCode — **Cards:** read, web and image cards untested - Pi — **Cards:** Pi's own, with Leverage renderers: diffs, todos, plan, Task steps, Read trim; **Background:** the card says running until its task settles; **Sub-agents:** steps listed inside the Task card, not a child session - Claude Code — **Cards:** Bash, Read, Edit and Write as Claude Code's own; an edit as a diff with context at its line; other tools as named stand-ins; **Background:** the status line counts them; a notice marks each start and end; **Sub-agents:** Claude Code's own agents: the Agent card, its list, each one's steps in its view; the report comes back as Claude Code's agents do **Questions, plans and approvals.** The agent asks you to pick an option, approve a plan, or allow a call: once, for the session, or always. A dismissed card can come back and an open one returns on reopen. Viewers see the wait but are never asked, and a card goes away when someone loses edit access. - Codex — **Role change:** stops asking a demoted person, but does not take the card back - OpenCode — **Sub-agent card:** sits on its own session, so Reject takes a reason; **Always:** asks the scope in a form - Pi — **Questions:** options as a card; the plan in full, and the review approves or asks for changes; **Approvals:** the dialog opens when the request arrives; `F4` asks again; only the choices the person may make; **Role change:** closes an open card when write access goes - Claude Code — **Questions:** Claude Code's own dialog; a plan review asks approve or request changes; **Approvals:** Claude Code's own dialog when the turn waits, once per window; `/leverage approvals` asks again; text under Other rejects with that reason; **Viewers:** the status line shows the wait; **Role change:** an open dialog stays; Leverage refuses its answer **Shared messages and images.** Each prompt shows who sent it and its images, and a teammate's prompt appears as soon as they send it. You can attach an image to yours. - Codex — **Images:** refuses local paths - OpenCode — **Images:** takes data: URLs - Pi — **Messages:** names, delivery state and inline images; mid-turn messages kept on reopen; **Images:** Ctrl+V and dragged files, up to 20 MB - Claude Code — **Teammate's prompt:** opens a turn under their name and gives an image count; Claude Code cannot draw them; **Images:** pasted images go with the prompt; **Others' messages:** checked every 1.5 s **Stop, steer, queue and compact.** Stop a turn. Your prompt shows at once and steers a running turn. Prompts sent while it is busy wait in a queue you can list, take back or send now. Compact a long session and see when it happened. - Pi — **Send:** shows before Leverage echoes it; **Queue:** Alt+Enter queues a follow-up and Alt+Q takes them all back; no send now; **Compact:** one card, Compacting until it ends - Claude Code — **Stop:** Esc stops the Leverage turn; **Steer:** Enter over a running turn; a teammate's steer shows as a notice; **Queue:** Claude Code's own: ctrl+x enter queues and can be taken back, Enter sends now; `/leverage queue` handles what other apps queued; **Compact:** `/compact`; a notice shows each one **Model and context.** Pick the model and effort, start new sessions on your last pick, and see how much context the session uses. - Codex — **Default:** the pick it shares with OpenCode - OpenCode — **Default:** the pick it shares with Codex - Pi — **Context:** in the footer, as Pi shows its own; **Model:** takes effect with your next message; **Default:** the model used last - Claude Code — **Context:** the meter reads Leverage's tokens against Claude Code's own window; **Model:** `/leverage model`, keeping the pick Codex and OpenCode share **Session list.** Browse sessions in the spaces you chose, page by page, and search them. The list updates live as sessions are made, renamed, archived or shared with you. Each space is a folder you can start a session in, and titles lead with their repository or #space. - Codex — **Titles:** n/a; groups threads under their folder - OpenCode — **Spaces:** `/api/opencode/` opens one space, from any local folder - Pi — **List:** scoped by Settings, searched locally, not paged; **Live:** the picker follows live; **Spaces:** F1 or `--leverage-directory`; the picker shows each session's folder; **Titles:** n/a; shows #space or the repository beside each title - Claude Code — **List:** the `/leverage` pane, scoped by Settings, searches titles, lists a space past its first eight on request; **Live:** read every 5 s; **Spaces:** `leverage claude `; the first prompt starts a session there; **Titles:** n/a; grouped under their space **Open, history and manage.** Open a session and page back through all of it; opening marks it read everywhere. Rename, archive and restore. The app names new sessions and messages itself, so a retry never makes a duplicate. - Codex — **Ids:** n/a; no id field for a new thread - OpenCode — **Rename:** stores the title alone - Pi — **History:** the latest 200 rows inline; a pager walks back 50 a page; **Read:** once, when the view opens; **Manage:** the open session, or Tab in the picker; **Ids:** message ids from the client; session ids from the server, one session per request - Claude Code — **History:** opening draws the whole session as Claude Code's own turns; **Manage:** `/rename`, `/leverage archive` and restore; **Ids:** the window names a new session and each message **Unsupported actions refused.** Actions Leverage does not support, like fork or rollback, fail with a clear message instead of breaking the app. - Codex — Fork, revert, rollback, delete, review and file writes are refused. - OpenCode — Fork, revert, rollback, delete, review, file writes, new worktrees and new repositories are refused. - Pi — Fork and `!` are refused; /tree opens `/leverage history`; /model, /resume, /new, /name and /compact go to Leverage. - Claude Code — /compact, /rename and /resume act on Leverage or point to `/leverage`; `!` runs on this machine. **Files and outputs.** Browse and read space files, see the session's sandbox files, find a file by name, and open or save the files a turn produced. - Codex — **Find:** searches space folders and the workspace root; repository and task folders answer empty; **Session files:** also roots a desktop project thread at its project - Pi — **Files:** `/leverage files`, every folder the session has, search by name; **Outputs:** `/leverage outputs` reads or saves each file - Claude Code — **Files:** `/leverage files`, read and save; before a session on the space, in a session its folder holds the space's files; **Find:** `/leverage find`; **Outputs:** `/leverage outputs`, then read or save **Shell and terminals.** Run one command in the session's sandbox, or open an interactive shell there. - Codex — **One-off:** refused; its terminals cover this - Pi — **One-off:** `!` refused; ask the agent to run it; **Terminals:** none - Claude Code — **One-off:** `/leverage run`; `!` still runs on this machine; **Terminals:** none **Git status and pull requests.** See which files changed in each repository, and the pull request for the work. - OpenCode — **Changes:** the Desktop review panel shows the folder's changes, from its newest session; a repository folder also shows its branch; **Pull requests:** `!gh pr create`, `list` and `view` open and read the session's pull request - Pi — `/leverage changes`: the branch, the diff and the pull request. - Claude Code — `/leverage changes`: each repository's changed files, what the pull request lacks, and the pull request. **Skills and connectors.** See the workspace's skills and run one, and see the connected tools, like GitHub or Slack, the agent can use. - OpenCode — **Skills:** listed, but none can run - Pi — **Skills:** `/leverage skills` lists the folder's skills and puts one in the composer; **Connectors:** `/leverage connectors` - Claude Code — **Skills:** `/leverage skills` lists; `/leverage skill` sends a prompt that loads one; **Connectors:** `/leverage connectors` Still partial: after "always", another person or a later stream shows "once". A session you start from your agent is private until you share it.