Exponential
DownloadSign inGet started free

Coding agents

Hand issues to a coding agent from the desktop IDE: Claude Code, Codex, or pi. It plans, implements, and opens the pull request. On your machine, on your own agent subscription.

Get the desktop app
01How it works

How it works

The desktop app is the client that runs coding sessions. When you start one, it hands the issue to your agent running locally: Claude Code, Codex or pi, on your machine, your checkout, your own agent subscription. Nothing executes in a cloud sandbox, and your code never routes through Exponential's servers.

The server's role is deliberately small:

  • It mints short-lived, repo-scoped GitHub tokens through the team's GitHub App connection, so the run can push without any long-lived credential on disk.
  • It opens and links pull requests when the agent calls the built-in MCP tool, then tracks the PR through to merge and completes the issue.

Because the agent is local, coding is unmetered: no plan gates it, on any tier.

02Setup

Setup

  1. Install the desktop app from the download page (macOS, Windows, or Linux).
  2. Have git plus whichever agent CLIs you use on your PATH (claude, codex, pi), each signed in to its own account. The app checks all three but only requires the one you pick for the run. That's the entire dependency list: no gh, no tokens to paste.
  3. Sign in to app.exponential.at or your self-hosted URL.
  4. Open a repo-backed board. The IDE clones the repository automatically. (Connect a repo in Team settings → Repositories if you haven't. See Getting started.)

Under the hood, the launcher wires a scoped MCP config into the run carrying a personal API key. That's how the agent drives Exponential itself: updating issue status, posting comments, and opening the PR, all as tools.

03Start coding

Start coding

Hit Start coding on any issue, or check several on the board and start them together. One dialog covers both:

⎇master
All Issues
In Progress1
EXP-8Live-steer terminal reconnectDSJul 9
In Review1
EXP-11Issue board keyboard navigationJul 15
Todo1
EXP-12Attachment paste uploads
Backlog2
EXP-9Issue board keyboard polish
EXP-13Widget screenshot annotationsfeedback
Done2
EXP-5Side-by-side diff viewDS
EXP-7Terminal exit-code badges
EXP-8
EXP-8
Live-steer terminal reconnect

When the steer relay drops a WebSocket mid-session, the activity feed goes stale and never recovers. Reconnect with exponential backoff and resume the pty stream from the last acked offset.

Repro: kill the relay while a Claude session is streaming. The viewer freezes until a full page reload.

Same reconnect contract as EXP-5. Ping @Danny Strähhuber once the relay patch lands.

0 images
Activity (2)
DS
Danny Strähhuber3 hours ago
Backoff should cap at 15s. The relay load balancer kills idle sockets after 60s anyway.
Danny Strähhuber changed status to In Progress· 2 hours ago
Status
Priority
Assignee
Labels
Due date
BoardExponential

Live demo: click Start coding on the issue to open the dialog.

  • An agent tab strip: Claude Code, Codex or pi. The strip narrows to the CLIs the app finds installed.
  • A searchable multi-issue picker. Check one issue for a single run, two or more for a batch.
  • Model and Effort pickers, per agent. Each agent offers its own models and its own effort vocabulary (Codex calls it Reasoning, pi calls it Thinking).
  • Skip permissions (Claude and Codex). Off leaves the agent in its own guarded auto mode, on hands it a full bypass.
  • Dynamic workflows (ultracode), Claude only. Lets the run organize its own workflow; it takes over the effort setting.
  • Plan mode, Claude and pi. It proposes a plan you approve before it touches code — in the terminal, or from the plan card in the session view on web and mobile.

Defaults are per agent, not per mode: single and batch runs prefill identically. Out of the box that's plan mode on, ultracode off and skip permissions off. Change them under Settings → Agents on the desktop, per agent, and every future run starts from your values. Every run uses exactly one repository.

The same dialog has an Actions tab: the team's saved prompts, run with the same agent, model and effort pickers. See Actions.

04Single runs

Single runs

One issue, one branch, one PR:

  1. The app creates a git worktree on a fresh exp/<IDENTIFIER> branch. Your main checkout stays untouched, and several runs can work the same repo side by side.
  2. The agent opens in the embedded terminal, seeded with the issue. With plan mode on it plans first; you approve before implementation starts.
  3. It implements, commits, pushes, and opens the pull request itself via the built-in MCP tool. The server opens the PR through the GitHub App and links it to the issue.
  4. The issue flips to In Review and merging the PR completes it to Done. Both targets are configurable in Team settings → Statuses.
05Batch runs

Batch runs

Check two or more issues in the dialog (or use the board's bulk-select bar) and you get a batch run: one agent session given all the issues at once, working on one shared branch (exp/batch-<id>), ending in one combined PR linked to every issue in the batch. Merging that PR completes them all.

The batch is deliberately loose. The issues go over as a list and the agent organizes the work. Overlapping issues are fine, and often the point.

When to batch

  • Related fixes: five small bugs in one screen make one coherent session and one reviewable PR.
  • Sweeping changes: a rename, an API migration, a copy sweep across the codebase, filed as several issues.
  • Feedback triage: bulk-select a morning's worth of widget reports and clear them in one run.
Batch sizeA run takes up to 30 issues, and the dialog shows a cost hint on large batches. Every checked issue adds to the prompt, so big batches are token-hungry.
06Watch & steer

Watch & steer

The embedded terminal is a real PTY, not a log view. Type into it any time to answer a question or redirect the run, and hit Stop to end the session.

While a session runs, your other devices see it live: the Agents view on web and mobile shows the running session with a live activity feed, and you can send steer messages from your phone. The agent picks them up mid-run.

07Review & merge

Review & merge

You never have to leave the IDE to land the work:

  • The issue's Changes tab shows the branch's full diff against the default branch, side-by-side.
  • The Reviews list in the sidebar collects the team's open PRs, across every board. Open one, read the diff, and merge from right there. The linked issues complete on merge. A merge that hits conflicts offers the Fix merge conflicts action.

Prefer GitHub's review UI? The PR is a completely normal pull request. Review and merge it there and the issue completes just the same.

08The git IDE

The git IDE

Around the coding flow sits a git IDE. Open a board and its repository clones automatically. That clone is the trunk, kept level with the default branch by a background sync. Coding runs work in their own worktrees, off to the side.

⎇master
Source Control
⎇master
exp/EXP-8worktree
↑2
exp/EXP-11
↑1
exp/EXP-5
Source Control
1 local change
History
feat(desktop): JetBrains-style IDE shell
niach · 3 hours ago
fix(ios): show compose button only inside a project
niach · 5 hours ago
fix(mobile): Android issue-open crash
niach · 9 hours ago
feat!: masterplan v5 — per-seat billing
niach · 11 hours ago
apps/web/src/components/steer-terminal.tsx
+24-6
@@ -42,10 +42,28 @@ export function SteerTerminal({ sessionId }: SteerTerminalProps)
42 const socket = useRef<WebSocket | null>(null)
42 const socket = useRef<WebSocket | null>(null)
43
43
44 useEffect(() => {
44 const retries = useRef(0)
45 const ws = new WebSocket(steerUrl(sessionId))
45 const reconnectTimer = useRef<ReturnType<typeof setTimeout>>()
46 ws.onmessage = (e) => term.write(decode(e.data))
46
47 socket.current = ws
47 const connect = useCallback(() => {
48 return () => ws.close()
48 const ws = new WebSocket(steerUrl(sessionId))
49 }, [sessionId])
49 ws.onmessage = (e) => term.write(decode(e.data))
50 ws.onopen = () => {
51 retries.current = 0
52 }
53 ws.onclose = () => {
54 const delay = Math.min(1_000 * 2 ** retries.current, 15_000)
55 retries.current += 1
56 reconnectTimer.current = setTimeout(connect, delay)
57 }
58 socket.current = ws
59 }, [sessionId])
60
61 useEffect(() => {
62 connect()
63 return () => {
64 clearTimeout(reconnectTimer.current)
65 socket.current?.close()
66 }
67 }, [connect])
50
68
51 return <TerminalView ref={mount} onData={handleInput} />
69 return <TerminalView ref={mount} onData={handleInput} />

The editor is read-only by design: changes arrive as pull requests, not local commits. The files rail browses the trunk, Source control walks its commit history and renders any commit's diff side-by-side, and an issue's Changes tab diffs its branch against the default branch. The one write affordance is an escape hatch: discard local changes and hard-reset to the remote, behind a confirm.