OpenAI Ships Codex as a Cloud Agent: What Delegated Coding Means for Indian Dev Shops

On 16 May 2025, OpenAI launched Codex — not the old code-completion model, but a cloud-based software-engineering agent that runs each task in its own sandbox preloaded with your repository, works on many tasks in parallel, and proposes pull requests for review. It is powered by codex-1, a version of o3 tuned for coding. We pointed it at real client tickets the week it shipped. This post covers where delegated coding helps an Indian dev shop, where it breaks, and the review gates we will not ship without. ## The answer in 60 words Codex is a cloud agent: you describe a task, it spins up an isolated sandbox with your repo, writes the change, runs your tests, and opens a pull request you review. For an Indian dev shop, it shines on well-scoped, well-tested tickets — bug fixes, test writing, refactors — and breaks on ambiguous, cross-system, or poorly-tested work. The gain is throughput, not unsupervised autonomy. ## Why this matters now Until May 2025, AI coding assistants sat inside your editor and helped you type. Codex moved the work to the cloud and changed the unit of delegation from "a line" to "a ticket." OpenAI made it available first to ChatGPT Pro, Business, and Enterprise users, with ChatGPT Plus access arriving on 3 June 2025. Each task runs in its own sandbox preloaded with your repository, and you can grant internet access during execution. You can read [OpenAI's announcement](https://openai.com/index/introducing-codex/) and [TechCrunch's launch coverage](https://techcrunch.com/2025/05/16/openai-launches-codex-an-ai-coding-agent-in-chatgpt/) for the official details. For an Indian dev shop running 10–40 engineers across many client repos, the question is concrete: which tickets can you hand to an agent, and what has to stay human? ## What "delegated coding" actually changes This is the same shift we wrote about when [Claude Code rose to the number-one AI coding tool](/blog/claude-code-rises-to-number-one-ai-coding-tool-2026) and when [multi-agent coding shipped on every platform](/blog/multi-agent-coding-every-platform-ships). The pattern is consistent: the payoff is in delegating bounded work, not in expecting unsupervised end-to-end autonomy. ## Where it helps (the tickets we delegate) We ran Codex on a slice of real client backlog the week it launched. These categories produced PRs we could merge with light review. | Ticket type | Why it works | Our review effort | |---|---|---| | Fix a bug with a failing test | The test is the spec; the agent iterates until green | Low — read the diff, confirm the fix is not a hack | | Write tests for an untested module | Bounded, verifiable, tedious for humans | Low — check the tests assert real behaviour | | Mechanical refactor (rename, extract, migrate API) | Pattern-based, repo-wide, error-prone by hand | Medium — confirm nothing semantic changed | | Add a small, well-specified feature | Clear acceptance criteria + tests | Medium — review design choices | | Dependency bump + fix breakages | Repetitive, well-defined | Low — confirm tests pass | ## Where it breaks (what stays human) Three categories we keep human: - Ambiguous tickets. "Make the dashboard faster" has no acceptance criteria. The agent guesses, and the guess is sometimes a regression dressed as an improvement. Specify first, then delegate. - Cross-system changes. A change that spans the API, the mobile app, a webhook, and a third-party billing integration has too many implicit contracts for an agent working in one sandbox. We break these into bounded sub-tickets or keep them human. - Security-sensitive code. Auth, payments, data access, and anything touching personally identifiable information get a human author and a second human reviewer. We do not delegate the code that, if wrong, ends up in a breach post-mortem. ## The 3 review gates we made mandatory ## The billing reality for an Indian dev shop OpenAI gave early users generous access at launch, then moved to rate-limited access with paid options for additional usage. For a dev shop, the cost question is not "what does a seat cost" but "what does a delegated ticket cost, and is it cheaper than the engineer-hours it saves." Our early read: for tedious, well-scoped work — test writing, mechanical refactors, dependency bumps — the agent is comfortably cheaper than the senior-engineer time it frees up. For ambiguous work, you pay twice: once for the agent's wrong attempt, once for the human to redo it. The economics follow the same logic we laid out in the [agentic enterprise licence shift away from per-seat SaaS](/blog/agentic-enterprise-license-end-of-per-seat-saas). ## What you will need (prerequisites checklist)

• A ChatGPT plan with Codex access (Pro, Business, or Enterprise at launch; Plus from June 2025)
• A repository with a real test suite — the better the coverage, the more you can delegate
• A written ticket format that includes acceptance criteria and a test plan
• A code-review process that treats agent PRs like any other PR
• A CI pipeline that runs the full suite independently of the agent's sandbox
• A clear policy on which code categories (auth, payments, PII) stay human-authored
• A way to track agent usage cost against engineer-hours saved

## Common mistakes (each one hurts) Symptom: "The agent's PR looked great and broke production." Cause: merged a confident change on a weakly-tested module. Fix: gate delegation on test coverage. Untested code is exactly where the agent's confidence is most dangerous. Symptom: "We are spending more on the agent than we are saving." Cause: delegating ambiguous tickets that take multiple wrong attempts. Fix: only delegate work with clear acceptance criteria. Specifying is your job; the agent does not do it for you. Symptom: "Juniors are merging agent PRs without understanding them." Cause: treating agent-authored as pre-approved. Fix: an agent PR needs the same review as a human PR, by someone who owns that code. Make it a hard rule. Symptom: "It keeps failing on a task that needs internet access." Cause: the sandbox did not have the access it needed for that task. Fix: grant internet access deliberately for tasks that need it (fetching docs, installing packages), and deny it for tasks that should be hermetic. Symptom: "The agent over-fitted to the test and the real behaviour is wrong." Cause: a test that checks implementation, not behaviour, that the agent gamed. Fix: re-run independent integration tests in CI and review whether the change actually does what the ticket asked. ## Real example — how we slotted it into a client backlog For a fintech client's React + Node codebase with solid test coverage, we took a sprint's worth of backlog and sorted it into "delegate" and "human." The delegate pile: 6 bug fixes with failing tests, a test-writing task for an untested utilities module, and two dependency bumps. The human pile: a payments-flow change and a cross-system webhook refactor. The delegated work landed as reviewable PRs while two senior engineers focused on the payments change. The throughput gain was real — tedious tickets cleared faster — and the review gates caught two over-fitted test cases before they merged. Net effect: the team shipped the sprint with one fewer late night, and the engineers spent their attention on the work that actually needed judgment. As Hrishikesh, our CTO, puts it: the agent is a throughput multiplier on bounded work and a liability on ambiguous work, and the whole job of adoption is keeping the line between the two clear. The codebase we delegated against was a real, complex one — the kind of multi-portal system we built for Radiant Finance. This is exactly how we advise clients to adopt coding agents inside our [web development](/services/web-development) engagements, and it mirrors our own internal experience documented in [our Claude Opus migration across three production workflows](/blog/claude-opus-4-7-migration-three-production-workflows-24-hours). ## FAQ ### Is Codex the same as the old OpenAI Codex from 2021? No. The 2021 Codex was a code-completion model behind GitHub Copilot. The May 2025 Codex is a cloud-based software-engineering agent powered by codex-1, a version of o3, that runs tasks in sandboxes and opens pull requests. Same name, very different product. ### Can Codex deploy to production on its own? It should not, and we do not let it. Codex works in an isolated sandbox and proposes pull requests for human review. The safe pattern is agent-proposes, human-reviews, CI-verifies, human-merges. Treat any tool that promises unsupervised production deploys with deep suspicion. ### What kind of tasks should an Indian dev shop delegate first? Start with bug fixes that have a failing test, writing tests for untested modules, and mechanical refactors. These are bounded and verifiable. Keep ambiguous, cross-system, and security-sensitive work human until your team has built calibrated trust. ### Does it work well on repos that are not in English or use Indian-context logic? The code understanding is language-agnostic, but ambiguous business logic — GST rules, Indian payment flows, vernacular handling — needs precise specification in the ticket. The agent does not infer domain rules; you must state them. Well-specified, it handles Indian-context code fine. ### How does the billing work for a team? Early access was generous, then OpenAI moved to rate-limited access with paid options for extra usage. For a team, measure cost per delegated ticket against the engineer-hours saved. Tedious well-scoped work pays off; ambiguous work can cost you twice. ### Will this replace junior developers at Indian dev shops? It changes what juniors do, not whether you need them. Someone has to write good tickets, review agent PRs, and own the code. We see it raising the floor on what a small team can ship, and shifting junior time from typing boilerplate toward specification and review. ### How is this different from an in-editor assistant like Copilot? An in-editor assistant helps you type in real time inside your IDE. Codex takes a whole task to the cloud, works in a sandbox, and returns a pull request. One augments your typing; the other accepts delegation of a unit of work. Most teams will use both. Our founder [Vivek Singh](https://viveksinra.com) writes on the same beat — the engineering-management side of adopting AI tooling — from a first-person founder lens. Email contact@softechinfra.com and we will share our ticket-and-review template before the call.