AI Code Conductor

Mission control for Claude Code and Codex — run dozens of Claude Code and Codex sessions in parallel, each with its own account, working directory and saved config, and see every session's spend, identity and attention at a glance.

Claude Code is a remarkable CLI. But the moment you have more than one project, more than one account, or more than one machine, the experience fragments: you lose track of which terminal is which, which sessions are paused, what they have spent, and where their attention is going. AI Code Conductor wraps Claude Code and Codex in a desktop app that treats the session as the first-class object. Every session has a colour, a name, an account, a working directory and a saved config; every spawn surfaces its tokens, model, rate-limit window and identity; every cent is captured and pivotable. It does not replace Claude Code or Codex. It conducts them.

Formerly Claude Command Center. Same app, same data — the rename is cosmetic and updates carry across on their own. An independent, community-built project — see Trademarks.

---

Sessions, accounts, and a sidebar that knows what is going on

Every workspace starts as a saved config: a label, a colour, a working directory, a starting model and effort, its own permission preset and any extra CLI arguments. Configs live in sections and groups you arrange yourself, and the sidebar has two modes — Saved for launching and Running for tending what is live — with a Quick Start row for the configs you pin. A config runs one session at a time unless you tick Allow Multi Spawn, which trades the play button for a copy count and lets you start several at once; Select on either tab turns the rows into tick boxes and launches a whole set in one press. Each session card carries the whole picture on one line: status, the model and effort actually in use (read live from Claude, never guessed) and whether Fast Mode is on, context consumed, the account it is signed in as, and its type — Claude Code, Codex or a plain terminal, over SSH or not.

• Multiple Claude accounts, real isolation — your existing login is captured into a protected primary account on first run, and every session runs under a saved, isolated home. Pick the account at launch, switch it mid-session without losing the session, and park the ones you are not using. Add one by running /login in any session; the Conductor notices and offers to save it.
• Two assistants, one Accounts page. Settings → Accounts starts with a Providers card that turns Claude Code and Codex on or off, says whether each CLI is installed and which version, and, when Claude Code or Codex is missing or Codex is too old, lists the install or update commands, the publisher's own installer first, each with Run it for me and Copy. Below it sit your Claude accounts and your Codex accounts. A fresh install asks which assistants you use, and a machine without Claude Code can run with Codex only. A provider that is off starts nowhere and says why; one cannot be switched off while anything of it is running. With Claude Code off, Insights runs for Codex accounts only, Ask Conductor runs on Codex, Cloud Agents runs Codex agents only, and Terminal only configs still run.
• Codex accounts, each with its own sign-in. Add more than one Codex account (ChatGPT or an API key; the key goes straight to Codex and the app never stores it). Each signs in inside its own folder that the app creates in its resources directory, so sessions never mix identities, and the app never reads the sign-in Codex keeps there. A saved config picks the Codex account it runs under; new sessions use the default and code reviews the reviewer. Codex accounts are always added in the app, as Claude accounts are; the Codex CLI's own sign-in in ~/.codex is left alone. Upgrading from an earlier version? After updating, the app asks once whether you use Codex. Nothing carries over from your earlier Codex setting: a 2.1.0 Codex user adds a Codex account once, and earlier Codex conversations stay in ~/.codex, where codex resume in a terminal picks them up. The old Settings Codex tab is now part of Settings → Accounts.
• In-app claude.ai sign-in — each account also carries its own claude.ai web session, signed in inside the app rather than by handing you off to a browser.
• In-app chatgpt.com sign-in for Codex accounts. Each Codex account can carry its own chatgpt.com web session too, signed in inside the app from its menu in Settings, Accounts or from a Codex session's right-click menu, and a Codex session's browser pane offers chatgpt.com as that account. Signing out of chatgpt.com, or archiving the account, clears it.
• Attention, activity and sleep — read the card — a session that needs you pulses (driven by the assistant's own hooks, Claude Code's or Codex's, never a guessed spinner); a session actively producing output wears a green working pill and a matching green sweep along its context bar; and, with the Session Watchdog enabled, one that has gone quiet earns a moon telling you how long it has been silent. The three are mutually exclusive, so a glance is enough.
• Command buttons — a bar of your own buttons under every terminal. A button does one of three things — sends a prompt to the assistant, runs a line in a shell, or opens a page in the browser pane — and the dialog asks that first, then shows you the button and the exact text it will type as you fill it in. Rows are named for where a button runs, a button shared by every config carries a global mark, and an argument that is a secret (a token, a key) lives in the OS keychain and is typed as a reference, so it never reaches your shell history.
• Help where you are — the tip of the day and Ask Conductor sit at the foot of the sidebar. Ask Conductor opens a real session, on Claude Code or Codex, that has read the app's documentation and its known issues; Discuss on any tip hands the question to it. Right-click either to switch it off.

Remote sessions that survive the link

Remote sessions run over SSH with the same session model as local ones — same dialog, same statusline, same account handling — and the Conductor's own MCP server reaches the remote through an automatically injected reverse tunnel. Same means same: a remote session reports its status back over that connection rather than painting escape codes through the terminal, so it fills in the account line on its card, the account pill in its header and its own bars in the multi-account strip — 5-hour, weekly and per-model alike — and Windows, Linux and macOS remotes all report status identically. Remote sessions run Claude Code: Codex sessions and Codex reviews run on this computer only in this release. A remote session raises the attention indicator too when Claude is waiting on you, over its own terminal: on Linux and macOS hosts, SSH Persistent and container sessions included, but not on Windows hosts yet.

How a config connects is one choice of three: Local, SSH, or SSH Persistent. The third runs the remote Claude under tmux, so a dropped VPN, a closed lid or a flaky network no longer kills the work: Claude keeps going on the remote, and reconnecting reattaches to the same session with your conversation and scrollback intact. If the remote has no tmux the app can fetch a verified copy for it, or push one down the existing connection when the remote has no internet of its own. Ending a session and leaving it running are separate, explicit choices, and a pill on the session says which it is. Launching a config always starts a new session, so picking a left-running one back up is its own visible gesture: it waits in a Remote Resumable section docked at the foot of the Running tab — a card each, with the host, how long ago you left it, and a Resumable or Unreachable pill — and one click puts you back in the same Claude and the same conversation. Right-click gives you Remove, which ends it on the host too. The cards survive closing the app, and they are checked cheaply: a ping while the section is on screen, a real sign-in to the host only when there is a reason to. The three kinds of remote session are told apart wherever they appear — a blue SSH mark, a green one with a chain link for persistent, a teal container mark on its own. A separate Runtime section decides where the session lands once it has connected — on the host, or inside a Docker or Podman container the app execs into for you: pick the engine, name the container, exec into a running one or start a stopped one, and Claude runs in there with the statusline, account and usage intact. Ending the session stops that session's Claude inside the container and leaves any co-tenant alone. (Container sessions are not persistent yet: they run bare and resume with --continue.)

Agent Canvas — review what your agent built by pointing at it

Your agent, Claude or Codex, renders a design mockup, a plan, or your project's real built site onto a canvas inside the app. You mark it up directly — pin a note to an element, draw over a region, paste screenshots of your own — and then decide: approve or reject the version in front of you. The agent receives the notes anchored to the actual elements you pointed at, works through them in one pass, renders the next version and hands back; the pane returns you to the terminal on its own. It is a review loop rather than a screenshot: the page is laid out by a real browser engine, so what you annotate is what will ship. Approving owes the agent nothing — notes you send with an approval are kept as observations rather than work — and once nothing else on the canvas is open the artefact signs itself off into the project Library. Only one round is ever live at a time, and a settled round stays settled: reopening a note, or a whole round, is yours alone. Answer a note in chat instead of the pane and the agent marks it addressed, but the decision is still yours. Each canvas holds one subject, so a new topic never inherits an old one's notes, and History moves you between the artefacts a session has built up. Not every render is a review: when you only want to see something, the agent can put it up as a show-and-tell that joins no queue and you dismiss in a click (or tell the agent to). The Canvas button counts what is still open across every canvas the session owns, so nothing waits out of sight, and Mark complete closes an artefact yourself, naming exactly what it will close as not done before you confirm. The canvas also has a plan mode: before starting anything large, the agent puts the plan on the canvas rather than in the chat, and you review it per step, anchored, before a line of code is written. A plan is reviewed as a plan — Approve or Submit Revisions, never Reject, because a plan is meant to go round again — and Approve stays out of reach while the plan carries an open question or you have a note you have not sent, so an approval never arrives carrying work the agent has not seen.

Testing mode turns the same surface on a running build: the agent serves the app and you use it. The moment you start writing a note the screen pauses and locks the evidence together — a screenshot with your drawings over it, the page state (route, open dialogs, where the focus is, which fields are filled, changed or invalid, and never a character of what you typed) and a timed trail of what you did to get there. Notes collect into a test pack that takes one pass-or-fail verdict per build, and afterwards the pack is a record you page back through rather than a site to re-run; the agent reads its structure first and asks for the pictures only when it needs pixels. Work is no longer tied to the session that made it, either: a canvas in flight is private to its own session, and when that session goes away any session on the project can Resume it — first press wins — or dismiss it, with a quiet dot on the Canvas button when there is something to pick up. The Library searches every artefact in the project by title and note text, filters by kind and state, expands a test pack to page through its evidence, and archives or deletes in bulk; signed-off work is readable by every session on the project. And Canvas Explained — a card on the canvas front page, and the same page inside the Feature Guide — draws the whole model rather than describing it.

Tokenomics — every cent, pivotable

A background indexer reads all of your transcripts — subagent and sidechain files included — dedups globally, and computes cost at query time from live pricing, so the dashboard opens instantly. A KPI row, a daily-spend chart, a per-model breakdown and a sessions table with cost, model, account and config attribution; filter the whole view by date, model, provider, account or project. With Claude Code and Codex both in use and no filter narrowing the view, each KPI shows the two apart, and the cost chart draws a line for each when both have spend in the range. Codex usage is attributed to the account whose folder it was written in, and Claude usage to the account profile a local session runs under (from 2.1.1 on; older usage, SSH sessions and sessions with no account profile read Not recorded, except that a local session later resumed in the app under an account profile moves its earlier usage to that profile's account). A model with no price yet reads no price instead of costing $0, and a notice names it. Pricing comes from LiteLLM's open pricing data, cached for a day.

Logs — your conversations, readable

The Conductor indexes Claude's own transcripts, and a local Codex session's own conversation, and renders them back as a readable chat — messages and tool calls. A timeline rail beside the transcript scrubs the whole conversation; click to jump. Full-text search spans every conversation and lands you on the matching turn. A per-session Conversation tab live-follows the running session. Deleting the index never touches your conversations, which stay in ~/.claude/projects (and, for Codex, in each Codex account's sessions folder).

Memory — catch the drift before it costs you context

A dashboard over Claude's auto-memory across every project. A KPI strip — memories, projects, total size, stale-over-30-days, index health — and charts summarise the store; a ranked project list shows staleness, index warnings and live-session activity. Drill into any project for a sortable table, open a memory in the reading drawer to read it cleanly, write missing frontmatter, or delete it. Full-text search runs across everything. With Codex in use, each Codex account's own memories are listed below, under the account's name, read-only.

Insights — what actually happened, across every account

On-demand reports over your own usage, Claude Code's and Codex's, runnable across all of your accounts at once rather than one at a time. A Claude Code account's report is Claude Code's own /insights; for a Codex account the app counts that account's sessions itself and asks Codex, read-only and with no tools, to write the cards. Where Tokenomics answers what things cost, Insights answers what you did with them.

And the rest of the surface

• Conductor MCP — a local MCP server giving every Claude and Codex session eighteen browser-vision tools (screenshot, navigate, click, type, eval), a host-screenshot fetch, the Agent Canvas tools and the push to the browser pane, plus codex_review for Claude sessions, so Claude can ask Codex to spot-check its own work. Codex sessions get claude_review the other way round. Each review is a separate, one-off, read-only reviewer on your reviewer account, with a switch per direction in Settings → General → Built-in Tools. One global Chrome instance is shared across every session so logins persist; SSH sessions reach it through the tunnel.
• Cloud Agents — dispatch headless agents, on Claude Code or Codex, as background tasks with live status and streaming output. (2.1 deprecates the old Agent Hub's Pipelines and agent Library; a richer replacement is planned for 2.2.)
• Codex — OpenAI's Codex CLI runs beside Claude Code. Choose Codex on the provider card of New saved config, per config, with the models the supported Codex versions offer in the model dropdown and read-only / standard / plan mode / auto / unrestricted permission presets. Pick the Codex account a config runs under, use Restart and pick a conversation in a Codex session's header to go back to an earlier conversation, and move a running Codex session to another Codex account with Switch Account, keeping its conversation. A five-page Hello Codex introduction shows once when you have said you use Codex and a Codex account you added is signed in, and can be replayed. Local sessions only in this release (no SSH); the Logs page indexes Codex conversations as it does Claude's. Switched on or off on the Providers card in Settings → Accounts.
• GitHub panel — PR status, CI runs, reviews, unresolved threads and inferred issue context in a collapsible right rail; OAuth, PAT, or adopt your gh login. Ctrl+/ (Cmd+/).
• Sentinel — an opt-in watcher that notices when Claude Code or Codex updates and checks whether the new version might affect the Conductor, proposing model and effort registry fixes you apply yourself. Fail-open; a hot-reloadable registry means brand-new models still get a colour, label and pricing.
• Session Watchdog — an opt-in, per-session watcher that reads a rate-limit, overload or safeguard-stop banner, waits out the reset and submits the retry itself — never over text you are mid-typing — with an hourglass and countdown on the card while it waits. It also flags a session gone quiet (the moon on the card), and the Conductor's services panel lists every background service with a per-service restart.
• Feature Guide — a searchable in-app reference with a card for every feature (what it does, how to open it, a tip) plus the complete What's New history, a click away from the sidebar's help button.
• Browser pane — every session has a browser beside its terminal: an address bar (type localhost:5173 and press Enter), working history, a home page per config, saved favourites, and a button to open the page in your real browser. Pages load in a sandbox with every permission off. A command button can point it at a dev server as it starts ("watch for a page") or simply open a page; freeze the page to annotate a snapshot in Excalidraw.
• Partner terminal and scratchpad — every session carries a partner shell in the same tab (on the host, for an SSH session), and a per-session Excalidraw whiteboard that persists with the config; export the drawing straight into the session.
• Multi-account usage strip — every signed-in account's usage along the bottom of the window, one pill per person, grouped by provider so Claude Code and Codex figures are never merged, and a minimal mode that shows just the account name and two traffic-light dots (green under 70 %, amber to 89 %, red from 90 %) so the strip stays readable with many accounts. The Usage page lists every Claude and Codex account's 5-hour and weekly allowance on one screen.
• Snap and Vision capture — region or window capture from any screen at 1920px / JPEG 85, a file path inline for local sessions and over the tunnel for SSH; Alt+V pastes clipboard images.
• A first-run tour and What's New that know where you came from: a fresh install gets the tour; an update shows what is new since the version you came from (every prerelease of a release shows that release's whole story), and an update across a release line also walks the tour again.

---

Getting started

1. Download the installer for your platform from Releases (AI-Code-Conductor-x.y.z.exe, AICodeConductor-x.y.z-macos13.dmg for Apple Silicon on macOS 13 or later, or AI-Code-Conductor-x.y.z-linux-x86_64.AppImage) and verify its SHA-256 against CHECKSUMS.txt on the release page. Up to 2.1.1-beta.1 (2.1.0 included) the Mac download was AI-Code-Conductor-x.y.z-mac.dmg, and the updater in those versions does not offer a download under the new name, so a Mac on 2.1.0 says it is up to date. 2.1.1 and later need macOS 13. On macOS 12, stay on 2.1.0. On macOS 13 or later, download the .dmg from the Releases page on GitHub once by hand; from then on the updater offers new versions as before.
2. Run it: after the Welcome page, choose your Data and Resources folders.
3. The setup wizard finds your Claude Code CLI — and, if it is not there, stops with the install commands (Anthropic's installer first, then npm), each with Run it for me and Copy, and Check again, because every Claude session the app launches is a Claude Code process — then walks you through accounts and hands off to Claude's own auth. If you only use Codex, choose Use Codex only on that screen instead. A fresh install asks which assistants you use (Claude Code, Codex or both); choosing Codex opens a Set up Codex page that checks for the Codex CLI, offers its install or update commands, each with Run it for me (a visible terminal tab, only once you confirm) and Copy, and signs you in to a Codex account. Every feature is optional and asks before it turns on.
4. Create a config, launch a session, and the sidebar starts filling in.

Internally the app still identifies itself as claude-conductor (npm name) and com.claudeconductor.app (Windows application id). Those are frozen on purpose — changing them would break the upgrade path and orphan existing data — so you may see them in paths and installer metadata.

Requirements

Claude Code	The Claude Code CLI, installed and authenticated, unless you run Codex only
Codex (optional)	OpenAI's Codex CLI, version 0.153.4 or newer, tested up to 0.156.1 (a newer one still runs, with a notice) (npm install -g @openai/codex; in PowerShell on Windows, npm.cmd install -g @openai/codex). Sign in to Codex accounts from Settings → Accounts. Codex runs on this computer only in this release
Node.js (optional)	22 or later. Without it the app still starts sessions, but these need it: the npm install of Claude Code or Codex (Anthropic's installer and OpenAI's need none), the resume list a new session opens, a Claude Code session's status line and, on macOS and Linux, the Codex hooks. Without Node.js a new session starts Claude Code or Codex directly; in a Claude Code session, /resume still lists earlier conversations
Resources folder	On a drive that keeps file permissions (NTFS on Windows), not a FAT or exFAT drive or a network share that does not keep them; otherwise the app's status line, the resume list and the Codex hooks are not used
Windows	10 or 11, x64. Installers are code-signed (SSL.com, publisher "Nicholas Moger"); SmartScreen may still prompt on a brand-new release — More info → Run anyway
macOS	13 (Ventura) or later on Apple Silicon; on macOS 12, stay on 2.1.0. Builds are signed and notarised
Linux	Experimental — glibc 2.39+ (Ubuntu 24.04+, Rocky 10+, Fedora 40+), x64. chmod +x the AppImage; needs FUSE 2 and GTK 3. Known issue: start the AppImage with --appimage-extract-and-run where FUSE 2's fusermount is missing, as on the Rocky Linux 10.2 host it was tested on, because the AppImage cannot mount there. The vision browser needs a deb/rpm Chrome — the snap build's confinement blocks the debug profile

Under the hood

Electron 44 with a frameless, sandboxed renderer and zod-validated IPC; React 19 with Tailwind CSS v4 (dark, light and system themes); Zustand 5 hydrated from disk on boot; xterm.js 6 over node-pty (ConPTY on Windows) — GPU rendering is on by default and only ever drives the terminal you are looking at, because the WebGL addon keeps one glyph cache per process and a session rebuilding it blanked every other until a victim was taught to drop its own render model before repainting; electron-vite; @modelcontextprotocol/sdk for the Conductor MCP server. The main process owns config persistence, the PTY pool, the hooks HTTP gateway that drives the attention pulse, the tokenomics aggregator, the statusline ingest, the MCP server and cloud-agent dispatch; the renderer talks to it exclusively through typed IPC channels.

Over six thousand unit tests plus a native suite that runs under Electron's own runtime — for better-sqlite3, node-pty, and anything whose behaviour differs between Electron and plain Node — green on Windows and macOS in CI on every labelled PR. Security-sensitive changes go through an adversarial review pass before merge: independent agents attack the change with distinct lenses, and the verdict is recorded on the pull request.

git clone https://github.com/nubbymong/ai-code-conductor.git
cd ai-code-conductor
npm install
npm run typecheck && npx vitest run    # tsc, then the unit suite
npm run dev                            # HMR dev
npm run package:win | package:mac | package:linux

Security & privacy

Credentials	SSH passwords, sudo passwords and encrypted notes are stored as encrypted blobs via the OS keystore — DPAPI, Keychain, libsecret. Machine-bound, never plaintext
Account isolation	Each session runs under its own isolated home; the original global login is snapshotted read-only on first run and never touched. Each Codex account signs in inside its own folder under the app's resources directory; the app never reads the sign-in Codex keeps there, and an API key goes straight to Codex without being stored by the app. Your own ~/.codex is no longer offered as an account; one that 2.1.1-beta.2 registered for it is used for a session only when you confirm that launch, and never for a review
Permissions	Claude Code's own permission prompts surface in the app. You can grant a standing approval so a repeated prompt stops interrupting you — yours to create and revoke, high-risk payloads excluded, nothing approved that you did not choose
Telemetry	None of our own. Outbound traffic is limited to GitHub Releases (update check), status.claude.com and status.openai.com (status pills, each only while its provider is on), api.anthropic.com (usage and rate-limit figures, with your own token), claude.ai (in-app sign-in and the per-account web session), chatgpt.com (a Codex account's in-app chatgpt.com sign-in and its browser pane view, only when you use them), the GitHub API (opt-in panel, after you sign in), LiteLLM's open-pricing JSON, Sentinel while it is on (off by default: Claude Code's public model list and changelog from support.claude.com and raw.githubusercontent.com, and Codex's public release notes from api.github.com, all read without any sign-in), and Codex's own usage check (chatgpt.com, and with some Codex versions OpenAI's content storage), which runs only when you open the Usage page, press Refresh or use a card's Retry, for a Codex account you added, signed in with ChatGPT, with no session or review on it, with that account's own sign-in. The full list, with what each request carries, is in PRIVACY.md
Data integrity	Atomic config writes; daily snapshots of CONFIG/*.json with 7-day retention; typed IPC with schema validation on every data-bearing channel
Releases	Windows code-signed, macOS signed and notarised, Linux unsigned by convention. Every download verifiable by SHA-256 against CHECKSUMS.txt — the in-app updater checks this on each update — and CI scans installers through VirusTotal

Report vulnerabilities privately via GitHub Security Advisories. See SECURITY.md for scope.

Keyboard shortcuts

Ctrl+T new config · Ctrl+W close session · Ctrl+Tab / Ctrl+Shift+Tab next / previous · Ctrl+1…9 jump to session · Ctrl+B sidebar · Ctrl+/ GitHub panel · Alt+V paste image · F2 rename. Most are rebindable in Settings → Shortcuts; Ctrl+1…9 and Ctrl+/ are fixed. Keys you press inside a session — Escape to interrupt, Shift+Enter for a newline — belong to Claude Code, not to the Conductor.

Contributing & history

Developed privately from late 2025 and open-sourced in April 2026 as Claude Command Center; everything from v1.0 forward is in the open. Per-release detail lives in src/renderer/changelog.ts, which also drives the in-app What's New. See CONTRIBUTING.md for the PR process, and AGENTS.md if you are pointing an AI agent at this repository.

Trademarks

Claude and Claude Code are trademarks of Anthropic, PBC. OpenAI and Codex are trademarks of OpenAI. This project is an independent, community-built tool. All references to "Claude", "Claude Code", "Codex", "Anthropic" or "OpenAI" are nominative, used solely to identify the third-party software this tool interoperates with. AI Code Conductor wraps and orchestrates the official Claude Code and Codex CLIs; it does not include, modify or redistribute their code, and it requires you to install and authenticate those tools yourself under their own terms. If you are a rights holder with a concern about this project's use of a name or mark, please open a GitHub issue or contact the maintainer and it will be addressed promptly.

---

_{AI Code Conductor © Nicholas Moger · MIT · Built on top of the Claude Code and Codex CLIs}