GUIDE, read 12 Nov 2026
Six agent surfaces cover AI on an employee laptop, and each one runs different code with different privileges
How does endpoint security work for AI agents?
An AI agent is software that takes actions on a person's behalf, usually by calling tools in a loop. Where that software runs decides which actions it can take and which controls can reach it. A program in a browser tab is bound by the browser's rules. A program started from a terminal is bound by the user's operating system permissions. A service in a vendor's cloud is bound by the permissions you granted it through OAuth.
A surface is a place where an AI system acts, and the place sets the privileges
This site groups agent software into six surfaces. The grouping is by place of execution, not by vendor, because the endpoint control that applies depends on the place. Examples named below are illustrations from vendor documentation read on 12 Nov 2026, and the list is not a market map.
The six actions that matter for security are file read, shell command, network call, credential access, data paste and package install. The last section crosses the surfaces with the actions. Reading that table first is a reasonable way to use this page.
Desktop AI apps run as the user, but usually inside their own application boundary
A desktop AI app is a standalone application with a chat interface, installed like any other program. Claude Desktop is one. It reads a config file that can define local MCP servers, in claude_desktop_config.json under the user's application support (macOS), APPDATA (Windows) or .config (Linux) folder (modelcontextprotocol.io, connect local servers page).
What runs: the app's own process, plus any child processes it starts for tools. What privileges: those of the signed-in user, limited by the operating system's per-app permission prompts, such as access to the Documents folder on macOS. What matters most: the app reads files the user attaches, and with MCP servers configured it can read and write files, query systems and run commands through them.
Control points: application allowlisting, MDM-managed settings where the app supports them, and the config file that adds tools. The app's own network traffic goes to its provider, and a network proxy can see the domain.
IDE assistants run inside the editor and inherit the project's reach
IDE assistants live in an editor or an editor fork. GitHub Copilot in VS Code and Cursor are two examples. They read open files and the project tree, propose edits and, in agent mode, run terminal commands and call MCP tools.
What runs: the editor process and its extension host, plus terminals and tool servers it launches. What privileges: the user's. An editor terminal is a normal shell. What matters most: file read across the workspace, shell command execution, package install through the terminal, and credential access through files such as environment files in the project.
Control points are richer than for desktop apps. Microsoft publishes VS Code enterprise policies that control access to MCP servers and an allowlist for them, along with policies for agent hooks and plugins (Microsoft, VS Code enterprise policies page). Cursor documents its own MCP config files and fields (Cursor docs, MCP). Because these are editors, they usually run on developer machines that hold source code, signing keys and cloud credentials, which raises the stakes.
Command-line agents run in a terminal with the user's shell, files and credentials
A command-line agent is started from a shell and works on the current directory. Claude Code is the documented example here. It has user, project and organization scopes for settings and MCP servers, and an organization can deploy endpoint-managed settings through native OS policies (macOS managed preferences, Windows registry) or a managed settings file (Anthropic, Claude Code server-managed settings page).
What runs: a long-lived process in a terminal, which starts child processes for each shell command. What privileges: everything the user's shell can do, bounded by whatever permission rules and sandboxing the agent applies. What matters most: shell command, file read and write, network call, package install and credential access, since the shell can reach the user's SSH keys, cloud credentials and tokens.
This is the surface with the thinnest default guardrails outside the tool's own settings, and the one where a process record is least informative, since a shell command run by the agent looks like one typed by the developer. Control points are the agent's managed settings, sandboxing where available, and an endpoint sensor that links commands to the agent session.
MCP servers are separate processes or remote services that give agents tools
The Model Context Protocol defines how an AI application calls tools and data sources. A server can run locally as a subprocess that the client launches over stdio, or remotely over Streamable HTTP (Model Context Protocol specification, transports page, read 12 Nov 2026). A local server can be a file system tool, a database client, a browser controller or a wrapper around a company API.
What runs: a process on the laptop, started by the client from a command in a config file. What privileges: the MCP security best practices page says local servers run with the same privileges as the client and may have direct access to the user's system, and it asks clients to show the exact startup command, require consent, and sandbox the server with restricted file system and network access (modelcontextprotocol.io, security best practices page).
What matters most: whatever the server exposes. A file server gives file read and write. A shell server gives shell commands. A database server gives network calls with stored credentials. Because one client config can define many servers, the surface multiplies the actions of every agent that uses it. The local MCP servers guide covers discovery and control in detail.
Browser extensions and AI browsers run inside the browser with the user's sessions
Browser extensions run in Chrome or Edge under the permissions in their manifest. Google explains that permission warnings describe API capabilities, and that a broad host permission lets an extension act across all sites (Chrome for Developers, permission warnings page). AI browsers such as Perplexity's Comet embed the AI in the browser itself (Perplexity, Comet page, vendor claim).
What runs: extension code in the browser, or an agent inside an AI browser. What privileges: the page content and the user's signed-in sessions, but not the local shell or arbitrary files, with the exception of file pickers the user approves. What matters most: data paste and upload, network calls to the AI provider, and actions on sites where the user is signed in.
Control points are the extension policy in Chrome and Edge, which can allow, block, force and restrict extensions (Microsoft Learn, Edge extension management reference; Google, Configure ExtensionSettings policy), and browser-level DLP. Anthropic's note that no browser agent is immune to prompt injection applies to this surface in particular (Anthropic, prompt injection defenses post).
SaaS copilots run in the vendor's cloud, with permissions you granted
A SaaS copilot is an AI feature inside a hosted product: Microsoft 365 Copilot is one, and Microsoft documents the Purview protections that apply to it and to other generative AI apps (Microsoft Learn, Purview and generative AI apps page). It runs in the vendor's cloud and acts on the data the signed-in user can already access in that product.
What runs: nothing on the laptop other than the browser or app used to reach it. What privileges: the user's permissions inside the SaaS product, plus any connectors an admin turned on. What matters most: data the copilot can retrieve and summarize, which is everything the user can open. The risk is oversharing: a user with access to too many files lets the copilot surface them.
Control points are tenant settings, sensitivity labels, access reviews and the OAuth grants for connected apps (Microsoft Learn, manage application permissions page). An endpoint product sees this surface only through the browser or through an API connector.
Which actions each surface can take, side by side
The table marks what each surface can typically do. 'Yes' means the capability is common in the category. Individual products differ, and tools often gate these behind permission prompts that a user or policy can set.
| Surface | File read | Shell command | Network call | Credential access | Data paste | Package install |
|---|---|---|---|---|---|---|
| Desktop AI apps | User-attached files; more through MCP | Through MCP tools | Yes, to the provider and tool servers | Through MCP config and env values | Yes | Through MCP tools |
| IDE assistants | Yes, across the workspace | Yes, in agent mode | Yes | Project files and environment | Yes | Yes, via the terminal |
| Command-line agents | Yes | Yes | Yes | Yes, via the user's shell and files | Not a typical path | Yes |
| MCP servers | Whatever the server exposes | If the server exposes it | Yes | Env values in config | Not a typical path | Package runners at launch |
| Browser extensions | Page content only | No | Yes | Cookies and sessions, by permission | Yes | No |
| SaaS copilots | Cloud data the user can open | No | Within the vendor's cloud | Via tenant connectors | Yes, in the prompt | No |
Use the surfaces to ask a vendor where its coverage stops
Take the six surfaces and the six actions and put a mark next to each pair for which a vendor claims coverage. Then ask the vendor for the component that sees it, and the way it can stop it. Most products cover two or three surfaces well. A product that claims all six should show you each one running on a test device.
Order your own priorities by exposure. For a company with many developers, command-line agents, IDE assistants and MCP servers carry the highest-impact actions: shell commands, credential access and package installs. For a company where most staff are knowledge workers, browser extensions, desktop AI apps and SaaS copilots hold more of the data-paste and oversharing risk.
OWASP's guidance on excessive agency is a useful frame for the review. It names excessive functionality, excessive permissions and excessive autonomy as root causes (OWASP GenAI Security Project, LLM06). Each surface above is a place where one of the three can creep in: a tool server with more functions than needed, a shell with broad permissions, a browser agent that acts without confirmation.
Where this sits in the index
- Agent Surface MapWhich of six agent surfaces each of 16 tools sees
- Action Control MatrixWhich of six agent actions each tool can stop
- The ranked index16 tools on seven published criteria
Related guides
- Securing Claude Code on developer laptops
- Securing Cursor on developer machines
- Shadow AI detection signals
Sources
- modelcontextprotocol.io: connect to local servers, read 12 Nov 2026
- modelcontextprotocol.io: transports specification 2025-11-25, read 12 Nov 2026
- modelcontextprotocol.io: security best practices, read 12 Nov 2026
- Microsoft: VS Code enterprise policies, read 12 Nov 2026
- Cursor: MCP docs, read 12 Nov 2026
- Anthropic: Claude Code server-managed settings, read 12 Nov 2026
- Google: Chrome extension permission warnings, read 12 Nov 2026
- Perplexity: Comet, read 12 Nov 2026
- Microsoft Learn: Edge extension management reference, read 12 Nov 2026
- Google: Chrome Enterprise Help, ExtensionSettings policy, read 12 Nov 2026
- Anthropic: prompt injection defenses in browser use, read 12 Nov 2026
- Microsoft Learn: Purview and generative AI apps, read 12 Nov 2026
- Microsoft Learn: manage application permissions, read 12 Nov 2026
- OWASP GenAI: LLM06 excessive agency, read 12 Nov 2026
Last reviewed 12 Nov 2026.