From reading pages to taking action
The label “AI browser” covers different capabilities. An assistant may answer questions about a page or summarize it; an agent can also interact with the site by following links, filling in fields and completing a sequence of steps. This is more than a convenience: it changes what the software can do on a person’s behalf.
In reading mode, the result is usually text that the user reviews and acts on independently. In agent mode, the browser can operate a page by clicking and typing, as OpenAI describes for ChatGPT Atlas agent mode. The Spanish consumer organization OCU also distinguishes assistance features from those that automate actions within websites. An incorrect answer and an incorrect action therefore do not have the same effect: the latter may change a form or start a transaction.
The distinction does not always match a product’s name. A browser may offer summaries and, in another feature or mode, automation. When comparing options, it is more useful to ask what each mode can do than to assume all “AI browsers” have the same level of access.
The practical takeaway is to distinguish “help me understand” from “do it for me.” Summarizing a returns policy is not the same as starting a return; comparing appointment times is not the same as booking one. The closer a task comes to making an external change, the more important it is to know what the agent can execute and when it asks for human input.
What context an agent can see
To take action, an agent needs enough information to find controls and understand the state of a page. Depending on the feature, that may include visible content, page text, form elements or information from multiple tabs. OpenAI says Atlas can view pages and take actions in the browser; OCU describes use cases such as reading email, analyzing documents and comparing information across tabs.
If a page belongs to an account where the user is signed in, the agent may encounter information accessible in that session. An authenticated session matters: the model does not need to be given a password to interact with a page that is already open and signed in. This can be useful for legitimate tasks, but it also increases the sensitivity of the information and actions within reach.
Products do not all process context in the same way. Some features rely on cloud services, while others may offer local components; check the specific service’s policy and controls rather than inferring its approach from the fact that it is a browser. Local processing alone also does not prevent malicious instructions on a page from influencing an agent.
Before enabling a feature, identify its actual scope: does it read only the current tab or others as well? Can it open new sites, type into fields, submit forms or click purchase controls? Check the feature’s specific capabilities, the pages it can access and the actions it can take during a task—not just the permission shown in a pop-up.
Prompt injection from a page
Indirect prompt injection occurs when an AI system processes external content containing instructions aimed at the agent itself. A page may contain visible text or elements that are not easy for a person to notice but that the system still incorporates into its context. That content may try to redirect the task the user requested.
In October 2025, Brave published details of a vulnerability its researchers had reported to Opera: instructions placed in hidden HTML elements could influence Opera Neon’s assistant. The example involved extracting an email address from an account and sending it to a third party. Brave said Opera deployed a fix on October 21, 2025, and that its subsequent check found the issue apparently resolved. This was a specific, corrected case, not evidence that all browsers behave the same way.
The case illustrates why page content should be treated as untrusted information, even when it looks like an instruction. An agent may receive both the user’s request and the content of the site it is analyzing; if it cannot reliably distinguish between them, a hostile page may try to make it abandon the original goal. Access to other open pages can increase the potential impact.
OpenAI describes prompt injection as a persistent challenge for agents and outlines automated attack exercises and defensive improvements for Atlas. The company also notes that agents may encounter untrusted instructions in pages, emails or documents. Defenses reduce risk but do not make web content trustworthy; that distinction remains important even as a provider updates its models and safeguards.
What confirmations can—and cannot—do
Confirming a sensitive action before it happens can reduce mistakes by letting the user review the recipient, content, amount or selected option before anything is sent or saved. OCU gives examples of tasks where an agent can pause before sensitive steps such as payment. A pause before execution is more useful when it shows what will change and allows the user to correct it before the action occurs.
But confirmation does not solve every problem. If the agent has misunderstood the page, it may present the wrong action for approval; if the user confirms without reading, the safeguard loses value. Approval for one operation should not be treated as blanket permission for other changes. Keep the task’s scope specific and require explicit review for higher-impact actions.
Providers may combine confirmations with attack training, monitoring and other safeguards. OpenAI describes a security update for Atlas and an ongoing process of testing and adjustment. That documents the provider’s measures, but does not guarantee that every future attack will be blocked. Security depends on multiple layers, including the choices users make about what to delegate.
A simple rule is to require human review for any step that is difficult to reverse or affects someone else: sending messages, publishing content, sharing files, changing account details, booking or paying. Review reading, extraction and organizational results, too, before relying on them.
Which tasks to delegate and which to review
Delegation makes most sense when the goal is clearly defined and the result can be checked before it has an effect. Asking an agent to gather published hours, compare features or summarize a page leaves the user in a position to validate the information. Automation can save steps, but a human should review the result if it will inform an important decision.
Tasks that write or send information call for greater care. Filling in a form as a draft is not the same as submitting it; preparing a message is not the same as sending it. If a feature lets you stop before the final step, use that checkpoint and verify fields containing personal or financial information, or instructions with consequences.
A practical classification can help before each task:
- Reading and summarizing: Summarize a page or gather public information; check names, dates and links before relying on the result.
- Reversible preparation: Filter results or fill in a draft without sending it; check every field and the destination site.
- Actions with consequences: Send, publish, buy, book, cancel or change an account; keep final approval in the user’s hands.
This classification does not depend on whether an action seems routine. One click can confirm a purchase, change a subscription or share a document. The criterion is the effect, not the number of steps: if a change affects money, access, reputation or data, review it deliberately before execution.
Delegate in stages; keep consequential actions under review
A task can move from reading to preparation to an external action. Review the result at each stage, and retain final approval for actions that affect accounts, money, data or other people.
-
Reading
Review the information
-
Preparation
Check before submission
-
Consequential action
Keep final approval
Capabilities and confirmation controls vary by product and feature; this is a decision aid, not a guarantee of safety.
Sources and references1
Checks before enabling an agent
Before granting access, check what information the feature can use and what options it offers for limiting that context. Find out whether it works with the current tab, multiple tabs or connected accounts; whether the service explains when it sends information to external systems; and whether it lets you delete or disable associated history. There is no universal answer: options depend on the provider and the specific feature.
It also helps to reduce unnecessary context. Close private tabs that are unrelated to the task, avoid leaving sensitive accounts open, and do not ask an agent to operate in a banking or work session if public information is enough. These steps do not eliminate the risk of malicious content on the page being analyzed.
Finally, decide in advance where delegation ends. An instruction such as “compare these options and prepare a recommendation, but don’t book or send anything” sets a clearer limit than a general request to handle a task. If the agent encounters an obstacle, asks for more information or proposes an unexpected action, stop and review the goal.
Agentic browsers can turn repetitive tasks into a faster sequence, but they also bring AI closer to accounts, forms and decisions that once required the user to make each click. The useful rule is not to avoid all automation, but to retain final control over consequential actions and limit access to what the task actually requires.