OpenAI's Codex with GPT-5.5 can now control your computer without writing a single line of code. It opens applications. Navigates websites. Debugs problems. Iterates until tasks complete. The demonstration from World of AI shows an agent completing multi-step workflows autonomously - not by executing scripts, but by visually interacting with interfaces the way a human would.
This isn't about coding anymore. It's about automation at the application layer.
Visual Interaction Changes the Game
Previous agent systems worked by calling APIs or executing code. They needed structured access to systems - programmatic hooks that developers built specifically for automation. Codex doesn't need that. It looks at your screen, recognises buttons and fields, and clicks them.
That means it can automate software that was never designed for automation. Legacy applications without APIs. Internal tools with clunky interfaces. Web forms that require human judgement. If you can see it and click it, Codex can too.
The technical shift is from "code-driven automation" to "vision-driven automation". The agent doesn't need to know how the application works under the hood. It just needs to see what's on screen and understand what actions produce which results.
Iteration Until Completion
Here's what makes this different from previous automation tools: Codex doesn't give up when something goes wrong. If a button doesn't respond, it tries again. If an error message appears, it reads it and adjusts. If the workflow breaks, it debugs and continues.
Traditional automation scripts are brittle. Change one element on a webpage and the script fails. Move a button and the workflow stops. Codex adapts. It's not following a predetermined sequence - it's solving a problem and adjusting its approach based on what it observes.
That's the difference between a macro and an agent. A macro executes steps. An agent achieves goals.
What This Means for Business Workflows
Most business processes involve switching between applications, copying data, filling forms, and checking results. These tasks don't require deep expertise - they require attention and consistency. That's exactly what agents are good at.
Consider customer onboarding. It might involve pulling data from a CRM, filling fields in an internal system, sending a templated email, and updating a spreadsheet. A human does this in 15 minutes. An agent could do it in two - and do it 50 times before lunch.
Or procurement workflows. Checking vendor databases, comparing prices, generating purchase orders, routing approvals. These are multi-system processes that don't have integrated automation. An agent that can see and interact with each application doesn't need integration. It just needs access.
The immediate use case isn't replacing jobs. It's eliminating the tedious parts of jobs - the copy-paste loops, the form-filling, the data transfer between systems that should talk to each other but don't.
The Risks Nobody's Discussing Yet
Giving an AI agent unrestricted access to your computer is a different security model than running code in a sandbox. The agent can see everything you see. It can access anything you can access. If it makes a mistake - or if someone malicious gains control of it - the damage surface is your entire digital workspace.
There's also the question of auditability. When a human completes a task, you can ask them what they did and why. When an agent completes a task by visually navigating interfaces, the decision-making process is harder to trace. What did it see? Why did it choose that option? Can you reconstruct the logic?
And then there's reliability. These systems are impressive in demos, but demos are controlled environments. What happens when the agent encounters an interface it's never seen? A popup it doesn't recognise? A workflow that requires domain knowledge it doesn't have?
The technology is ready. The governance around it isn't.
From Coding Tool to General Automation
Codex was released as a tool for developers - a way to write code faster. This expansion into general computer use represents a fundamental repositioning. It's no longer a developer tool. It's an automation platform for anyone who works on a computer.
That shift has implications for who adopts it and how. Developers understand the limitations of AI code generation. They know when to trust it and when to verify. Non-technical users might not have that intuition. They might trust the agent to complete tasks without understanding when it's guessing or when it's confident.
The accessibility of the technology is both its strength and its risk. Lower the barrier to entry and more people benefit. But lower the barrier too far and more people deploy systems they don't fully understand.
What to Watch For
If you're building products or managing teams, this technology is worth testing now - not because it's perfect, but because it's evolving fast. The gap between "interesting demo" and "production-ready tool" is shrinking.
Start with low-risk workflows. Internal processes where mistakes are reversible. Data entry tasks where verification is built in. Use it to eliminate the work nobody wants to do - and learn how it behaves in real conditions.
Because this isn't a future capability anymore. It's shipping. And the businesses that figure out how to use it safely will gain time their competitors are still spending on manual processes.