Singularity vs Conductor: steering agents by workspace or by ticket

Conductor is a Mac app for developers who use Claude Code or Codex every day and want to run several at once. Each task gets its own workspace, with its branch, files, terminal and diff, and the flow ends in a GitHub pull request. It mainly targets teams whose review already happens on GitHub.

Singularity shares the core mechanics (one agent, one worktree, one branch) but puts them under a Kanban board: the ticket is the agent’s mission, with dependencies, child tickets, a report and file-by-file review, followed by local integration by rebase. The choice is about how you steer: a list of workspaces that end as PRs, or a queue of tickets that land in a controlled order.

Comparison checked on 10 October 2026 against Conductor’s official documentation and Singularity’s own docs. It compares workflows; it does not benchmark speed or the quality of generated code. Public prices in USD/EUR as displayed, excluding taxes and AI provider usage; they may change.

In short

• Same isolation: one Git worktree and branch per task, with CLI agents using your own accounts.
• Conductor centres on the workspace and the PR: start from a GitHub or Linear issue, comment in the diff viewer, use the Checks tab, with cloud workspaces and collaboration on paid plans.
• Singularity centres on the ticket: dependencies, child tickets, a scheduler, a report, file-by-file review, rebase and a commit queue.
• Platforms: Conductor is macOS-only (plus an iOS app); Singularity ships macOS, Windows and Linux packages.
• Price: Conductor’s local workspaces are free and cloud starts at 50 USD a month; the Singularity app is free and only its paid-plugin licence is billed.

What Conductor is

On its official site, Conductor describes itself as a Mac app that creates parallel Claude Code, Codex and Cursor agents in isolated workspaces; its documentation adds OpenCode. Each workspace is a copy of the project created with Git worktrees, on a new branch starting from the latest remote commit of the base branch. A .context folder holds notes and handoffs without being committed. Agents run on your Mac with your permissions, and the docs state that this isolation is not a security boundary. Several agents can also share one workspace (parallel agents).

setup, run and archive scripts are defined in the app or in .conductor/settings.toml. Conductor reserves ten ports per workspace through CONDUCTOR_PORT, and a non-concurrent mode avoids collisions when a project relies on a fixed port or a local database (scripts).

The documented workflow starts from a branch, a PR, a GitHub issue or a Linear issue. You chat with the agent (in Plan Mode if needed, see agent modes), ask for an agent review, read the changes in the diff viewer, where line comments go back to the agent, then create the PR, whose description the agent drafts (review and merge). The Checks tab gathers CI, GitHub review threads and todos, and may discourage a merge while required work is open.

Installation requires GitHub (gh auth status) and at least one agent provider; Conductor is not yet available for Windows or Linux. The changelog shows a fast pace: version 0.90.0 on 2 October 2026 brought Conductor for iOS, alongside Sign in with ChatGPT, editing directly in diffs and a Conductor MCP server. On pricing: Free at 0 USD for local workspaces with your own subscriptions and keys; Pro at 50 USD a month with cloud workspaces (Vercel sandboxes), collaboration with up to five Pro users, the API and the mobile app; Teams at 60 USD per user per month; Enterprise on quote. Cloud compute carries no extra fee for now, but usage-based pricing is announced.

Singularity in a nutshell

Singularity is a desktop ADE (Agentic Development Environment) from Meteor Factory: an editor with language servers, native terminals, a Git client (graph, diffs, stash, worktrees), multi-project workspaces and a Kanban board that is the execution surface for agents. A ticket carries the description, priority, dependencies and agent configuration; the board shows status and live activity, and the ticket keeps the report, blockers and a short resolution.

In worktree mode, each run works in its own Git worktree; commits are replayed onto the base by rebase, an integration queue orders tickets within a project, and the result is integrated automatically or waits in the Review tab. Singularity drives seven providers through their CLIs (Claude Code, Codex, Copilot, Cursor, Gemini, Mistral, Ollama) with your accounts; the orchestration guide covers an agent’s lifecycle. The app is free; the Singularity Licence (24 EUR per month per workstation, 14-day trial) only unlocks paid plugins in the Marketplace, such as Pipelines. It is proprietary software, available on macOS, Windows and Linux (installation).

Comparison table

The same feature in both tools

Take a CSV export of invoices: a server-side endpoint, then a client-side button that calls it.

In Conductor, you might start from a Linear issue and create one workspace for the endpoint and another for the button. The setup script installs dependencies and each workspace has its own port range. You can ask for a plan before any edit. Since the docs do not describe a formal dependency between workspaces, ordering is up to you: an API contract in the prompt, or waiting for the endpoint to be merged. Each workspace ends with a review, a PR, green checks, a merge and archiving.

In Singularity, the “button” ticket is marked Blocked by the “endpoint” ticket. The scheduler runs the endpoint, waits for its integration, then starts the button on a base that already contains the API. The card shows the agent’s phase; a blocking question puts the ticket on hold until you answer; the agent finishes with a report. With auto-merge off, you approve each file, annotate or relaunch with feedback, then integration happens by rebase.

In both tools, success depends first on the prompt and the tests. Conductor takes you to the PR and remote CI; Singularity to an updated base branch, ticket by ticket.

Tracking, review and integration

In Conductor, the visible unit is the workspace: born from a branch, PR or issue, it lives in the sidebar, then moves to the history once archived. Planning and priorities stay in GitHub or Linear, which suits a team that already runs its backlog there. The end of the cycle follows the pull request: GitHub comments sent back to the agent, checks, and a merge once the PR is approved. For a team that already enforces PRs and CI, the path is short.

In Singularity, the visible unit is the ticket, and the board is the queue. Statuses separate an active run, an explicit wait and a retryable failure; a parent can wait for its child tickets, then synthesise their results; the scheduler picks the next ready ticket based on dependencies, priority and the agent limit. Integration is local: per-file approval, partial merge, rebase and a commit queue. You then push to your forge; with the paid Pipelines plugin you follow GitHub Actions, GitLab CI or Azure DevOps in the app. Either way, run the tests after every integration: a clean rebase or a green PR does not rule out a semantic conflict.

Local, cloud and platforms

Both tools run agents on your machine with your accounts; prompts and code excerpts go through the provider you choose, except with a local model through Ollama in Singularity. From Pro, Conductor adds cloud workspaces, live collaboration, an API and an iOS app. Singularity offers neither hosted cloud execution nor a mobile app: it stays a desktop application, with its data in a local SQLite database. On the other hand, Conductor is not yet available for Windows or Linux, while Singularity ships packages for both: for a mixed team, that is often decisive.

Where Conductor is stronger

• Full GitHub cycle: workspaces created from a PR or issue, PR drafted with the agent, Checks tab.
• Cloud and collaboration: cloud workspaces, live collaboration, an API and an iOS app on paid plans.
• Port handling: ten ports per workspace and a non-concurrent mode.
• OpenCode: access to the models configured in OpenCode.
• Release pace: several releases a week according to the changelog.

Where Singularity stands out

• The ticket as a mission: dependencies, child tickets, a scheduler and a concurrent-agent limit.
• Fine-grained local review: per-file approval, notes, partial merge, rebase and a commit queue.
• More providers: Copilot, Gemini, Mistral and Ollama on top of Claude Code, Codex and Cursor.
• Complete environment: editor, language servers, terminals and a Git cockpit.
• Platforms and price: macOS, Windows and Linux, and a free app with no limit on agents or worktrees.

Can you use both?

Yes, on a Mac, as long as the two tools never manage the same branch. Both work on ordinary Git repositories and drive the same Claude Code, Codex and Cursor CLIs. You could keep Conductor for tasks that start from a GitHub issue and end as a PR, and Singularity for work split into dependent tickets. Git does not allow one branch in two worktrees: let each tool create its own branches.

Which tool should you choose?

• A Mac team with GitHub PR review and mandatory CI: Conductor.
• You need cloud workspaces or live collaboration: Conductor Pro or Teams.
• Work split into dependent tickets with a report per mission: Singularity.
• Windows or Linux machines: Singularity.
• Copilot, Gemini, Mistral or local models through Ollama: Singularity.

See also Singularity vs Superset, another parallel-agent manager, or Singularity vs Claude Code.

Trial protocol

1. Pick a repository with tests and a feature in two dependent parts.
2. Use the same agent (for example Claude Code) in both tools.
3. In Conductor, create two workspaces with a setup script; in Singularity, two tickets linked by “Blocked by”, with auto-merge off.
4. Track your interventions: questions, relaunches, handling the order.
5. Review, integrate (PR on one side, rebase on the other), then run the full test suite on the base branch.
6. A week later, check what is still easy to find: PRs and archived workspaces, or tickets and reports.

Frequently asked questions

Does Conductor run on Windows or Linux?

Not as of 10 October 2026: its installation page says it is not yet available for those systems. Singularity ships macOS, Windows and Linux packages.

Do I pay for models on top?

Yes, in both cases. Conductor’s free plan uses your own subscriptions and keys, and Singularity drives your providers’ CLIs with your accounts.

Does Conductor require GitHub?

Its installation page says you need GitHub and at least one agent provider. Singularity does not require a particular forge: it integrates locally and you push wherever you like.

Are worktrees enough to avoid conflicts?

They stop two agents from writing to the same working files. Git or semantic conflicts can still appear when the PR is merged in Conductor, or at rebase time in Singularity; tests and review remain essential.

To go further, browse all Singularity comparisons, follow the getting started guide or download Singularity.