Conductor - Claude Code UIs For Parallel Agents

SUMMARY

A developer tests Conductor, a Claude Code UI for managing parallel agents, comparing it to Verdant AI's superior UX while seeking cost-effective alternatives for efficient coding workflows.

STATEMENTS

The speaker is building an ultimate AI-assisted toolset and has tested various AI agents, with Verdant AI standing out for its exceptional UX in managing parallel agents.
No other tools have matched Verdant AI's overall experience in handling parallel agents effectively.
Claude Code is favored for its pluggability, large community, and integration potential with numerous tools.
The goal is to find graphical UIs that control multiple parallel Claude Code agents, comparing them to Verdant for a similar experience with Anthropic's predictable pricing plans like Claude Pro or Max.
Verdant AI functions as a VS Code extension or standalone app for Mac and Windows, focusing on task delegation and agent review rather than traditional IDE features.
Modern editors like Cursor, Google's new UI, and Try are shifting from IDE-first to agent delegation-first paradigms.
Verdant excels in agent delegation, particularly with git worktrees, allowing seamless task execution across branches without replacing the primary IDE.
Users can delegate tasks like changing a favicon via prompts, which run on main or git worktrees, with dedicated terminals for each.
Verdant provides history views, diff displays, and commit options for changes, streamlining solo workflows and potentially eliminating pull requests.
Minor issues with Verdant include lack of zoom functionality and high credit consumption—33% in two hours on the $20 plan—suggesting it exhausts monthly budgets quickly.
Claude Code appears more cost-effective based on initial experiments, prompting the search for Claude-based UIs mimicking Verdant's experience.
Conductor is the first tool reviewed, built on git worktrees, exciting for its potential to replicate Verdant's UI with Claude.
Sculptor uses containers instead of git worktrees, raising concerns about database integration but offering isolation to avoid port conflicts seen in Verdant.
Crystal is an open-source, MIT-licensed tool from a company possibly focused on Markdown AI, also using git worktrees, providing a free alternative.
Installation of all tools is straightforward via Homebrew or direct downloads.
Conductor requires GitHub login and GitHub CLI setup, supporting both Claude Code and Codex models.
Conductor creates git worktrees for workspaces, allowing parallel agents within shared contexts for flexibility.
Settings in Conductor include model selection (e.g., Claude 3.5 Sonnet), session notifications, keyboard shortcuts, and Git configurations like username prefixes.
File explorer in Conductor supports prompting with comments on specific lines, which are incorporated into agent prompts.
Resuming Claude sessions in git worktrees is challenging due to path dependencies, requiring manual handling or editor switches.
Conductor allocates 10 ports per workspace automatically, enabling scripts to use variables like $CONDUCTOR_PORT for dev servers and databases.
Setup scripts can leverage $CONDUCTOR_ROOT_PATH for project initialization, ignoring files via .gitignore.
Parallel tasks in Conductor demonstrate isolated database operations across workspaces, solving Verdant's shared resource issues.
Plan mode in Conductor visualizes Claude's planning steps nicely, enhancing transparency in complex tasks like UI migrations.
Merge conflicts in Conductor can be resolved by agents, supporting full delegation.
Conductor integrates well with tools like OpenSpec for structured prompting, boosting productivity.
Overall, Conductor provides a strong, productive experience with Claude, though minor UI blurriness and GitHub ties exist.

IDEAS

Verdant AI's UX redefines coding by prioritizing agent delegation over traditional editing, turning development into a review-focused process.
Git worktrees in Verdant enable seamless branching without IDE overhead, mimicking pull request workflows locally for solo developers.
Parallel agents risk resource conflicts, but container-based isolation in tools like Sculptor could minimize shared state issues like port clashes.
Automatic port allocation in Conductor transforms setup scripts into dynamic, workspace-aware automations for dev environments.
Claude Code's community extensibility allows hybrid UIs to blend multiple models, optimizing for cost and capability.
Open-source alternatives like Crystal democratize advanced agent management, potentially accelerating innovation in AI coding tools.
Prompting with file comments injects precise context into agents, bridging human intent and AI execution gaps.
Resuming sessions across git worktrees highlights path-dependency pitfalls in AI tools, suggesting hybrid editor-UI workflows.
Setup scripts using environment variables like $CONDUCTOR_ROOT_PATH enable reproducible, git-ignored configurations for personalized projects.
Visualizing plan modes in UIs makes AI reasoning transparent, aiding debugging in multi-step tasks like schema migrations.
Agent-driven conflict resolution in merges represents true delegation, reducing human intervention in collaborative coding simulations.
Integrating task managers like Linear via APIs could create closed-loop workflows from issue to deployment.
Blending Claude and Codex in one UI leverages diverse model strengths, like Sonnet for delegation and Codex for code generation.
Zero-shot prompting for complex features like org charts yields impressive results, but highlights the need for iterative refinement to avoid bugs.
Non-concurrent execution options in UIs prevent parallel runs from interfering, ideal for resource-constrained setups.
Custom commands in global configs allow tool-specific integrations, like OpenSpec for spec-driven development.
UI blurriness in glassmorphism designs trades aesthetics for performance, a common trade-off in modern apps.
GitHub ties in tools enable CI/CD previews but complicate local merges, balancing collaboration with solo efficiency.
Database isolation via port offsets solves parallel execution risks, enabling true concurrency in agent-driven development.
Experimental features like plan mode previews evolve UIs into interactive AI copilots rather than static interfaces.
Credit efficiency varies wildly across tools, with Verdant's high consumption underscoring the value of model-agnostic UIs.
Agent memory additions personalize prompts, accumulating project knowledge for sustained productivity.
Workspace archiving preserves history without clutter, supporting iterative experimentation in AI-assisted coding.

INSIGHTS

Effective AI coding UIs shift focus from writing code to orchestrating agents, enhancing human oversight in complex projects.
Git worktrees combined with automatic port allocation enable scalable parallel development, mitigating traditional resource bottlenecks.
Model flexibility in UIs like Conductor optimizes costs by switching between providers, aligning AI power with budget constraints.
Isolated environments via containers or ports reduce interference in multi-agent workflows, fostering reliable concurrent execution.
Transparent planning visualizations demystify AI decision-making, building trust and facilitating targeted human interventions.
Open-source tools lower barriers to advanced agent management, spurring community-driven improvements in coding efficiency.
Context injection through file comments and session resumes bridges ephemeral AI interactions with persistent project states.
Agent-resolved merges exemplify full delegation, evolving developers into strategists rather than manual integrators.
Hybrid editor-UIs preserve familiar workflows while layering AI capabilities, easing adoption in established toolchains.
Dynamic setup scripts personalize environments, ensuring reproducibility without compromising git hygiene.
Task manager integrations create seamless pipelines from ideation to deployment, streamlining team AI collaboration.
UI polish, like zoom and clarity, directly impacts sustained productivity, revealing the subtlety of design in AI tools.

QUOTES

"I'm trying to make the ultimate AI assisted uh tool set and I've been testing a lot of different AI agents and tools and whatnot and the one that blew my mind the most was Verdant AI."
"Claude Code is uh one of the most pluggable because it has a huge community. There's a lot of things you can integrate with it."
"Verdant excels in agent delegation, particularly with git worktrees, allowing seamless task execution across branches without replacing the primary IDE."
"In 2 hours of coding, even though I was really really productive... I used uh like 30 33% of my credits."
"Conductor has this really interesting feature where they distribute uh ports. actually distribute 10 ports for each one."
"This is total delegation and yeah and I like it."
"I think this plus something like openspec or bmad or something can be really amazing."
"The conductor port thing is really great... this solves one of the main drawbacks that I had with Verdon."
"I'm already sold on using conductor. I think this is really good."

HABITS

Delegate simple tasks like favicon changes via prompts to agents before manual review in a preferred IDE.
Use git worktrees for isolated branching, checking out pull requests directly to test changes without main branch disruption.
Archive completed workspaces to maintain clean interfaces, restoring only when needed for historical review.
Incorporate file comments into prompts for precise agent instructions, addressing specific lines to guide modifications.
Run setup scripts automatically on workspace creation, using environment variables for dynamic port and path configurations.
Switch between models like Claude and Codex based on task needs, leveraging global commands for quick access.
Merge changes locally after agent tasks, using git commands to avoid GitHub dependency for solo work.
Enable plan mode for complex migrations to visualize steps, iterating on AI plans before execution.
Test parallel tasks with isolated databases, validating via dev servers on allocated ports to ensure no conflicts.

FACTS

Verdant AI's $20 plan consumes about 33% credits in two hours of intensive parallel agent use.
Conductor allocates exactly 10 ports per workspace, starting from a base like 55000 for dev servers and offsets.
Claude 3.5 Sonnet is recommended for delegation tasks due to its balanced thinking level.
GitHub CLI is required for Conductor's repository cloning and authentication flows.
Crystal is MIT-licensed open-source from a company potentially specializing in Markdown AI tools.
Modern editors like Cursor and Try incorporate agent panes, signaling an industry shift from IDE to delegation focus.
Sculptor's container approach avoids git worktrees, potentially complicating Docker-in-Docker for databases.
Conductor supports both Anthropic's Claude and OpenAI's Codex models in the same interface.
Agent sessions in Conductor can run non-concurrently to kill overlapping processes in other workspaces.

REFERENCES

Verdant AI (UI for parallel agents, VS Code extension/Mac/Windows app).
Claude Code (Anthropic's AI model, Pro/Max plans).
Cursor (editor with agent delegation pane).
Google's new UI (agent-focused editor pane).
Try (editor with similar agent features).
Zed (preferred IDE for diffs, commits, and editing).
GitHub CLI (for authentication and repo operations).
Codex (OpenAI model supported in Conductor).
Sculptor (container-based Claude UI, beta free, plans to charge).
Crystal (open-source MIT-licensed Claude UI from Travel company).
Homebrew (installation method for tools).
Linear (task manager for issue integration and MCP).
OpenSpec (tool for spec-driven development and prompting).
Bmad (mentioned as potential integration tool).
Docker Compose (for database and service setups).
PNPM (package manager used in project examples).
Prisma (schema for database migrations).
Code Rabbit (GitHub bot for PR reviews).
Next.js (framework in demo project for UI tasks).

HOW TO APPLY

Install Conductor via Homebrew with brew install --cask conductor for quick setup on Mac.
Authenticate using GitHub login and ensure GitHub CLI is configured for seamless repo access.
Clone a repository by pasting the SSH URL into Conductor's interface, creating a new git worktree automatically.
Configure settings like default model to Claude 3.5 Sonnet and enable session notifications for better workflow awareness.
Add file comments in the explorer to guide agents, ensuring prompts include specific line references for targeted changes.
Create a conductor.json file in your repo root to define setup scripts, using variables like $CONDUCTOR_PORT for dynamic ports.
Run setup scripts on workspace creation by committing them to the repo, verifying output via terminal cat setup.out.
Delegate parallel tasks by creating multiple agents in one workspace, monitoring via the UI for isolated executions.
Resolve merge conflicts by prompting the agent directly in Conductor, allowing automatic fixes before manual review.
Integrate custom commands like OpenSpec via global MCP settings, applying specs to workspaces for structured development.

ONE-SENTENCE TAKEAWAY

Conductor delivers Verdant-like parallel agent management for Claude Code, boosting productivity with isolated ports and seamless delegation.

RECOMMENDATIONS

Adopt Conductor for Claude-based workflows to achieve Verdant-level UX without high credit costs.
Use git worktrees in UIs to simulate pull requests locally, streamlining solo development.
Implement automatic port allocation in scripts for concurrent dev servers and databases.
Enable plan mode for visualizing AI steps in complex tasks like UI migrations or schema changes.
Integrate task tools like Linear to pull context into agents, creating end-to-end workflows.
Switch models between Claude and Codex to optimize for delegation versus generation needs.
Customize setup scripts with root paths for reproducible, git-ignored project environments.
Test non-concurrent execution for resource-heavy projects to avoid parallel interference.
Add file comments routinely to inject precise instructions, enhancing agent accuracy.
Resolve conflicts via agent prompts to minimize manual git interventions.
Explore open-source Crystal as a free starting point before committing to closed tools.
Pair Conductor with OpenSpec for spec-driven prompting in structured coding sessions.
Monitor session contexts closely, copying run outputs manually until UI improvements.
Disable unnecessary GitHub bots like Code Rabbit for faster PR merges in personal repos.
Experiment with container UIs like Sculptor for full isolation in team environments.

MEMO

In the quest for the ultimate AI-assisted coding toolkit, a developer embarks on a rigorous evaluation of graphical interfaces designed to harness Claude Code's power for managing multiple parallel agents. Inspired by Verdant AI's mind-blowing UX—which prioritizes task delegation over traditional editing—the creator seeks affordable alternatives that replicate its seamless git worktree integration and review-focused workflow. Verdant shines in isolating branches via dedicated terminals, allowing effortless diffs, commits, and even automatic code reviews, but its steep credit consumption (33% in just two hours on the $20 plan) underscores the need for Claude's more economical models like Pro or Max.

Enter Conductor, the first contender in this three-part series, a tool that builds on git worktrees to orchestrate agents with impressive flexibility. Launching via Homebrew, it requires GitHub authentication and CLI setup, supporting both Claude and OpenAI's Codex for hybrid capabilities. The interface impresses with customizable settings—defaulting to Claude 3.5 Sonnet for delegation—and features like session notifications and keyboard shortcuts (Command-Enter to send prompts). Workspaces spawn isolated git branches, enabling parallel agents within shared contexts, while the file explorer allows inline comments that feed directly into prompts, ensuring precise AI responses.

A standout innovation is Conductor's automatic port allocation: each workspace gets 10 dynamic ports (e.g., $CONDUCTOR_PORT for dev servers, offsets for databases), solving Verdant's shared-resource pitfalls. In a demo project—a Next.js expense tracker—the developer crafts a conductor.json setup script to compute ports for web, database, and email services via Docker Compose. Committing this to the repo triggers automatic execution on new workspaces, generating .env files with interpolated values and running migrations seamlessly. This enables true concurrency: one agent adds a message board with isolated Postgres on port 5501, another implements org chart groups on 5502, without clashes.

Parallel tasks reveal Conductor's strengths in delegation. Prompting zero-shot for features like user groups yields functional schemas and routers, though iterations fix bugs like missing UI components. Plan mode visualizes Claude's step-by-step reasoning for migrations—such as porting to Mantine UI—rendering it in a clean, interactive format. Merge conflicts arise naturally in concurrent edits, but agents resolve them adeptly, creating PRs or local commits. Shortcuts like Command-R to run/stop servers and one-click opens to localhost previews enhance the flow, though resuming sessions across worktrees demands manual path handling.

Despite minor gripes—blurry glassmorphism UI, tight GitHub reliance complicating local merges, and run output not auto-injecting into contexts—Conductor delivers a productive experience. It outperforms Verdant in cost-efficiency and isolation, allowing creative port extensions for complex projects. For teams, Linear integration could pull issues into workspaces, while solo users benefit from OpenSpec for spec-driven prompts. As the developer archives workspaces and pushes changes, the tool proves a worthy Claude companion, hinting at a future where AI UIs evolve developers into conductors of automated symphonies.

Closing thoughts affirm Conductor's edge: it's "really good" for Claude enthusiasts, blending model switching to dodge limits and fostering experimentation. Upcoming reviews of container-based Sculptor and open-source Crystal promise further insights, but this debut episode already sells the vision of parallel agents as the new coding paradigm—intuitive, isolated, and infinitely scalable.