Codex vs OpenHands: A Coding Session or a Software Factory?
Compare Codex's goal-driven coding sessions with OpenHands' software factory, independent acceptance checks and deployment choices.
Founder, Task Machine
Codex and OpenHands both check code, so the choice starts with a narrower question: do you want to steer a coding session or configure a software factory? Codex's Goal mode documentation describes a persistent target checked through tests and measurements. OpenHands' software factory guide connects triage, development, independent review and conditional merge.
For a small development team, the deciding difference is what happens after an implementation changes. You may want to inspect a session's patch and checks yourself. Or you may want an explicit factory procedure that requires fresh independent acceptance for the exact revision before it merges.
Codex gives the developer a session to steer
Codex works across an app, terminal, editor and hosted workspaces. Its command documentation includes Plan mode, so you can ask for an execution plan before implementation. Goal mode can then retain measurable success criteria while the agent works.
Its cloud documentation describes an isolated workspace for each task, with changed files and check results available for review. You can delegate work without keeping your own computer awake for the cloud task. Local command-line work remains another execution option.
This is useful when the developer remains the person directing the next move. A repair can start with a failing test, proceed through a proposed implementation and finish with inspection of the resulting patch. The published model gives you several ways to perform that work without making a factory configuration the starting point.
OpenHands makes engineering automation configurable
OpenHands combines Agent Canvas, managed Cloud and a Python SDK for building coding agents. Its Canvas overview describes conversations with their own history and agent configuration, connected to a backend on your computer, in Docker, on a virtual machine or in managed Cloud.
The software factory turns an engineering delivery process into four automations. Triage examines work and dependencies, development implements it, an independent reviewer checks the result, and delivery merges conditionally. That is a published process you can evaluate against your repository's actual acceptance requirements.
The limit is the work record. OpenHands' public pages describe conversations and gathered GitHub issues, but do not establish a shared record assignable to a person or agent as its owner. If your team needs a human to take over a non-coding deliverable, inspect where that responsibility will live outside the engineering conversation.
Independent review means checking the current revision
Codex can verify Goal mode progress against completion criteria and offers dedicated code review. Its GitHub review documentation also explains review against applicable AGENTS.md guidance. Root instructions and more specific nested instructions apply to the changed files they cover.
OpenHands' software factory gives the reviewer a separate token that cannot push code. The reviewer tests and reviews the exact pull-request revision. A changed commit requires fresh acceptance, and the watchdog waits for current independent statuses before merging.
These are related capabilities with different documented boundaries. Codex provides coding and review tools for an author deciding whether to accept a change. OpenHands documents the relationship between a revision, independent acceptance and the factory's merge decision.
When trying either, ask the implementing agent to revise a patch after review. Then inspect which evidence still applies to the new commit. An earlier report can remain useful context without being proof that the updated code passed.
Scheduled jobs and reusable execution
Codex's automation guide covers desktop schedules in local projects and isolated worktrees. The computer and app must stay running for those schedules. Skills package reusable instructions, while the published workflow description remains agent-followed guidance rather than a fixed enforced execution graph.
OpenHands' automation documentation covers schedules, matching webhook or service events, configuration and recent run history. Script automations execute saved bundles directly without starting an agent conversation. On Cloud backends, script logs become unavailable when the run's sandbox is deleted, so the docs advise opening them while the run is in progress.
Consider a recurring failing-check investigation. Codex's local schedule depends on desktop availability, while OpenHands offers Canvas automations on a selected backend. In both evaluations, include an evidence-preservation step: the person reviewing a later failure needs the relevant output, not only a record that a run happened.
Plans and accounts cover different resources
Codex's pricing documentation lists Plus at $20 a month and Pro from $100 a month in USD. Local messages and cloud chats share the included allowance, with extra credits available. API-key usage is billed separately at API rates.
OpenHands' pricing page lists Canvas as 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, and managed Cloud model usage uses credits.
Those amounts describe different purchases. The OpenHands self-hosted Teams price covers a team deployment tier, not a published managed Cloud plan amount. Keep model access, execution environment and separate user identities visible in your evaluation instead of treating every listed amount as the same kind of subscription.
Codex and OpenHands, point by point
The sourced table uses the same questions for each product and shows when each answer was checked. Its explanations distinguish session verification, SDK controls and the documented factory procedure.
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 | Codex | OpenHands |
|---|---|---|
| Goals |
Codex
Yes
Goal mode gives Codex a persistent target to track while a task runs. You can define tests or measurements as completion criteria and steer the same session as it works toward them. |
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 |
Codex
Partly
A main agent delegates to specialized subagents, routes follow-up instructions and collects their results. Its docs describe coordination within a chat rather than assigned lead roles over projects, goals or teams. |
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 |
Codex
Yes
Through its Linear integration, you can assign issues to Codex just as you assign them to teammates. Codex posts progress and results on the issue, and follow-up comments continue the same cloud chat. |
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 |
Codex
Yes
Codex in the desktop app can run scheduled tasks in local projects or isolated worktrees. Separately, Linear triage rules can automatically delegate new issues to Codex cloud chats. Local schedules need the computer and app running. |
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 |
Codex
Partly
Skills package reusable process instructions and resources, and plugins add tools and runtime hooks. Its docs describe agent-followed instructions rather than a fixed execution graph with enforced steps and branches. |
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 |
Codex
Yes
Sandbox settings, command rules and approval policies determine when Codex asks before acting. Requests route to you by default, with desktop permission notifications and an Activity view for chats waiting for a response when available. |
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 |
Codex
Not published
Its docs do not describe Codex proposing permission changes from your approval history. Auto-review evaluates individual action requests under a configured policy, while local memories carry context into later work. |
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 |
Codex
Yes
Opt-in local memories turn eligible earlier chats into files that inform later sessions. You can inspect the files, control each chat's use and contribution, or delete the store. The docs discourage hand editing as the primary control. |
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 |
Codex
Yes
Plan mode lets you ask Codex for an execution plan before implementation starts. You can refine an unclear outcome through conversation into a goal with measurable success criteria before starting Goal mode. |
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 |
Codex
Yes
Linear assignments, mentions and triage rules route issue work to Codex. It selects a repository environment, starts a cloud chat and posts progress back to the issue. |
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 |
Codex
Yes
Cloud environments connect Codex to APIs and private services. Local clients can connect Linear through Model Context Protocol, and Linear triage rules can automatically start Codex cloud work. |
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 |
Codex
Partly
You choose the model and reasoning effort through app controls, the CLI or the editor. Its docs describe manual choices and defaults rather than automatic model selection for each 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 |
Codex
Yes
The CLI works against repositories and tools on your own machine. Codex Cloud provides a separate workspace for each task and keeps working while your computer sleeps. |
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 |
Codex
Yes
ChatGPT sign-in covers subscription access, and an OpenAI API key provides usage-based access for local app, CLI and editor work. API-key access does not include Codex cloud, which requires ChatGPT sign-in. |
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 |
Codex
Yes
USD pricing lists Plus at $20 a month and Pro from $100 a month, with included usage and extra credits. API-key usage is billed separately at API rates. Local messages and cloud chats share the plan allowance. |
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 |
Codex
Yes
Goal mode can verify progress against tests, measurements and completion criteria. Codex also offers dedicated code review and cloud tasks whose changed files and check results you inspect before accepting the work. |
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 | Codex | OpenHands |
|---|---|---|
| Code review rules |
Codex
Yes
Codex reviews GitHub pull requests against applicable code review rules in AGENTS.md files. Root guidance and more specific nested guidance apply to the changed files they cover. |
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 |
Codex
Yes
Security Review adds a separate security-focused pass over pull requests alongside Code Review, using threat-model context when configured. It is a research preview for Pro, Business, Enterprise and Edu, not Plus. |
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 |
Codex
Partly
Auto-review assesses the risk and authorization of individual proposed actions. Its docs describe action-level risk categories rather than an overall risk rating for a code 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 |
Codex
Yes
Codex cloud tasks can open pull requests, and authors can ask Codex to address specific review feedback. Its review interface also exposes checks and lets you investigate failing checks before deciding to merge. |
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. Codex 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 Codex if you want interactive planning, coding and review with a cloud delegation option. Its desktop schedules depend on a running computer and app, so verify that a nightly local check has an available host.
Pick OpenHands if you want its SDK and factory pattern for revision-specific independent acceptance before conditional merge. Free Canvas uses a single user or shared identity, while separate identities and role-based access are part of self-hosted Teams.
Where Task Machine fits
Task Machine is relevant when the deciding boundary is shared responsibility across engineering and other work. Its acceptance review documentation describes checking each Task requirement before a person reviews delivery. Task Machine Workflows can return failed results for correction, while Tasks keep human or agent ownership with the plan and history.
Task Machine is the wrong pick if your main requirement is the OpenHands Python SDK or direct Codex editing sessions. Read Task Machine vs Codex and Task Machine vs OpenHands, then write the acceptance requirement for one job a person and an agent must hand between them.