One-line takeaway
The old automation problem was "the script was wrong". The new agent problem is "it understood something else and did it anyway". The first can be covered by regression tests; the second can only be contained by permission boundaries.
Three companies, one question, one week
Between November 19 and 20, 2026, three unrelated developments pointed at the same issue.
Google shipped Computer Use for the macOS Gemini app: natural-language requests drive clicks, typing, form filling and menu actions across applications. Tasks run in a separate background window, a live preview streams in the chat pane, sensitive steps require confirmation, and the user chooses which apps may be accessed.
According to multiple reports, Apple is developing its own computer-use agent able to operate apps, browse the web and write code, still early stage, and is preparing additional permission warnings for competing agents.
Meta's Muse ran into a different problem: employees reported seeing other people's parenting messages, personal reminders and bank balances inside their own sessions. Meta said the build under test was not yet public.
Each maps to a different anxiety: scope (what Gemini can touch), system (whether the OS should warn), and isolation (whether context can leak).
The three layers of permission
Strip the products down and only three layers exist. Every implementation makes a trade-off among them.
| Layer | Decided by | Governs | Observed approach |
|---|---|---|---|
| App | User | Which programs and folders an agent may touch | Gemini: user selects apps, not the whole machine |
| Action | Agent + user | Whether a specific step executes | Gemini: confirmation before sensitive steps, pause and stop at any time |
| System | Operating system | Whether to warn, label and show an indicator | macOS 27.3: risk disclosure, scope statement, indicator that an app is controlling another |
The division of labour makes sense. The app layer answers "how far", the action layer answers "should this step happen", and the system layer answers "does the user know".
Gemini acts on all three, with the centre of gravity at the app layer. It decomposes "control of the machine" into "which apps may be operated". That lowers the worst-case ceiling: even if the model misjudges, the damage stays inside the ticked applications.
The macOS 27.3 plan fills in the system layer, so a user can always see that something is controlling something else, and is told what that access implies. The detail that already-authorised apps need no re-approval matters: if every update demanded re-approval, users would click "allow" reflexively and the warning would lose its force.
Three failure modes
Permission design prevents what should not happen. Real failures, however, usually arrive from three other directions.
One, scope too broad. A user grants whole-machine control for convenience, or an agent borrows an authorised app to reach data it should not see (reading the whole disk through a file manager, for instance). The root cause is coarse granularity.
Two, context bleed. The Muse reports belong here. The problem was not excessive permission but weak isolation between sessions. An agent typically reads screen contents, clipboard, notifications and recent files. If that environmental data crosses into somebody else's session, it becomes a disclosure. Allowlists cannot fix this, because the failure is not about which app is reachable but whose context is reachable.
Three, invisible execution. An agent runs dozens of steps in the background and the user sees only the result. If one step misreads the intent - "tidy the desktop" becoming "delete the Downloads folder" - and nobody watched, the loss has already occurred. Gemini's live preview and pause control target exactly this.
The three have different remedies: scope needs granularity, bleed needs isolation and account boundaries, invisibility needs process transparency. None substitutes for another.
How this differs from RPA
Someone will ask whether this is just RPA with a chat box. Two differences.
First, the input. RPA depends on pre-written scripts or recorded sequences. Behaviour is predictable and failures are mostly engineering problems, such as a UI change breaking element location. An AI agent takes natural-language instructions and decides behaviour at runtime; failures are mostly semantic, a misread intent. The first can be regression-tested. The second is hard to enumerate.
Second, the range. RPA is reliable only inside fixed flows and must be rewritten when the flow or interface changes. An agent handles variation, at the cost of never executing quite the same way twice. Reliability and coverage trade off along that line.
That is why permission design matters far more for an agent than for RPA. An RPA risk is mostly "it did the wrong thing". An agent's risk is "it did, correctly, something you never asked for".
Four checks worth running
These are not forecasts. They follow directly from the facts above.
First, is permission granted per app rather than per machine? A tool offering only "full control" has shifted the entire scope risk onto the user.
Second, can execution be interrupted? Being able to pause where visibility is thin sets the ceiling on the cost of a misjudgement.
Third, are sensitive actions confirmed twice? Delete, pay, send and change system settings should default to interception rather than default to passing through.
Fourth, is there a system-level indicator? Whether the OS shows that an agent is operating cannot be verified before 27.3 ships, but it determines the most basic question: whether the user knows.
A detail that gets overlooked
The background-window design is not only a comfort feature; it also changes what auditing is possible.
Classic foreground automation leaves visible traces: window switches, cursor movement, button highlights. Background execution pulls those traces into another window where the main screen does not show them. The benefit is that it does not interrupt. The cost is that a bystander can no longer notice anomalies by glancing at the screen.
Auditing therefore shifts from "visible to the eye" to "logs and status indicators". The transparency indicator planned for macOS 27.3 fills that gap at the system level, making invisible execution visible again. If a user switches the indicator off or ignores it, background execution returns to being a black box.
A counterpoint
On the same day, the European Commission confirmed an AI-assisted cyberattack that knocked out HR and medical reimbursement systems for more than ten days.
The reminder: AI is speeding up the attack side too, accelerating vulnerability discovery and compressing reconnaissance that once took weeks. The more control an AI agent is granted on the defensive side, the more paths exist to be exploited.
So the net benefit of "an AI that can operate a computer" depends not only on how well the product is built, but on how much attack surface it exposes. An agent that can read the screen, click buttons and fill forms, if induced into the wrong action, is indistinguishable in effect from a malicious script.
Boundaries
- Gemini for Mac's feature set, permission model, hardware and plan requirements come from Google's official materials and press coverage;
- Apple's in-house agent is press-reported and unconfirmed; this article records the development without inferring its implementation;
- The Muse session-isolation reports come from employees and press, with Meta stating the tested build was not public; the nature of the incident awaits the company's investigation;
- The macOS 27.3 warnings are pre-release descriptions; actual behaviour depends on the shipped system;
- Facts on the European Commission incident appear in a separate report published the same day; this article cites it only as context and judges no country or institution;
- This article provides no method for bypassing permissions, suppressing system prompts or widening an agent's scope; it discusses design and governance from public information only.
