The web is where most work actually happens. So the most useful thing an AI agent can do is not describe a task in a browser. It is to do the task, in a real browser you control, while you watch every move and keep the power to stop.
For years, capable agents have stopped at the edge of the browser. They could research a page, summarize a thread, or draft the message, but the last mile still belonged to you: open the tab, click the button, fill the field, check the result, submit.
Melaya Browser Control closes that last mile on the web, and it does it for everyone. A Melaya agent can now drive a real desktop browser you own, Chrome, Edge, or Brave, open a page inside a session you granted, read the page as a compact accessibility tree, click, type, scroll, switch tabs, and continue from what is actually on screen. You watch it live. You approve what matters. You stop it with one click.
This is the counterpart to Melaya Device Control on Android, and it answers three problems at once.
- Mobile automation left a lot of people out. Device Control drives Android. If you live on an iPhone, or your work simply lives in web apps, the phone was never the surface that mattered. The browser is. And you already have one.
- Open-source browser agents ask too much. The DIY route means installing a Python stack, wiring a headless Chromium over CDP, babysitting selectors, and accepting that there is no real permission model, no approval step, and no one watching but you. That is a weekend project, not a product.
- Most browser automation has no control stack. Record-and-replay macros break the moment a page moves. Raw agent frameworks hand the model the keys and hope the prompt holds. Neither gives you signed, scoped permission, a human-in-the-loop for consequential actions, a live view, or a hard stop.
Melaya Browser Control is the governed version. Connect a browser, grant a scope, and let an agent work the web the way a careful person would, inside a system that knows whose browser it is, which sites are in play, what the page became, when you must decide, and how to stop.
Ask once. Watch it drive.
The fastest way in is the chat built into the Browser Control page. Connect a browser, then describe the outcome in plain language:
"Open Google, search for the latest pricing on our top three competitors, open each result, and give me a short comparison I can paste into a doc."
You do not model a single click. The agent picks a browser tool, Melaya routes a bounded command tied to your account and the browser you granted, the page executes it, and the fresh page comes back so the agent decides from what is really there, not from memory. The live mirror shows the tabs it opens and the page it is on. The tools it used collapse into a tidy count under each reply, exactly like the main Melaya assistant.
The shift is subtle but real. You are no longer copying instructions out of a chat and into a dozen manual clicks. The agent carries the intent into the browser and keeps checking the actual screen before it acts again.
You watch the run as it happens and read exactly which browser actions the agent took, the same tool stream you know from the Melaya assistant, now driving a real browser.
You express the outcome. Melaya operates only the browser and the sites you granted. The page stays visible, and consequential moments come back to you.
Two ways to connect a browser, both without a technical setup
You should not have to install a toolchain to let an agent use a browser. Melaya gives you two paths, and you pick the one that fits the moment.
A dedicated Melaya browser, launched by your runner
The default path launches a clean, dedicated browser profile through the Melaya runner already on your machine. One click in the target picker and a real Chrome, Edge, or Brave window opens, controlled over the DevTools protocol, isolated from your everyday profile and logins. It is the safest way to try Browser Control: nothing touches your personal sessions, and the agent only ever sees the dedicated profile.
Your everyday browser, through the Melaya extension (coming soon)
For tabs where you are already signed in, the Melaya browser extension is on the way. You will connect it with a normal Melaya login in your browser, with no pairing code to copy and no config files. It will attach to one tab you explicitly select, show the browser's own "being controlled" banner while active, and route every consequential action through an approval in its popup. Until it ships, the dedicated-browser path above gives you the full experience today.
The extension will attach to a single tab you select and show the browser's native control banner, so an active session is never in doubt. Every consequential action gets approved right in the popup.
- No Python environment, no headless Chromium, no CDP wiring to maintain.
- No brittle selector scripts to record and re-record when a page changes.
- No pairing code, ever: the runner path is one click, and the coming extension connects with a normal login.
- No blanket permission: sessions are granted per site, per effect, and expire.
- No blind trust: you watch the run live and can stop it at any second.
How an AI agent operates your browser
There is no separate "browser brain" inside Melaya. Browser actions are ordinary tools in the same agent runtime as research, documents, connectors, memory, and human approval. That keeps web work composable with everything else you build.
The agent reads the page as a compact tree of interactive elements, each with a stable reference, so a click targets the right control rather than a screenshot guess. When plain text is not enough, it can take a downscaled screenshot for visual context and act by coordinates. It waits for the page to settle, handles cookie banners and dialogs, and re-reads after anything that changes the page, because a page that moved is the normal case, not the exception.
Built for the web as it really is
Web pages are dynamic, personalized, localized, and constantly redeployed. An element can exist on screen and off screen at the same time. A single-page app can swap the whole view under the agent while it reasons. A search can throw a consent wall in front of the results.
Browser Control is designed around those conditions, not against them.
- Observe after acting. A successful action returns the page that now exists, so the next decision is grounded in reality, not in a remembered layout.
- Reference the real element. The agent targets a stable element reference from the live tree, and can resolve visible text like an "Accept all" button, before falling back to coordinates.
- Manage tabs in the session. The agent can open, switch, and close tabs inside the browser you granted, and the live mirror shows the full tab strip so you can follow along or switch the view yourself.
- Stay inside the fence. Navigation is checked against the sites you allowed for the session. Dangerous destinations like local network addresses and cloud metadata endpoints are always blocked, even when you grant "any site."
- Do not type secrets. The agent is prohibited from typing passwords, one-time codes, and card numbers. When a step needs one, it hands control back to you.
This is an architectural point, not a benchmark claim. Less waiting between action and evidence, and fewer chances for the agent to reason from a page that no longer exists.
Permission is part of the product
Giving an agent a browser creates a sharper trust problem than giving it a read-only API. A paragraph in a prompt is not a boundary. The boundary has to survive a confused model, a moved page, and a hostile site trying to talk the agent into something.
So Melaya treats permission as an execution rule, not a suggestion. Every session an agent drives is backed by a signed grant, and the trusted Melaya UI is the only thing that can mint it. The model never issues its own permission.
- A session grant is a signed, single-use, short-lived token, minted only by the trusted Melaya interface, never by the model.
- The grant is bound to your account, the exact browser, the session, the allowed sites, and a ceiling on how consequential an action may be.
- Origin policy is enforced where actions happen. Off-limits sites return a clear blocked result the agent cannot argue past.
- Local network, private, and cloud-metadata destinations are denied by default, even under an allow-any-site grant.
- Secrets are off limits in inputs. Passwords, OTP codes, and card numbers route to a human handoff, never the model.
- The coming extension path will attach to one selected tab, show the browser's own control banner, and be revocable at any time.
Live means controllable, not just observable
You are never automating in the dark. A run always shows you two things: that it is happening, and how to end it.
The Browser Control page streams a live mirror of the session, with the tab strip, the current address, and the agent's actions as they occur. A branded "Controlled by Melaya" marker on the page makes an active session unmistakable. And you are always one control away from taking over.
- A live mirror shows the granted session, the open tabs, and each action as it happens.
- Take over pauses the agent so consequential actions hold while you drive the real window yourself.
- Emergency stop ends the run and revokes the session immediately, from the page.
- Consequential effects such as posting, purchasing, or account changes pause for a human decision.
- The session is scoped to you: a grant for your browser can never be used to touch someone else's.
Taking over pauses the agent so nothing consequential runs while you hold the wheel. Emergency stop ends the run and revokes the grant immediately, from the same page you are watching.
Automation can prepare the moment. The person should still own the consequence. Composing a post and publishing it are not the same action, and Melaya treats them differently.
Why this beats the do-it-yourself route
It is genuinely impressive that you can wire an open-source agent to a headless browser in an afternoon. It is also the wrong tool for real work. A raw script has no idea whose browser it is on, no scoped permission, no approval for the risky step, no live view for you, and no clean way to stop. The first time it clicks the wrong button on a page that redeployed overnight, you find out the hard way.
Browser Control gives you the reasoning of a modern agent with the guardrails of a product: a signed grant, an enforced site scope, a human-in-the-loop for consequential effects, a live mirror, and a hard stop. The same reliability model that keeps the rest of Melaya honest, described in the anti-hallucination system, applies here too. The same security posture behind Melaya security and compliance governs the runtime underneath.
The web and the phone, one agent runtime
Browser Control and Device Control are two surfaces on the same idea: give an agent a visible, user-governed path through the interfaces where daily work already happens. Device Control reaches Android apps. Browser Control reaches every web app, on any desktop OS, which is exactly where the people who could not automate a phone can finally automate their work.
Because both are ordinary tools in one runtime, a single agent can research with the web tools, act through the browser, pull from your connectors, remember across steps, and pause for your approval, all in one workflow. Start from the chat for a one-off, then save the working flow as a pipeline and refine the agent, the model, the schedule, and the approval rules. See everything that shipped around it in the July 2026 recap.
What Browser Control is, and what it is not
Browser Control is scoped, governed automation of a real desktop browser you own. It combines the breadth of the web with the reasoning, memory, tools, evaluation, and workflow design already in Melaya.
It is not invisible control of every tab you have open. It is not a reason to hand an agent a blanket permission. It is not a promise that a third-party site will never change under it. And it is not permission to automate what a service forbids.
Good Browser Control agents stay selective: read before acting, use the accessibility tree when it is enough, take a screenshot only when the visual context is needed, stay inside the granted sites, stop on ambiguity, and summarize what changed.
Try it today
Browser Control is live for Melaya users now. Connect your AI provider, open the Browser Control page, and launch a dedicated Chrome, Edge, or Brave browser with one click. The extension for driving your own logged-in tabs is coming soon.
Explore Melaya Browser Control, read the setup guide in the docs, or create your account and drive your first browser session.
