OpenAI's acquisition of Ona this year is a clear signal about where coding agents are headed: away from quick autocomplete-style suggestions and toward agents that run autonomously for hours against a real codebase, opening pull requests and iterating on feedback with minimal human babysitting. It's a genuinely important shift, and Australian engineering leads evaluating coding tools should understand what's actually changing before picking a side.
What long-running agents actually require
A coding agent that works for thirty seconds on autocomplete needs good next-token prediction. A coding agent that works for four hours on a multi-file refactor needs something different: reliable long-context memory of the codebase, the discipline to run tests before declaring success, sensible judgement about when to ask a human a clarifying question versus guessing, and enough self-awareness to notice when it's gone down a dead end and needs to back out rather than compounding a bad decision. That's a much harder engineering problem than most coding-assistant marketing admits.
Ona's acquisition suggests OpenAI is building toward this with Codex, buying capability rather than building it from scratch, which is a reasonable strategy but means the resulting product is still integrating two codebases and two teams' assumptions about how an agent should behave. Integration friction like that tends to show up first in edge cases, exactly the situations where a long-running agent most needs reliable judgement, so the real test will come once Australian teams start running the combined product against messy production codebases rather than clean demo repositories.
Where Claude Code already sits on this
Claude Code has been built from the ground up around exactly this long-running, tool-using agent pattern, with hooks, sandboxing, and permission scoping designed for autonomous multi-step work.
The pre-tool-use hook pattern lets a team constrain what an agent can touch before it acts, not just review what it did after the fact, which matters when the agent is running for hours unsupervised.
Context management for large codebases has been a core design focus rather than an add-on, which shows up directly in how reliably it holds state across a long session.
An Australian fintech engineering team we work with runs Claude Code against their transaction-processing service for overnight refactor and dependency-upgrade work, unattended, with guardrails set through pre-tool-use hooks that block it from touching the payments module without explicit review. That kind of unattended-but-constrained operation is exactly the use case the Ona acquisition suggests OpenAI is chasing, and it's already in production use today rather than a roadmap item.
What the acquisition means for the comparison going forward
This isn't a case that Codex will remain behind indefinitely. OpenAI has the capital and the talent to close a capability gap quickly, and Ona's team brings real expertise in exactly this problem. The honest read for an Australian CTO deciding what to standardise on today is that Claude Code has a meaningful head start on the specific engineering discipline long-running agents require, built in from the start rather than acquired, and that head start is worth something concrete right now, not just in benchmark comparisons but in production reliability.
What this means for engineering leads making a decision this quarter
If your team is evaluating coding agents for genuinely autonomous, hours-long work, overnight test suites, large refactors, dependency upgrades run unattended, the practical question isn't which vendor announced the most exciting roadmap. It's which tool has the guardrail and permission model your engineering team actually trusts enough to let run unsupervised on production code. That trust gets built through the boring parts: sandboxing, hooks, audit logs, not the exciting parts vendors put in a launch announcement.
A Melbourne engineering team running a six-week evaluation between Claude Code and a Codex-based competitor found the deciding factor wasn't raw task completion rate, both were reasonably close, it was how predictably each tool behaved when it hit an ambiguous situation. Claude Code's tendency to pause and ask rather than guess saved the team an estimated $18,000 AUD in rework from bad autonomous decisions over the evaluation period. That's the metric worth tracking, not which vendor made the bigger acquisition this quarter.
The practical takeaway for now
Standardising an engineering team on a coding agent is not a decision to remake every quarter based on the latest acquisition headline. Pick the tool whose guardrails your team trusts today, run it on genuinely autonomous work with the constraints (hooks, permission scopes, sandboxing) that let you sleep at night, and revisit the comparison when there is a specific, tested capability gap rather than a press release to react to. For Australian engineering teams weighing this decision this quarter, Claude Code's production track record on exactly this kind of long-running, constrained autonomy is the more concrete data point available right now.
