CodeConductor Puts a GUI on Top of Your Coding Agent

A fork of AionUI that treats Claude Code, Codex, and Goose as interchangeable backends, and bets the command line is not going anywhere.

8 min read • View on GitHub • More from zhu1090093659

A wide editorial illustration of a conductor's podium at the center of a stage. Instead of an orchestra, a neat row of small CRT-style terminal windows sits on the podium, each with a blinking cursor. The conductor, seen from behind with minimal detail, holds a baton rendered as a single vertical line, and thin cables run from the podium down into each terminal. Small identical GUI window frames are bolted onto the fronts of the terminals like faceplates added to old machines. The image explains CodeConductor's thesis: a graphical workspace that directs existing command-line agents rather than replacing them.
The conductor does not play the instruments. It directs them. CodeConductor is a workspace that points and conducts the CLI agents you already have installed.
Key Takeaways

The Wrapper Bet

Most AI coding apps want to own the entire stack. Cursor bundles an editor, a model router, and an agent loop. The provider web apps keep the model in their cloud and the loop behind their login. CodeConductor does the opposite. It refuses to build a model loop at all.

The app is an Electron desktop shell that wraps CLI coding agents you already have installed. Claude Code, Codex, Qwen Code, and Goose stay exactly where they are: as command-line processes on your disk. CodeConductor detects them, launches them, and drapes a workspace around them. Sessions, diffs, file previews, and a chat surface sit on top. The agent underneath never changes.

That is the bet. The command line is not a transitional phase waiting to be replaced by a polished IDE. It is a stable substrate, and the missing piece is a good cockpit. For a developer who already lives in Claude Code, the app is a second window onto work they already do. For someone who has never opened a terminal, it is a guided front door.

Auto detection and unified UI - Recognize local CLI tools and bring them into one interface.

CodeConductor project, GitHub repository / project description · zhu1090093659/CodeConductor

The codebase backs up the framing. The main process pulls in node-pty for real PTY-backed terminals, better-sqlite3 for local conversation storage, and the MCP SDK for tool integration. There is no inference stack, no tokenizer, no prompt cache. Those belong to the agent, and the app is happy to leave them there.

The Question Mark in the Machine

Wrapping a terminal agent in a GUI runs into one stubborn problem. A CLI agent can ask a question, but only as text. "Delete build/ and 42 files inside it?" prints to the terminal and blocks on standard input. Inside a graphical app, that line has nowhere to land. There is no dialog, no button, no visible prompt. The agent is waiting, and the user cannot see what for.

CodeConductor solves this with a small prebuilt MCP server called popup-mcp. Binaries ship for Linux, macOS, and Windows under resources/bin/popup-mcp/. The agent gets a tool it can call to reach out of its own process and open a native dialog in the host application.

The exact tool name and payload are not documented in the sources, so treat the following as an illustration of the pattern rather than an exact call.

{
  "tool": "popup_prompt",
  "arguments": {
    "title": "Confirm file deletion",
    "message": "Delete build/ and 42 files inside it?",
    "buttons": ["Cancel", "Delete"]
  }
}

The mechanics are the interesting part. The agent is a separate operating-system process. It cannot touch Electron's renderer directly, and it should not be able to. So the call travels a chain: the tool call reaches the MCP server, the server relays it over IPC into the Electron main process, the main process asks the renderer, and a real modal appears. The user's answer travels back down the same chain. It is an out-of-process round trip, and that is precisely why it works. The agent can stay isolated and still be interactive.

A tight close-up editorial illustration of a single terminal window. A solid, physical question mark fills much of the frame next to a blinking cursor. A thin articulated mechanical arm reaches out of the terminal's screen surface, holding the question mark forward. Its pincer is about to press a small physical button marked with a checkmark that sits on a graphical dialog panel floating just outside the screen. The image explains how a text-only CLI agent reaches out of its process to open a native dialog in the graphical host.
The agent physically reaching out of its process to press a button in the GUI. That gesture is what popup-mcp makes possible.

The popup bridge, step by step. The agent emits an MCP tool call, the popup-mcp server relays it through IPC into Electron's main process, a native dialog appears in the renderer, and the answer travels back to the agent. The tool name and payload are illustrative; the round trip is the point.

One Crash, One Process

The main process bundle has four webpack entries: index, worker, acp, and codex. The last two are separate bundles for the ACP and Codex adapters. That split is a reliability decision, not an accident of build layout.

Each agent adapter runs in its own worker process. If the Codex adapter crashes mid-session, it takes down its own worker and nothing else. The UI stays up, the other sessions keep running, and a fresh worker can be started. The changelog's references to worker process management and orphaned process cleanup line up with exactly this design: keep the fragile part isolated, and make sure its leftovers get reaped when it dies.

The path aliases reinforce the same layering. @common holds shared code, @process is the Node side, @worker is the adapter space, and @renderer is the browser side. The boundaries are enforced at build time, which keeps a crashing adapter from quietly dragging renderer code into its process.

The Fork and the Person

CodeConductor is an enhanced fork of AionUI, an open-source desktop chat UI for CLI agents. The maintainer is zhu1090093659, who is also the top contributor to the repository. The fork keeps AionUI's foundation and layers coding-specific workflow on top.

This fork focuses on making command-line coding agents easier to use in real projects and daily work:

CodeConductor project, GitHub repository / project description · zhu1090093659/CodeConductor

The fork-specific additions are where the coding focus shows. There is role collaboration across PM, Analyst, and Engineer personas, explicit approvals for high-impact actions, slash commands, project-oriented sessions, and review-oriented previews and diffs. The assistant/ directory carries Markdown persona definitions in English and Chinese, and the skills/ directory holds skill folders with their own SKILL.md files. These are project-stated capabilities; the sources do not independently verify performance in production.

瓦砾酱的AionUI二次开发了CodeConductor(简称CC )。

WindTraveler, Author of a locdd project post; relationship to the GitHub maintainer not independently confirmed · locdd.com forum post

A locdd forum post describes the project the same way, calling it a further development of AionUI and highlighting commands, skills, and multi-agent collaboration. The post is signed @WindTraveler, but the supplied sources do not establish that this account is the GitHub maintainer, so it is cited as a forum post rather than as a maintainer statement.

The Tax of Shipping Electron

The build is where the romance ends and the invoices arrive. Native modules cannot be read from inside an asar archive, so each one has to be unpacked at install time. The asar.unpack list reads like a bill of materials:

Notarization is the second invoice. The packaging config excludes vendor directories to "prevent unsigned binaries," then re-includes three of them for better-sqlite3, bcrypt, and node-pty, because macOS notarization fails when unsigned Mach-O binaries are bundled. Native tree-sitter binaries are excluded entirely and the WASM variant is kept instead, again to avoid signing problems. The build uses Electron Forge for compilation and electron-builder for packaging, signing, and publishing, and the split is documented directly in the config:

// forge.config.ts
// "Forge is only used for compilation in hybrid setup.
//  Signing and notarization handled by electron-builder"

There is grit here that rarely makes it into a feature list. The 1.7.6 changelog documents a 404 on latest.yml, the auto-update manifest, which is the kind of bug you only find by shipping. The unpack lists live in two places, forge.config.ts and electron-builder.yml, and they are similar but not identical, which is a maintenance risk waiting to bite. This is what it actually costs to ship a desktop app with native dependencies, and CodeConductor pays it in full.

Where It Sits

The clean way to place CodeConductor is as a layer, not a replacement. It does not compete with Claude Code or Codex; it hosts them. It does not compete with Cursor's editor; it sits beside it. The distinction that matters is who owns the model loop and where the agent process runs.

ProjectCategoryOwns the model loop?Where the agent runsBest for
CodeConductorDesktop workspaceNoLocal CLI processesMulti-agent, project-oriented work in real repos
AionUIDesktop chat UI (upstream)NoLocal CLI processesGeneral chat-first agent UI
CursorAI IDEYesIn-editorEditing inside an IDE
Claude Code / Codex / Goose / Qwen CodeCLI agentsYesTerminalTerminal-native users
Provider web UIsHosted web appYesProvider cloudProvider-locked, no local setup

A caveat: star counts and independent benchmarks are not asserted here, and the supplied sources do not establish that CodeConductor uniquely provides multi-agent collaboration, approvals, or previews across the whole market. The defensible distinction is architectural. It is the combination and the integration target, not a claim that nobody else has any of these parts.

One naming hazard worth flagging. A broader essay on agent-development environments discusses a product called Conductor, alongside Cursor, Codex, and Claude. That essay is market commentary and is not about CodeConductor. The two share a word and nothing else, so do not read the essay's criticisms of the other Conductor onto this project.