Conductor vs OpenHands: Who Controls the Review Loop?
Compare Conductor workspace review with OpenHands independent acceptance, plus execution environments, automations and published pricing.
Founder, Task Machine
Conductor and OpenHands give you a choice about who operates the code-review loop. Conductor keeps review actions, comments and merge-readiness signals beside the coding workspace. OpenHands documents a software factory that separates implementation from an independent reviewer and requires current acceptance for the exact proposed revision.
For a developer supervising several changes, the deciding question is whether you want to request and interpret each review or configure a process that demands fresh evidence after revisions. Both products publish tests and recurring automation. Their review boundaries are more useful to compare than a simple feature checklist.
A workspace you can steer directly
Conductor's workflow guide describes coding workspaces with test actions, diffs and pull-request feedback. Plan Mode lets you inspect an approach before files change. Inline review comments go back to the agent, and Checks collects continuous integration status and unresolved work before merge.
Repository-specific review preferences guide the Review action. You can ask a different model to inspect a proposed fix and open another session to challenge its approach. This gives a hands-on developer several ways to question a change without leaving the workspace model.
Conductor's public docs do not describe a change-level risk rating before merge. Collected checks and review comments give you evidence, but they should not be represented as that overall rating. The important evaluation is whether your own review procedure asks for the evidence your change needs.
A factory with separate implementation and review
OpenHands combines a coding agent, Agent Canvas and a Python SDK. Its software-factory guide defines triage, development, independent review and conditional merge through automations. The reviewer uses a separate token that cannot push code.
That reviewer checks and tests the exact pull-request revision. A changed commit needs fresh acceptance, and a watchdog requires the current independent statuses before merge. For a team that wants the review boundary expressed in automation, these are concrete controls to inspect.
Canvas also supports objective-driven conversations in which a judge identifies missing work and returns it to the agent. Those completion checks assess a run's objective. Its public docs do not describe them as an owned business goal with an ongoing tracked metric and target.
How a second opinion becomes a gate
Conductor's review and merge guide describes repository review guidance and returning feedback to the agent. Its second-review examples are user-directed. You decide when another model should challenge a fix and what to do with its findings.
OpenHands places independent acceptance inside the documented factory process. Repository-specific review rules can be added as a skill alongside its default code-review framework. The separate reviewer and fresh-revision requirement connect those checks to delivery.
For a small change you are already examining, a requested second opinion may fit your process. For unattended issue delivery, inspect whether an amended commit can move forward using evidence from an earlier revision. OpenHands explicitly documents requiring new acceptance, while Conductor's published second-review example depends on your intervention.
Recurring work and the evidence it leaves
Conductor supports Cloud routines on schedules, GitHub actions and webhooks. Its API documentation describes a saved prompt opening a fresh workspace for an incoming request. Setup scripts, named run actions and archive scripts repeat parts of the repository lifecycle.
OpenHands' automation guide describes scheduled and event-driven runs with configuration, status and recent history in the Automate view. Script automations can execute a saved bundle directly, without starting an agent conversation. Its factory uses automations to connect the engineering stages.
There is a retention boundary worth testing before relying on script output as your review evidence. On OpenHands Cloud backends, script logs become unavailable when the run's sandbox is deleted, and the docs advise opening them while the run is in progress. A successful run status alone should not be your plan for retaining the detail you need to inspect.
Where execution runs and what access costs
Conductor's Cloud FAQ distinguishes local Mac sessions from managed Vercel sandboxes. Cloud sessions continue with the app closed, and customer-owned cloud machines are not supported yet. Cloud supports GitHub repositories, with other Git hosts directed to local workspaces.
OpenHands' Canvas overview describes backends on your machine, in Docker, on a virtual machine or in managed Cloud. That matters if the execution environment is part of your engineering setup. Canvas accepts provider API keys and can reuse a signed-in ACP agent subscription when the backend shares its machine.
Conductor says your selected provider account or subscription covers model usage. Its general FAQ calls the tool free, while the Cloud FAQ names Pro, Teams and Enterprise without paid amounts and describes compute billing as a future change. Confirm current terms for the workspace type you intend to use.
OpenHands' pricing page lists Canvas as free to self-host and self-hosted Teams at $500/month for up to 10 users, plus $50/month per additional seat, with a 5,000-session monthly cap. Free Canvas uses a single user or shared identity. Cloud model usage uses credits, and the public pricing page does not give a managed Cloud plan amount, so do not treat the self-hosted team figure as a Cloud quote.
Conductor and OpenHands, point by point
The table presents both products' answers to the same questions, including the source and check date for each. Read the explanations alongside the labels to distinguish user-directed reviews from an independent acceptance gate.
Both columns answer the same questions from each company's public pages. Yes means the company publishes the capability the question asks about, Partly means something narrower, No means it says it does not offer it, and Not published means its public pages do not describe it. Every answer links to its source and shows when we last checked it. The oldest check on this page was November 13, 2026.
| What you compare | Conductor | OpenHands |
|---|---|---|
| Goals |
Conductor
Partly
Local Codex sessions can pursue a standing objective, with status and optional token-budget usage shown above the chat. Its docs do not describe tracking outcome metrics or targets against that objective. |
OpenHands
Partly
Canvas runs an objective through an agent and a judge until completion or an iteration limit. Its docs describe completion scores rather than an owned goal with a tracked metric or target. |
| Leads |
Conductor
Partly
The API cookbook gives an external agent a Conductor manager role to supervise coding sessions and steer stalled work. Its docs do not establish a lead assigned to a project, goal or team. |
OpenHands
Partly
The daily-work agent prioritizes development work and dispatches separate agents, while factory triage checks issue dependencies. Its docs describe these workflows rather than named lead roles over projects, goals or teams. |
| Tasks |
Conductor
Partly
Each coding task gets a workspace with chats, branch and review history, and Cloud workspaces can be reassigned to teammates. Its docs do not establish assigning workspace ownership to an agent. |
OpenHands
Partly
Conversations retain their own history and agent configuration, and the daily workflow gathers assigned GitHub issues. Its docs do not establish a shared work record that either a person or an agent can own. |
| Recurring work |
Conductor
Yes
Cloud routines run agents on schedules or GitHub actions, and webhook routines run a saved prompt in a fresh workspace for each incoming request. |
OpenHands
Yes
Canvas automations run on schedules or matching webhook and service events. The Automate view shows their configuration, recent run history and status. |
| Workflows |
Conductor
Yes
Repository setup scripts repeat sequences such as installing dependencies, copying environment files and building each new workspace. Named run actions and archive scripts cover the rest of the coding-project lifecycle. |
OpenHands
Yes
The software factory defines triage, development, independent review and conditional merge as four automations. Script automations can execute a saved bundle directly instead of starting an agent conversation. |
| Autonomy |
Conductor
Partly
Tool approvals are configurable user settings, and local tool calls can pause before shell commands, file changes or MCP tools run. Its docs do not describe collecting those requests into an approval queue. |
OpenHands
Yes
SDK confirmation policies require approval for all actions, risky actions or none. Pending actions are collected for confirmation and can be rejected with feedback through a custom confirmation handler. |
| Learned autonomy |
Conductor
Not published
Its docs describe configurable approvals and durable repository instructions, but no proposals to change an agent's permissions based on your approval history. |
OpenHands
Not published
Its public docs describe configured confirmation policies and feedback-led skill improvement. They do not describe proposing permission changes from your approval history. |
| Memory |
Conductor
Partly
Repository preferences, instruction files and skills preserve editable guidance for later sessions. Its docs do not describe inspectable memories learned from previous runs. |
OpenHands
Yes
Opt-in persistent memory stores agent-maintained user and project notes in Markdown files loaded into later conversations. You can review, edit or delete those files. |
| Planning |
Conductor
Yes
Claude Code and Codex Plan Mode produce a plan before editing files. You can approve the approach or give feedback before moving into implementation. |
OpenHands
Yes
The daily-work guide has you discuss a failing check, ask for a proposed fix and approve its plan before implementation. That review boundary is expressed through conversation instructions. |
| Intake |
Conductor
Yes
The HTTP API creates workspaces and sends prompts to coding agents. A webhook routine binds incoming JSON to a saved prompt, project and selected agent. |
OpenHands
Yes
Signed webhook payloads are routed to automations by event name and optional filters, then added to the agent's prompt. Automations can select an Agent Profile on supporting backends. |
| Connectors |
Conductor
Yes
Agents use custom local or remote MCP servers, while the HTTP API supports workspace automation and webhook-triggered routines. MCP configuration follows the selected coding agent. |
OpenHands
Yes
Canvas connects MCP servers for external tools and data, while custom webhook sources accept HTTP payloads and trigger matching automations. Some service signature formats need a validating relay. |
| Models |
Conductor
Partly
You choose a model from Claude Code, Codex, Cursor or OpenCode, and the API recommends passing an explicit model. Its docs do not describe automatic model selection per task or step. |
OpenHands
Yes
The SDK's optional task-routing tool uses a classifier model to select a saved model profile from the current conversation. The agent decides when to request a switch, and routing configuration defines the candidates. |
| Cloud or your own computer |
Conductor
Yes
Local sessions run on your Mac, while Cloud sessions run in managed Vercel sandboxes and continue with the app closed. Customer-owned cloud machines are not supported yet. |
OpenHands
Yes
Canvas can connect to a backend on your machine, in Docker, on a virtual machine or in managed OpenHands Cloud. You choose the execution environment and the workspace it can access. |
| Your own subscription |
Conductor
Yes
Claude and Codex subscriptions or provider API keys cover model usage, including in Cloud workspaces. Conductor says it does not bill or resell model usage. |
OpenHands
Yes
Canvas accepts provider API keys and can reuse a signed-in ACP agent subscription when the backend shares its machine. The SDK also documents ChatGPT Plus or Pro access to Codex models. |
| Pricing |
Conductor
Not published
The general FAQ calls Conductor free, but the Cloud FAQ names Pro, Teams and Enterprise without amounts. It describes usage-based compute pricing as future, so current paid rates and billing basis are not published. |
OpenHands
Yes
Cloud model usage uses credits. Canvas is free to self-host. Self-hosted Teams costs $500/month for up to 10 users, plus $50/month per additional seat, with a 5,000-session monthly cap. Enterprise has custom pricing. |
| Correctness |
Conductor
Yes
Workspace actions run tests, and Checks gathers CI status and unresolved work before merge. The API cookbook also instructs a supervising agent to review results against an implementation brief and request fixes. |
OpenHands
Yes
Goal runs use a judge to check completion and send missing work back to the agent. The software factory establishes acceptance criteria, runs relevant tests and requires passing independent statuses for the exact revision before merging. |
For software work
| What you compare | Conductor | OpenHands |
|---|---|---|
| Code review rules |
Conductor
Yes
Repository-specific Code review preferences guide the Review action, which asks an agent to inspect the current diff. You write the guidance in Repository Settings. |
OpenHands
Yes
You can add repository-specific review rules as a skill that runs alongside the default code-review framework. The documented example covers approval decisions, lint conventions and test locations. |
| Adversarial review |
Conductor
Yes
The homepage demonstrates asking a different model to review a proposed fix for risks, then opening another session to challenge its approach. This is user-directed second review, not an automatic risk-triggered gate. |
OpenHands
Yes
The software factory uses an independent reviewer with a separate token that cannot push code. It reviews and tests the exact pull-request revision, and the watchdog requires current independent acceptance before merge. |
| Risk rating |
Conductor
Not published
Checks gathers merge-readiness signals such as CI, comments and todos. Its docs do not describe a risk rating of the change before merge. |
OpenHands
Partly
The SDK rates individual actions LOW, MEDIUM, HIGH or UNKNOWN before execution. Its docs describe action security ratings rather than a risk rating of the whole change before merge. |
| Pull requests |
Conductor
Yes
Agents draft pull requests, receive inline review comments, fix failing checks and prepare branches for merge. Checks and the Diff Viewer keep GitHub review feedback with the workspace. |
OpenHands
Yes
Factory agents turn GitHub issues into pull requests, receive native reviews and revise failed changes. A changed commit needs fresh acceptance, and the watchdog can merge once its required checks pass. |
A fact we cannot find or cannot check is left out, and prices can change after the date shown. Task Machine publishes this comparison and is an interested party. Conductor and OpenHands are named only to identify them, and there is no relationship between the companies. Has something changed? Tell us.
Who each one suits
Pick Conductor if you want to steer coding agents through plans, diffs, review comments and workspace checks. Its honest limit is that the documented second opinion is a review you request, and customer-owned Cloud execution is not supported yet.
Pick OpenHands if you want to inspect or build on a repository delivery process with a separate reviewer and exact-revision acceptance. Account for the single-user or shared identity in free Canvas and the loss of Cloud script logs after sandbox deletion.
Where Task Machine fits
Task Machine checks each Task's acceptance requirements before a person reviews the delivered work. Its task-review documentation also describes independent adversarial review when an approved plan has high sensitivity or a Critical review level. It fits when the review process must sit inside work owned by people and agents, and is the wrong pick if your main requirement is the particular Conductor workspace or OpenHands factory you already use.
The Task Machine vs Conductor and Task Machine vs OpenHands pages connect those checks to shared Tasks and Goals. Take one recently revised pull request and identify which evidence became stale after the last commit, then inspect each product's correctness row against that example.