Keep every agent in one pen.

corral is a terminal runtime for coding agents. Run Claude Code, Codex and opencode side by side, see at a glance which one is waiting on you, and keep them running when you close the laptop.

$ curl -fsSL https://bottercode.github.io/corral/install.sh | sh

macOS and Linux · MIT · then run corral · other ways to install

~/src/api — corral

^b ? keys

Playing back corral's real layout.Click an agent in the sidebar, or answer the blocked one.

agent CLIs recognised on sight

agents on screen side by side

config files to get started

binary for macOS and Linux

01 what it does

Less tab-hunting. More landing.

Running several agents breaks down fast: one sits blocked in a tab you aren't looking at, closing the terminal kills the work, and two of them edit the same files. corral fixes all three.

triage

The one that needs you comes first.

The sidebar sorts agents by what they need: blocked and finished on top, then the busy ones, then the quiet ones, each with how long it has waited. Agents you aren't watching ring the bell and send a desktop notification.

How the sidebar works →

sidebar · by need^b b next blocked

NEEDS YOU  2
2 fixer             ◆ blocked 4m
3 docs                 ✓ done 1m

WORKING  1
1 api                       ⠋ 32s

QUIET  1
4 tests                      idle

corral
fixer (p2) needs your input

worktrees

A branch of its own for every agent.

^b w starts an agent in a fresh git worktree, so parallel agents never edit the same checkout or break each other's builds. The sidebar shows each one's branch, its pull request, and how much it has changed.

Worktrees in depth →

~/src/apizsh

$ corral new --worktree --branch fix/login -- claude
p5 started in worktree fix/login

▍5 claude                    ⠋ 2m
▍   Fix the login redirect
▍   api · claude
▍   ⎇ fix/login +42 −7 #118

review

Read the diff. Land it.

^b D opens what the agent changed since its branch started, committed work and new files included. Commit it, merge it into the branch it came from, or throw it away, without leaving the terminal.

Diff review →

diff fixer ⎇ fix/token-refresh → main

▍M src/auth/refresh.rs        +12 −3
 A tests/refresh_race.rs      +31 −0

@@ -41,6 +41,9 @@ impl Refresher {
+     let _guard = self.lock.acquire().await;
-     if self.expired() {
+     if self.expired() && !self.in_flight() {

 2 files +43 −3 · 1 commit · 2 uncommitted 
c commit  m merge  x discard  r refresh

always running

Close the lid. They keep going.

A small background server owns every agent's terminal; the UI just attaches to it. Detach, lose SSH, come back from another machine. If corral itself stops for a reboot or an update, it offers to bring every agent back into its conversation.

Restoring after a stop →

welcome back

corral stopped with 3 panes open. Bring them back?

  fixer   api ⎇    resumes its conversation
  api     api       continues its latest conversation
  zsh     website   shell

 Enter bring them back
 n     start fresh (worktrees stay on disk)
 Esc   decide later

Put work away, not out.

Done with an agent for now? ^b a archives it: the process ends, but its folder, worktree and conversation are kept, even across restarts. ^b A lists them and brings one back where it left off.

Archiving →

archived2

▍ fixer  api ⎇    2h ago  resumes its conversation
  docs   website  1d ago  continues its latest conversation

 ↑↓ pick  Enter bring back  x forget  Esc close

scriptable

Agents can drive it too.

Everything the UI does is also a command, with --json where it helps. Hand a task to an agent from a script, wait until it needs you, then read its screen. Hooks for Claude and Codex let them report their own state.

The CLI →

task.shsh

p=$(corral new --worktree -- claude)
corral send "$p" "add input validation" --enter
corral wait "$p" --state blocked --timeout 600
corral read "$p" --lines 30
corral diff "$p" && corral merge "$p"

02 the difference

Tabs were fine for one agent.

Terminal tabs

An agent asks for permission in a tab you aren't on, and waits twenty minutes.
Closing the window or dropping SSH ends every agent.
Two agents edit the same checkout and break each other's builds.
Reviewing their work means juggling branches by hand.

corral

Blocked agents rise to the top of the sidebar and ring a bell.
A background server keeps them running; reattach from anywhere.
Each agent can work in its own git worktree and branch.
Review, commit and merge each agent's diff in place.

03 no wrappers

Your agents, unchanged.

corral opens a normal shell. Start an agent the way you always do and corral notices, reads its screen to tell whether it's working, blocked or done, and tracks it.

claudecodexopencodegeminiampcursor-agentcopilotpidroidgrok

Anything else runs too, as a plain shell. Optional hooks: corral integrate claude, corral integrate codex.

04 the keys

Ctrl-b, then one letter.

Everything you type goes to the focused agent. corral's own commands sit behind one prefix, and the mouse works too.

^b n new shell

^b w new shell in a worktree

^b b jump to the next blocked agent

^b j k next / previous agent

^b s show another alongside

^b D review the diff

^b a archive the agent

^b d detach, agents keep running

^b ? every key

get started

Open the gate. Let them run.

One command installs corral. Run corral in your project and start an agent the way you normally would.

$ curl -fsSL https://bottercode.github.io/corral/install.sh | sh

or cargo install --git https://github.com/bottercode/corral