What Bruce can do with each agent

What Bruce can read from each agent CLI, what it can query and control, and in which terminals it can operate them. The page is checked again and updated as each CLI releases.

Last checked: 2026-11-12

- This page states what Bruce can read from each agent and how far it can control it. It is not a list of what each CLI can do on its own.
- Each row was checked against the CLI version listed under Checked versions; newer releases may differ until they are checked again. This page is updated as each CLI releases.
- Mode, model and reasoning effort names are written exactly as each CLI spells them.

Legend

- ✅ Supported
- 🟡 Partial: the cell says what is missing
- ❌ Not supported
- — Not applicable: the agent has no such feature
- ? Not verified

Where Bruce reads from

- Session file: The session file the agent writes itself.
- Live stream: Its output stream, when Bruce drives it in a headless mode such as `-p`.
- ACP: Bruce hosts the agent as an ACP child process.
- hook: The agent's hooks push events to Bruce.
- Native interface: The agent's own control socket or app-server.
- Screen reading: Reading the terminal screen through Bruce's own terminal or an editor plugin.
- Footer: The status line a CLI draws at the bottom of its screen; needs screen reading.
- Note from Bruce: Claude Code receives the message as a note from Bruce, not as you typing.
- Take over: Continue an external session in Bruce's own terminal from then on.

Checked versions

The checked version is the release each row was verified against, as the table describes; it is not necessarily the CLI's latest release.

Checked version of each agent

Agent	Checked version	How it was checked	Checked on
Claude Code	2.1.296	Real subagent session samples; permissions and configuration also checked against 2.1.318 / 2.1.322	2026-11-12
Codex	0.166.0	Live stream checked with 0.166.0 samples and session files with 0.160.1 samples; native approvals and queueing verified against real Codex	2026-11-12
Grok	1.0.70	Real print-mode stream and session file samples	2026-11-12
Kimi Code	2.3.1	Real wire records and print output samples; the older CLI 1.1 is covered by tests built from the upstream schema	2026-11-12
DeepSeek Harness	0.2.2-rc.1	Tests built from session format v4; no real samples yet	2026-11-12
Qoder CLI	1.1.86	Real TUI session and log samples	2026-11-12
Pi	Not checked	Plain-text live stream only; no samples yet	—
Gemini CLI	Not checked	Process scan only; permission modes checked against the 0.67.0 sources and samples, not tested signed in	—
Copilot CLI	Not checked	Process scan only; permission modes checked against the 1.0.105 help	—
opencode	Not checked	Process scan only	—
aider	Not checked	Process scan only	—
Cursor Agent	Not checked	Sessions are not observed; Bruce can dispatch it, with permissions checked against the 2026.07.23-e383d2b help	—
Qwen Code	Not checked	Not integrated yet	—

Bruce's own engine ships with Bruce and is not listed.

Session parsing

Bruce parses each agent's sessions into a readable conversation. Desktop and iOS read the same parsed session, so this section applies to both.

Messages, thinking, tools, questions, approvals, compaction

Agent	Messages	Thinking	Tool calls	Edit diffs	Questions	Approvals	Context compaction	Todo
Bruce engine	✅	✅	✅	✅	❌ No question tool	✅ Approval hook	✅ Compaction card	🟡 Only the coding subagent's `todo`
Claude Code	✅ Session file + live stream	✅ Public thinking; redacted thinking shows as an empty card	✅ Name, arguments, result, failure and exit code	✅ Write / Edit / MultiEdit and Bash changes	✅ AskUserQuestion card; hook and screen reading as fallback	✅ PermissionRequest hook; screen reading as fallback	✅ Compaction summary as a card, expandable to the full text	✅ TodoWrite (the latest list is kept)
Codex	✅ Session file + live stream	✅ Public summaries (encrypted content is unreadable by design and stays so)	✅ With exit codes; terminal polling folds into the same card	✅ `apply_patch` hunks (a plain tool card in the live stream)	🟡 Asynchronous questions become cards; synchronous `request_user_input` is only a tool card; screen reading as fallback	✅ Native approvals (macOS / Linux only); screen reading as fallback	✅ A card per compaction; a local one opens to its summary, a server one is encrypted and does not open	✅ `update_plan`
Grok	✅ Session file + live stream	✅ Public thoughts; signatures ignored	✅ Exit code and tool status are judged separately	🟡 Marked as an edit only, without hunks or file cards	🟡 Screen reading only	🟡 Screen reading only; headless runs can only be cancelled	❌	❌ Its todo tool is not mapped
Kimi Code	✅ Session file	✅ Public think blocks; encrypted content stays unread	✅ Exit code taken from the last line of failed output	🟡 Marked as an edit only	🟡 Screen reading, or cards when hosted over ACP	🟡 Cards when hosted over ACP, otherwise screen reading	❌	✅ TodoList
DeepSeek Harness	✅ Session file; ACP gives a one-line summary only	✅ reasoning blocks	✅ Exit code parsed from the output	🟡 Workspace git diff side panel, not per turn	🟡 `ask_user_question` is read, but cannot be answered until the plugin for its desktop app is installed	✅ Session file + ACP	🟡 Replaced messages are dropped without a card	❌
Qoder CLI	✅ Session file (Claude format) + live stream	✅	✅	? Uses the Claude edit logic; no file-writing sample yet	❌ Questions in the file are not shown yet	❌ Shown as running; answer only in its own terminal	?	? Only when the tool is named TodoWrite
Pi	🟡 Plain live-stream text (ANSI stripped)	❌	❌	❌	🟡 Screen reading, in Bruce's own terminal only	🟡 Screen reading, in Bruce's own terminal only	❌	❌
Gemini CLI · Copilot CLI · opencode · aider	❌ Only a row from the process scan	❌	❌	❌	🟡 Screen reading, in Bruce's own terminal only	🟡 Screen reading, in Bruce's own terminal only	❌	❌
Cursor Agent · Qwen Code	❌ External sessions are not recognized	❌	❌	❌	? Screen reading for Cursor Agent dispatched by Bruce is not verified	? As for questions	❌	❌

Subtasks, usage, images, system lines, turn end, model, queue

Agent	Subagents / subtasks	Tokens / cost	Images	Slash commands and system lines	Errors and turn end	Model echo	Queued input
Bruce engine	✅ Dispatched tasks + coding subagent pages	✅ Per step and per turn, with cost in USD	✅	— Templates are already expanded	✅ Separate cards for failure, stop, truncation and retry	✅ Model card	✅ steer / follow-up
Claude Code	✅ Subagent files open as child pages	🟡 Per-turn tokens, no cost	🟡 Only images sent from Bruce are shown; image blocks in the session are dropped	✅ Command names and local command output handled; meta lines hidden	✅ API error cards (rate limit, sign-in, quota) + interruption card	✅ Model and effort	✅ Native queue replay
Codex	✅ Spawned threads fold in as child tasks, each with its own page	🟡 Per-turn tokens, no cost	🟡 As for Claude Code; `input_image` is not read	🟡 Injected context is filtered; slash commands not verified	✅ Failure cards, aborts, retry times	✅ Per-turn configuration snapshot	✅ Native queue + screen preview
Grok	❌ Subagent sessions are excluded	🟡 Tokens and duration once a turn ends, none while it runs; no cost	❌	?	✅ Stop reasons and error cards; tool cancellation	❌	🟡 Screen-read lines only
Kimi Code	✅ subagent / task children	🟡 Per-turn tokens, start time and duration; no cost	❌	🟡 Input not typed by you is filtered; slash commands not verified	✅ Failure and interruption endings + error cards	✅ Model alias and thinking effort	✅ Queue and steer with native IDs
DeepSeek Harness	🟡 Background jobs as children	🟡 Per turn from the file + live over ACP, no cost	🟡 Only an [Image] placeholder	🟡 System reminders are filtered	✅ A provider error becomes an error card (with its retry time); a cancelled turn shows as interrupted; `max-tokens` and `blocked` say so	🟡 Only when hosted over ACP	❌
Qoder CLI	❌	❌ No usage in the file; live-stream usage is all zero	🟡 As for Claude Code	✅ Same filtering as Claude Code	✅ System errors become error cards	✅ The `model` on its replies (usually `auto`) and `reasoningEffort`	❌
Pi	❌	❌	❌	❌	🟡 Process exit code only	❌	❌
Gemini CLI · Copilot CLI · opencode · aider	❌	❌	❌	❌	❌	❌	❌
Cursor Agent · Qwen Code	❌ External sessions are not recognized	❌	❌	❌	❌	❌	❌

Bruce's own send queue works for every agent: messages wait in Bruce and go in when it is their turn. The Queued input column covers only each agent's native queue.

Only Bruce's own engine reports cost; external agents report token counts only.

Settings and status

Launch means applied as arguments when Bruce starts, dispatches or reopens a session; live means changed on a session that is already running. Reopening a closed session currently works for Claude Code, Codex, Kimi Code and Grok.

Query

Agent	Quota	Permission mode	Model	Reasoning effort	Context usage
Bruce engine	🟡 Manual balance check in Settings (DeepSeek, OpenRouter)	✅ Trust level	✅ Model recorded for every reply	✅	✅ Provider counts against the known window
Claude Code	✅ 5-hour, weekly, per-model and extra usage, with reset times	✅ `permissionMode` in the file + footer	✅ Session file	✅ effort in the file	✅ Request size from the file; the window is Claude Code's default for that model, marked as coming from the model table
Codex	✅ 5-hour, weekly and credits, with reset times	✅ Session file + the `/permissions` picker	✅ Session file	✅ Session file	✅ Usage in the file against the model window
Grok	✅ Weekly pool + reset time	🟡 Footer only (needs screen reading)	❌ Shows the launch choice only	❌ Shows the launch choice only	✅ Session signals file; footer as fallback
Kimi Code	❌	✅ Wire records + footer	✅ Wire records	✅ Wire records	🟡 Footer in Bruce's own terminal only
DeepSeek Harness	❌	— No modes, only per-action approvals	✅ When hosted over ACP	✅ When hosted over ACP	✅ `contextWindow` and the latest request (cache included) from its log
Qoder CLI	❌	❌	✅ From the file (the `model` on its replies)	✅ From the file (`reasoningEffort`)	❌ The file names its window but records no usage
Pi	❌	— No built-in approval modes	❌ Shows the launch choice only	❌ Shows the launch choice only	❌
Gemini CLI	❌	🟡 Footer only	❌ Shows the launch choice only	—	❌
Copilot CLI	❌	🟡 Footer only	❌ Shows the launch choice only	❌ Shows the launch choice only	❌
Cursor Agent	❌	❌	❌ Shows the launch choice only	❌	❌
opencode · aider	❌	❌	❌	❌	❌
Qwen Code	❌ Not integrated yet	❌	❌	❌	❌

Footer only means Bruce can read it only while the agent runs in Bruce's own terminal or in an editor terminal with Bruce's plugin.

Set

Agent	Permission: launch	Permission: live	Model: launch	Model: live	Effort: launch	Effort: live
Bruce engine	✅ ask / auto-read / auto-all	✅ Takes effect at the next step	✅	✅ Per session, from the next turn	✅ auto / low / medium / high (when the model supports it)	✅
Claude Code	✅ `--permission-mode`	✅ Presses Shift+Tab to cycle (needs screen reading); `dontAsk` and `bypassPermissions` only if allowed at launch	✅ `--model`	❌ Takes effect at the next launch	✅ `--effort` low…max	❌
Codex	✅ Presets on-request / auto-review / full-access / read-only	✅ Types `/permissions`; takes effect from the next turn (needs screen reading)	✅ `--model`	❌	✅ `model_reasoning_effort`	❌
Grok	✅ default / auto / bypassPermissions / dontAsk	🟡 Can only type `/auto` or `/always-approve`	✅ `--model`	❌	✅ `--reasoning-effort` low / medium / high	❌
Kimi Code	✅ `--yolo` / `--auto`	✅ Types `/yolo` to open the three-way choice	✅ `--model`	✅ Types `/model`, selects, and reads it back to confirm	✅ Environment variable	✅ Picker + Alt+S
DeepSeek Harness	—	—	✅ Saved while not hosted, applied the next time it is hosted	✅ ACP config option, from the next turn	✅ As for model	✅ As for model
Qoder CLI	🟡 Only adds accept edits when dispatched to write	❌	✅ `--model`	❌	❌	❌
Pi	— No approval modes by design	—	✅ `--model`	❌	✅ `--thinking` off…max	❌
Gemini CLI	✅ `--approval-mode` default / auto_edit / yolo / plan	🟡 Presses Shift+Tab / Ctrl+Y; not tested signed in	✅ `--model`	❌	—	—
Copilot CLI	✅ default / allow-all	🟡 Types `/permissions <mode>`	✅ `--model`	❌	✅ `--effort` low…max	❌
Cursor Agent	🟡 Only two levels: `--force` and `--auto-review`	❌	✅ `--model`	❌	❌	❌
opencode · aider	❌ Observed only, cannot be dispatched	❌	❌	❌	❌	❌
Qwen Code	❌ Not integrated yet	❌	❌	❌	❌	❌

Claude Code modes: `manual`, `acceptEdits`, `plan`, `auto`, `dontAsk`, `bypassPermissions`. Kimi Code modes: manual / yolo / auto.

The four Codex presets are Bruce's, combining `--sandbox`, `--ask-for-approval`, `--approve-for-me` and `--dangerously-bypass-approvals-and-sandbox`. For Codex, Bruce also shows, read-only, the sandbox, approval policy, approver, service tier, permission profile, and file and network access.

Fast mode is not wired for any agent yet.

Where each client shows it

Item	Desktop	iOS
Quota	✅ A strip below the session (Claude Code / Codex / Grok windows and reset times) + a diagnostics card in Settings	✅ Windows, reset times, forecast, balance
Permission query and setting for external CLIs	✅ In the session's composer row (in its header when it can only be watched)	✅
Model and reasoning effort	✅ Echoed values are shown apart from the launch choice	✅ As on desktop
Context usage ring	✅	✅

Neither client shows the subscription tier name; the quota snapshot does not include it.

Terminals and control

Conversations are read from each agent's own session file, wherever it runs: Claude Code, Codex, Grok, Kimi Code, DeepSeek Harness and Qoder CLI conversations are visible from any terminal. The tables below cover only what Bruce can operate.

Public distribution of the JetBrains plugin and the Bruce Bridge extension is being prepared.

Overview: terminal host × action

Terminal host	Discover and attribute	Read the screen	Type input	Answer screen menus	Interrupt	Change permission / model live	Focus the window
Bruce's own terminal	✅	✅ Including Claude Code's greyed suggestion	✅	✅	✅ Esc (Ctrl+C for Grok)	✅	— Already in Bruce
JetBrains IDE + Bruce plugin	✅	✅	✅	✅	✅	✅	❌
JetBrains IDE without the plugin	✅	❌	❌ Prompts to install the plugin	❌	❌	❌	❌
VS Code family + Bruce Bridge	✅	🟡 Needs shell integration in the terminal	✅	✅ Needs screen reading	✅	🟡 When the screen can be read	❌
VS Code family without the extension	✅	❌	❌ Prompts to install the extension	❌	❌	❌	❌
Ghostty (macOS)	✅	❌	✅	🟡 Selects with arrow keys only, without a screen card	✅	❌	❌
Terminal.app (macOS)	✅	❌	✅	🟡 An extra Return follows the number	🟡 An extra Return follows the key; not tested	❌	❌
iTerm2, Warp, Alacritty, kitty, WezTerm, Hyper, Tabby, Zed, Fleet	✅	❌	❌	❌	❌	❌	❌
tmux / GNU screen	🟡 tmux hides the outer terminal; screen is not recognized	❌	❌	❌	❌	❌	❌
Native Windows / Linux terminals	🟡 Only Windows Terminal is recognized	❌	❌ Editor plugins work across platforms	❌	❌	❌	❌
Headless: Codex app-server	🟡	—	🟡 Native queue (macOS / Linux; the thread must already be loaded)	✅ Native approvals and asynchronous questions	❌	❌	—
Headless: Kimi Code / DeepSeek Harness hosted over ACP	✅	—	✅	✅ ACP permission cards	🟡 DeepSeek Harness can be cancelled; Kimi Code cannot	🟡 DeepSeek Harness can change model and effort	—

Change permission / model live: permissions change the way each agent's row under Set describes; in a terminal only Kimi Code can change model while running, and the others apply it at the next launch.

In any terminal, Claude Code approvals go through its hook and Codex approvals through its native interface, so both can be answered from the phone or desktop even where typing is not supported.

Bruce's own terminal

A PTY that Bruce opens itself: everything works here, and it is where a taken-over session continues.

Action	Support
Type input	✅ Written straight into the PTY, then Return; Codex gets a bracketed paste after Bruce confirms its input box is empty
Answer menus	✅ Raw number keys; the screen hash is checked first, and nothing is pressed if the menu changed
Interrupt	✅ Esc; Ctrl+C for Grok
Change permission live	✅ Each agent's permission adapter presses keys or types a command, then reads the screen back to confirm
Change model live	🟡 Kimi Code only (types `/model`); the others apply it at the next launch
Read the screen	✅ The full VT grid; Claude Code's greyed suggestion, the Codex queue preview and the Kimi Code footer all come from here

JetBrains IDE terminals

IntelliJ IDEA, WebStorm, PyCharm, GoLand, CLion, RustRover, Rider, PhpStorm, RubyMine and DataGrip.

The plugin requires IDE 2026.1 or later (builds 261–263.*); restart the IDE after installing it. Bruce finds each session's terminal tab by its process, so several open IDEs never get mixed up.

Action	With the Bruce plugin	Without it
Discover sessions and their IDE	✅	✅ The IDE is recognized from the process tree
View the conversation	✅	✅ Read from the session file, independent of the plugin
Read the terminal screen	✅ Screen, menus and Claude Code's greyed suggestion	❌
Type input	✅ Paste + Return, landing in the CLI's own input queue	❌ Phone and desktop prompt you to install the Bruce plugin and restart the IDE
Answer screen menus	✅ Choices are checked against the screen hash; waits while the terminal is in front and was used in the last 10 seconds	❌
Interrupt	✅ Esc / Ctrl+C	❌
Change permission / model live	✅ Same as Bruce's own terminal	❌
Focus the window	❌ Can only open a new terminal tab	❌
Fallback	If the IDE does not respond, messages wait in a queue; for Claude Code they become a note from Bruce after 5 minutes	Claude Code: a note from Bruce; Codex: its native queue; the others refuse and can be taken over into Bruce's terminal

VS Code family terminals

VS Code, Cursor, Windsurf, Trae, Qoder IDE, Antigravity IDE, Kiro and VSCodium.

The Bruce Bridge extension requires VS Code 1.90 or later and needs no restart. Each window registers itself with Bruce.

Action	With Bruce Bridge	Without it
Discover sessions and their editor	✅	✅
View the conversation	✅	✅
Read the terminal screen	🟡 The terminal needs shell integration; Claude Code's greyed suggestion cannot be read	❌
Type input	✅ Same interface as the JetBrains plugin	❌ Prompts you to install the Bruce Bridge extension; no restart needed
Answer screen menus	✅ When the screen can be read	❌
Interrupt	✅	❌
Change permission / model live	🟡 When the screen can be read	❌
Focus the window	❌ A new terminal appears without taking focus	❌
Fallback	As for JetBrains	As for JetBrains without the plugin

Ghostty (macOS)

No plugin needed: Bruce uses Ghostty's AppleScript. The first time, allow Bruce to control Ghostty in System Settings; if access is denied, Bruce shows where to change it.

Action	Ghostty 1.3 or later	Earlier versions
Find the session's window	✅ By the process tty	🟡 By working directory + title, which must match exactly one window; when Claude Code has no directory, the title must be exactly "✳ session title"
Type input	✅ Pastes the text + Return without bringing the window forward	🟡 The same, provided exactly one window matches
Answer menus	🟡 Arrow keys to item n, then Return; the screen cannot be read, so there is no menu card	🟡 As for 1.3 or later
Interrupt	✅ Esc / Ctrl+C	✅
Read the screen, change permission / model live	❌	❌

Bruce does not check the Ghostty version: when the tty lookup fails it falls back to directory and title. Tested on 1.3.1; Qoder CLI input was tested on 1.4.0.

Terminal.app (macOS)

Action	Support
Type input	✅ Types only into the one tab whose tty matches the session process, without changing the front app; nothing is typed when no tab or several tabs match
Answer menus	🟡 Sends the number; Terminal.app adds a Return
Interrupt	🟡 Sends Esc / Ctrl+C, also followed by an extra Return; not tested
Read the screen, change permission / model live, focus	❌

As with Ghostty, allow Bruce to control Terminal.app in System Settings the first time.

Other terminals

iTerm2, Warp, Alacritty, kitty, WezTerm, Hyper, Tabby, Zed, Fleet, tmux and Windows / Linux terminals.

Bruce never types into a guessed window, so it does not type into these terminals. Only each agent's own channels work:

Agent	What works
Claude Code	Messages are sent as a note from Bruce (Claude Code sees Bruce's note, not your own words; unavailable on Windows); approvals still go through the hook
Codex	Messages go through the native queue (macOS / Linux); approvals still go through the native interface
Others	Messages cannot be sent; the session can be taken over into Bruce's own terminal, after which there are two sessions

Each agent's input channels

The parts that do not depend on the terminal.

Agent	Preferred	When that fails	Session closed	Stop / send now	Take over
Claude Code	Types directly in a supported terminal	Waits in a queue, then becomes a note from Bruce	`claude --resume <id>` with the message	Esc / Ctrl+X Ctrl+S	Hand over (the original terminal exits, then the session resumes); or open a copy (`--fork-session`)
Codex	Types directly in Bruce's terminal or an editor terminal whose screen can be read, when the input box is empty; otherwise the native queue by session ID	Refused; never sent a second way	`codex resume <id>` with the message	Esc	`codex resume` (the other writer stops first)
Grok	Types directly	Refused	`grok --resume <id>` with the message	Ctrl+C	Fork with `--fork-session`
Kimi Code	Types directly	Refused while running	Hosted by Bruce over ACP	Only in Bruce's terminal	`kimi fork`
DeepSeek Harness	ACP hosted by Bruce, or the plugin bridge in its desktop app	Refused while the desktop app holds the session	ACP, one message at a time	ACP cancel, or the plugin	❌
Qoder CLI	Types directly, only between turns	Waits for the turn to end	Refused	Esc	Fork with `--fork-session`
Pi · Gemini CLI · Copilot CLI · opencode · aider	❌ No channel Bruce can write to	—	—	—	❌

Sessions on Bruce's own engine are used directly in Bruce; Cursor Agent and Qwen Code external sessions are not recognized yet, so they are not listed.

Guards

- Bruce types only into the one terminal that matches: Terminal.app by tty, Ghostty by tty and then directory + title, and editors by asking which window holds the process, letting only that window type.
- A send with an uncertain result is never retried another way; Bruce would rather show the failure.
- Menu answers and send now wait while the terminal is in front and was used in the last 10 seconds; your own messages are not held back and land in the CLI's own input queue.
- Before a hand-over types `/exit` into the original terminal, Bruce likewise checks that nobody is typing there, so the command never merges with a draft.
- Qoder CLI receives input only when idle and while the session ID still matches; Grok and Kimi Code refuse input while a menu is open; messages wait while an approval or a synchronous question is pending.
- Ghostty and Terminal.app input works only on macOS; Claude Code notes, the Codex native queue and native approvals work only on macOS / Linux.

Markdown