A practical guide to Codex's browser agent for QA testing, password-protected logins, and turning repeated browser tasks into reusable automation skills.
What is Codex’s browser agent, and what does it actually do? #
Codex’s browser agent is a feature inside the Codex desktop app that lets an AI model see and control a real browser window (or, through computer use, your actual desktop) to complete tasks that don’t have an API. It can click buttons, fill forms, navigate menus, download files, and log into accounts using saved credentials. It runs alongside your chat session, so you type instructions in natural language and watch the agent’s own mouse move across the screen as it works.
The core idea is that most software you’d want to automate today has an API, and Codex can connect to those directly through plugins. But plenty of tools, especially older platforms, internal dashboards, or consumer sites like banking portals, don’t expose an API. Browser use fills that gap by relying on vision and reasoning: the agent looks at the screen, decides what element to click, and adapts based on what shows up next.
How do you set up Codex’s browser agent? #
The browser agent lives inside the Codex desktop app, which opens a browser panel on the right side of the interface. You can drive that browser manually yourself (searching, clicking, navigating) or hand control to Codex, at which point you’ll see a distinct agent cursor take over the mouse.
Built like a system. Not vibe-coded.
Remy manages the project — every layer architected, not stitched together at the last second.
Setup itself is simple: you don’t need special scripts or configuration to get started. You describe the task in plain language, similar to how you’d brief a person, and the agent begins working. For tasks that require login, you sign in once manually and Codex saves that session, so subsequent runs skip the login step, provided the platform doesn’t force a re-authentication.
For platforms that do require repeated logins (banking sites are a common example, since they log users out for security), Codex includes a built-in password manager. You create a CSV file with columns for name, URL, username, password, and notes, then import it into Codex’s settings. The agent pulls credentials from that file to log in rather than storing them in your chat history, which keeps sensitive data out of the conversation log.
How is it used for QA testing web apps? #
One of the clearest use cases is stress-testing a web app’s UI before shipping it. Instead of manually clicking through five or six scenarios yourself, you point the browser agent at a running app (including a localhost build) and ask it to try to break it.
In a demonstrated example, the agent was told to test a form submission page: try invalid inputs, skip required fields, switch views, and generally hunt for bugs. It clicked “continue” without filling fields, confirmed validation messages appeared correctly, then deliberately tried edge cases like entering invalid contact data and switching country codes. It caught a real data integrity issue where changing a country code to UK silently reverted to US when the user returned to edit the form. It also switched to mobile view on its own and found responsiveness failures that hadn’t been tested yet.
You can push this further with a scoped goal, for example instructing the agent not to stop until it has tried a set number of unique edge-case scenarios before reporting back. Once it finishes, it returns a list of passed and failed checks, and you can immediately follow up by asking it to implement fixes for whatever it found.
There’s also an annotation feature for visual bugs: you click an “annotate” option, select a specific UI element (like a phone number field that overlaps another box), and describe the problem in plain language. That annotation gets sent to the chat as an instruction, similar to how design-focused AI tools let you mark up a page directly rather than describing coordinates in text.
How does it handle tasks without an API, like down statements? #
For platforms with no API access, such as down account statements from a financial dashboard, the workflow looks like this: you describe the goal (open the platform, navigate to accounts, find statements, download specific ones as CSVs, save them to a folder), and the agent executes it end to end using vision to figure out where to click. In one demonstrated run, the agent signed into a platform, located the statements section, downloaded files, and saved the entire sequence as a reusable “skill,” all from a single natural-language description with no example recordings or screenshots needed. That skill can later be triggered again, for instance as part of a scheduled monthly routine, without re-explaining the steps.
Everyone else built a construction worker.
We built the contractor.
One file at a time.
UI, API, database, deploy.
The catch is session persistence. Secure platforms like banking tools often log users out automatically. When that happens, the agent needs fresh credentials, which is where the password manager import becomes useful: rather than manually retyping a password every time the session expires, Codex pulls it from the imported CSV and logs back in automatically.
Two-factor authentication is a hard limit here. If a platform requires a code sent to your phone, the agent can’t complete that step unless you handle it manually, or unless you’ve set up computer use on a machine where the messages themselves are accessible for automation, which comes with obvious security tradeoffs.
When should you use browser automation versus an API or a macro? #
The general order of preference: API first, deterministic macro second, browser use last.
An API is faster, cheaper, and more consistent because it’s a direct, structured connection rather than a simulated human clicking around. If no API exists but the task is simple and repeatable (click this exact pixel, then that exact pixel, every time with no variation), a deterministic macro script is often a better choice than an AI-driven browser agent. Macros don’t require reasoning or vision, so they’re cheaper to run and less prone to the occasional misclick that comes with an AI interpreting a screen in real time.
Browser use earns its place when a task involves enough variability that a fixed script would break, meaning the agent has to actually assess what’s on screen and decide where to click based on that. This is the case for tasks like navigating an unfamiliar dashboard layout, handling forms that change dynamically, or working around UI elements that shift position.
For anything involving credentials or financial accounts, it’s worth having a human watch the first several runs closely rather than trusting a skill blindly after one successful attempt. Since the agent is using AI and vision rather than a fixed script, its behavior isn’t guaranteed to be identical every time, so validating consistency before letting it run unsupervised (especially on a schedule) matters.
Is Codex’s browser agent worth using for automation? #
For teams building software, using a browser agent to QA an app before launch is a low-cost way to catch bugs that manual testing might miss, particularly around edge cases and unpredictable user behavior. It won’t replace structured automated testing entirely, but it adds a layer of adversarial testing that’s fast to set up.
For personal or workflow automation, such as pulling files from a no-API platform or reformatting content across a site’s editor, it’s most useful when the task is repeated regularly and doesn’t have a clean API alternative. The tradeoff is that vision-based automation is inherently less predictable than code, so it fits best for tasks where occasional oversight is acceptable, and less well for fully unattended, high-stakes processes.
Frequently Asked Questions #
What’s the difference between headless and headed browser use in Codex?
Headless means the browser agent runs in the background without a visible window, so you can keep working on other things while it operates. Headed means you can see the browser and mouse movements in real time, which is useful when you want to monitor exactly what the agent is doing, especially for a new or sensitive task.
Does Codex’s browser agent remember login sessions?
Remy doesn't write the code. It manages the agents who do. #
Remy runs the project. The specialists do the work. You work with the PM, not the implementers.
Yes, in most cases. Once you sign into a site through the in-app browser, Codex saves that session so you don’t need to log in again on future runs. Some secure platforms, like banking sites, force logouts periodically, which is where the built-in password manager becomes useful for re-authenticating automatically.
How do “skills” work in Codex’s browser automation?
A skill is a saved sequence of browser actions that Codex records after successfully completing a task once. Instead of re-describing the steps every time, you can trigger the saved skill again, and even schedule it to run on a recurring basis, such as down monthly statements.
Is it safe to automate logins to sensitive accounts like banking platforms?
It carries risk since the agent relies on AI and vision to decide what to click, which isn’t perfectly deterministic. It’s safer to watch the first multiple runs closely, keep the instructions tightly scoped, and avoid full unattended automation for high-stakes accounts, particularly where two-factor authentication is involved.
Should I use browser automation instead of an API?
No, an API should generally be the first choice when one is available, since it’s faster, cheaper, and more reliable. Browser automation, and computer use more broadly, are better suited for situations where no API exists and the task involves enough visual variability that a fixed script wouldn’t hold up.