Verdict: choose Codex when the team already buys ChatGPT, wants OpenAI's cloud agent and local CLI under one account, values isolated per-task cloud environments, and prefers a smaller adoption decision. Choose Factory when the company needs model flexibility, formal spec approval, persistent or owned execution machines, centralized agent policy, OTEL telemetry, and enterprise deployment beyond a hosted coding-agent service.
- Codex is one agent across many surfaces. Factory is an agent platform centered on Droid.
- Codex cloud runs each task in an isolated environment preloaded with the repository and can work on many tasks in parallel.
- Factory can run Droids locally, headlessly, on BYOM hosts, on managed persistent computers, and in enterprise deployment patterns.
- Factory Specification Mode is more formal than a normal Codex task: planning stays read-only until approval.
- Codex is tied to OpenAI models. Factory exposes a model-flexible policy and routing layer.
- Existing ChatGPT spend can make Codex the cheaper pilot. Factory starts at $20 a month and has no public free plan.
Verdict and criteria matrix
Codex and Factory overlap at the task level. Both can inspect code, edit files, run tests, work asynchronously, and return changes. They diverge at the organizational level. Codex is a first-party OpenAI agent product. Factory is a control and execution stack intended to standardize autonomous engineering across models, machines, policies, and teams.
Official documentation and plan pages checked 10 August 2026.
| Criterion | Factory AI | OpenAI Codex | Edge |
|---|---|---|---|
| Product class | Enterprise autonomy stack | First-party coding agent | Depends on purchase scope |
| Cloud tasks | Droid Computers and platform sessions | Isolated cloud task per repository and branch | Codex for direct setup |
| Parallel cloud work | Missions and multiple Droids | Multiple independent Codex tasks | Tie |
| Local terminal | Droid CLI | Codex CLI | Tie |
| Desktop multi-agent surface | Factory desktop | Codex app with worktree support | Tie |
| Formal spec gate | Specification Mode | Planning, AGENTS.md, task instructions | Factory |
| Model choice | Several providers plus policy and routing | OpenAI Codex model family | Factory |
| Local sandbox | Autonomy levels, policy, hooks, deployment controls | OS-enforced sandbox in Codex CLI | Codex for simple local boundary |
| Persistent remote state | Droid Computers | Task environment configured per repository | Factory |
| Enterprise observability | OTEL metrics and traces | Workspace usage and Compliance API | Factory for open telemetry |
| Price to start | $20/mo | Included with eligible ChatGPT plans, temporary Free access | Codex |
| Airgapped pattern | Documented | Enterprise qualification required | Factory |
Codex cloud agents are the center of this comparison
OpenAI introduced Codex as a cloud-based software-engineering agent able to run many tasks in parallel. A task receives an isolated environment preloaded with the selected repository. Codex can read and edit files, run test harnesses, linters, and type checkers, commit changes, cite terminal logs and test output, accept follow-up instructions, and open a GitHub pull request. That is a complete assignment loop without requiring the developer laptop to remain active.
Factory covers remote work through Droids attached to managed or owned computers. Managed Droid Computers persist files, installed packages, configuration, local services, and process memory between sessions. BYOM lets a team register an existing Linux, macOS, or Windows machine. Factory Missions add decomposition and worker coordination for larger goals. The environment becomes a reusable company asset rather than a fresh task container.
| Cloud question | Factory | Codex |
|---|---|---|
| Fastest route from GitHub repo to one remote task | Configure Factory account and target | Connect repository and start a task |
| Environment isolation per task | Depends on chosen computer and workflow | Separate cloud environment |
| Persistent services across sessions | Droid Computer | Recreate through environment setup |
| Use an existing private-network machine | BYOM | Needs compatible OpenAI environment access |
| Parallel independent tasks | Multiple Droids or Mission workers | Native Codex task queue |
| Formal multi-stage project orchestration | Missions | Multiple tasks and automations |
Codex wins when a clean cloud sandbox per assignment is the desired unit. Factory wins when the remote machine itself has durable value or must live inside customer infrastructure. A buyer should state which kind of state it wants to preserve: repository setup in a repeatable script, or the live machine with its packages and services.
Local work and sandbox boundaries
Droid CLI and Codex CLI both work inside the current repository, read project instructions, edit files, run commands, and support headless automation. Their local trust boundaries differ. Codex exposes an operating-system sandbox on macOS and Linux, with modes that limit writes and network access, plus an approval policy that controls when the agent asks. This creates a compact security model a developer can reason about from the command line.
Factory controls Droid through autonomy levels, tool and model policy, organizational allow and deny rules, hooks, secret scanning, deployment architecture, and optional sandboxed environments. That system is broader and asks more configuration questions. It can fit enterprise controls more closely, while Codex gives an individual a strong default boundary with less platform work.
| Local-run need | Factory | Codex |
|---|---|---|
| Read-only repository analysis | Low autonomy or policy-restricted Droid | Read-only sandbox mode |
| Write only inside the checkout | Policy and environment configuration | Workspace-write sandbox |
| Headless command with machine-readable output | droid exec and SDK | codex exec with JSON or schema |
| Central tool deny list across an organization | Factory admin policy | Workspace controls and repository policy |
| Kernel-level local file boundary | Depends on deployment and sandbox choice | Codex sandbox |
| Fully airgapped local runtime | Factory enterprise deployment | Requires separate OpenAI qualification |
Specification Mode against Codex instructions
Factory Specification Mode creates a written specification, acceptance criteria, implementation plan, file-level change outline, test strategy, and security considerations before edits begin. The user approves or revises that plan. Approved specs can be saved as Markdown in the project. This is useful when scope approval is a required artifact rather than an optional conversation.
Codex uses task prompts, repository environment setup, and hierarchical AGENTS.md files. A cloud task can research, plan, implement, test, cite its evidence, and prepare a pull request. The Codex app and CLI share session history and configuration. This is lighter to adopt because the instruction file lives beside the code and the same agent identity spans local and cloud surfaces.
| Context type | Factory | Codex |
|---|---|---|
| Repository navigation and commands | AGENTS.md and Factory project instructions | AGENTS.md |
| Formal acceptance criteria | Generated spec for approval | Prompt or checked-in issue/spec |
| Prevent edits during planning | Built into Specification Mode | Use read-only task or plan workflow |
| Persist plan in repository | Save spec as Markdown | Ask Codex to write or consume a checked-in plan |
| Carry configuration across local and app surfaces | Factory account and project configuration | Codex CLI, IDE, and app share config/history |
| Encode repeat procedure | Skills, hooks, commands, SDK | Skills, automations, scripts, AGENTS.md |
Teams already using AGENTS.md gain portability because both products can consume repository-level instructions. Keep stable build, test, architecture, and scope rules there or in linked owned docs. Product-specific features can then add planning and orchestration without becoming the only place the rules exist.
Model strategy and failure ownership
Codex uses OpenAI models selected and tuned for the Codex product. The advantage is integration: one vendor owns model behavior, agent tools, sandbox, cloud environment, app, CLI, account, and rate card. When the stack works, there are fewer seams to diagnose. When model behavior or capacity disappoints, model choice stays within OpenAI's catalog.
Factory treats model selection as a platform concern. Its product and enterprise pages emphasize model independence, allow and deny policy, customer gateways, BYOK, routing, and fallback. Factory Router can select models based on task and policy. This can reduce dependency on one provider and can also make cost and quality diagnosis more complex because the route becomes another variable.
| Priority | Better fit | Reason |
|---|---|---|
| One accountable model and agent vendor | Codex | OpenAI owns the integrated path |
| Switch providers without moving the agent platform | Factory | Model policy is part of the platform |
| Simple individual debugging | Codex | Fewer routing layers |
| Enterprise gateway and model eligibility rules | Factory | Designed for organization policy |
| Latest OpenAI coding models immediately | Codex | First-party surface |
| Provider outage or quota diversity | Factory | Multi-provider routing options |
The evaluation should pin models for at least one test round. Automatic routing can be evaluated in a second round. Otherwise the buyer cannot distinguish agent workflow quality from model selection quality, and the resulting score will be difficult to reproduce.
Enterprise controls and telemetry
Factory makes enterprise architecture a first-class product. Droid can run on developer machines, CI, VMs, Kubernetes, devcontainers, hybrid infrastructure, and fully airgapped networks. Admins can manage identity, models, tools, network policy, retention, and telemetry. Droid emits OTEL metrics and traces that can flow to customer-owned observability systems.
Codex is available under ChatGPT business and enterprise arrangements, with workspace controls, usage reporting, data controls, and Compliance API visibility for Codex activity. Cloud tasks operate inside OpenAI-managed isolated environments. The appeal is a managed service tied to an existing OpenAI contract, especially when ChatGPT is already approved.
- Factory wins when deployment topology and customer-owned telemetry are design inputs.
- Codex wins when the organization wants an approved OpenAI service with a small integration footprint.
- Factory requires platform ownership. More policy and deployment options create more decisions and operational work.
- Codex requires vendor trust. The cloud environment, model family, and service controls stay inside OpenAI's product boundary.
Ask each vendor for the evidence path on the same cloud task: initiating identity, repository and branch, environment build, network access, model and token use, commands, files changed, tests, output citations, pull request, and retention. A usable audit story follows the task rather than listing certifications.
Pricing and quota behavior
Factory Pro costs $20 a month, Plus $100, and Max $200. Usage draws from rolling five-hour, weekly, and monthly windows. Droid Core offers a separate selected-model pool after standard usage is exhausted, and prepaid Extra Usage can continue paid models. Managed Droid Computers are included according to plan and availability. Team contracts require sales contact.
Codex is included with eligible ChatGPT plans. As of 10 August 2026, OpenAI also advertises limited-time access on Free and Go, while Plus remains the ordinary paid entry for an individual. Local, app, IDE, code-review, and cloud usage draw from Codex or shared agentic usage according to the applicable plan and current rate card. Some users can purchase credits after included limits.
| Cost question | Factory | Codex |
|---|---|---|
| Public free access | No | Limited-time Free access |
| Common paid individual entry | $20 Pro | $20 ChatGPT Plus |
| Heavy individual tier | $200 Max | $200 ChatGPT Pro |
| Meter | Rolling 5h, weekly, monthly standard usage | Plan allowance and token-based credits |
| Fallback after limit | Droid Core or Extra Usage | Credits, upgrade, or wait depending on plan |
| Cloud work shares account usage | Factory platform allowance | Yes, Codex surfaces share the applicable pool |
When to pick each
| Pick Factory when | Pick Codex when |
|---|---|
| The company wants a model-flexible autonomy platform | The company wants OpenAI's agent specifically |
| Persistent owned or managed computers matter | Fresh isolated cloud tasks match the work |
| Formal specification approval should be standard | AGENTS.md and task-level planning are sufficient |
| OTEL and deployment topology belong to internal architecture | A managed OpenAI service reduces integration work |
| Hybrid or fully airgapped operation is required | OpenAI cloud is approved and convenient |
| Platform policy spans models, tools, and teams | A local sandbox plus workspace controls covers the need |
Codex is the pragmatic first test for many individuals because it may already be included. Factory deserves a pilot when the problem has grown beyond agent quality into platform questions: which model, which machine, which policy, which telemetry, which deployment, and which long-running workflow.
Migration notes
Moving from Codex to Factory begins with portable assets: AGENTS.md, setup scripts, test commands, task templates, and accepted pull-request examples. Keep those in git. Recreate cloud environment requirements on a managed Droid Computer or BYOM host. Translate automations into droid exec, SDK workflows, or Missions. Establish model policy and OTEL export before scaling. Preserve Codex access during the pilot for OpenAI-specific work and as a baseline.
Moving from Factory to Codex requires reducing platform assumptions. Put durable Droid instructions and approved specs into repository files. Convert headless workflows to codex exec or Codex automations. Replace persistent-machine dependencies with reproducible setup scripts where possible. Map enterprise policy to ChatGPT workspace controls and repository permissions. Test any workload that relied on airgapped, hybrid, or custom-gateway behavior before committing to the move.
Inventory the execution contract
Record model, environment, network, secrets, tools, approval, budget, evidence, and output for each recurring task.
Make repository context portable
Keep AGENTS.md, build commands, test policy, and architecture constraints in version control.
Rebuild one cloud task
Use a bounded issue with deterministic tests and reproduce the full branch-to-PR path.
Rebuild one local headless task
Verify exit codes, structured output, permissions, timeout, cleanup, and cost under unattended execution.
Cut over by task class
Move isolated cloud tickets, local interactive work, and enterprise automation separately because their risk and environment needs differ.
Questions people ask
Factory is stronger as a model-flexible enterprise platform with formal specs, persistent computers, deployment choice, policy, and OTEL. Codex is stronger as a focused OpenAI agent with cloud tasks, a local sandbox, CLI, app, IDE, and existing ChatGPT distribution.
Yes. Codex cloud runs each task in an isolated environment preloaded with the repository. It can edit files, run tests and linters, commit changes, cite terminal evidence, accept revisions, and open a pull request.
Yes. Droids can run on Factory-managed persistent Droid Computers or customer-owned machines registered through BYOM. Factory also supports headless execution and larger Missions.
Codex offers a clear OS-enforced sandbox and independent approval policy for local CLI work. Factory offers broader organizational policy and deployment controls. The stronger choice depends on whether the unit is one developer process or a company runtime.
Factory. Its platform is designed for model choice, allow and deny policy, gateways, BYOK, and routing. Codex uses OpenAI's model family, with the benefit of first-party integration.
Codex may already be included with an eligible ChatGPT account and has temporary Free access as of August 2026. Factory starts at $20 a month. Paid entry is commonly $20 on both sides, with different meters and products.
Codex can research, plan, follow AGENTS.md, and implement from a checked-in specification. Factory packages a stricter read-only planning phase and approval gate that can save the approved plan as Markdown. Teams can recreate the discipline in Codex with process.
Test one isolated cloud task, one private-environment task, and one headless automation. Score environment success, policy fit, traceability, accepted code, human review, rework, total usage, and operational ownership.
Sources
Every figure above was read from these pages on August 2026. Vendors reprice without notice; if you find a stale number, tell us.