Skip to content

GUIDE, read 12 Nov 2026

Six agent surfaces cover AI on an employee laptop, and each one runs different code with different privileges

See the full indexAll guides

Surfaces this guide covers

  • Desktop apps
  • IDE assistants
  • Command-line agents
  • MCP servers
  • Browser extensions
  • SaaS copilots

Actions it covers

  • File read
  • Shell command
  • Network call
  • Credential access
  • Data paste
  • Package install

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.

SurfaceFile readShell commandNetwork callCredential accessData pastePackage install
Desktop AI appsUser-attached files; more through MCPThrough MCP toolsYes, to the provider and tool serversThrough MCP config and env valuesYesThrough MCP tools
IDE assistantsYes, across the workspaceYes, in agent modeYesProject files and environmentYesYes, via the terminal
Command-line agentsYesYesYesYes, via the user's shell and filesNot a typical pathYes
MCP serversWhatever the server exposesIf the server exposes itYesEnv values in configNot a typical pathPackage runners at launch
Browser extensionsPage content onlyNoYesCookies and sessions, by permissionYesNo
SaaS copilotsCloud data the user can openNoWithin the vendor's cloudVia tenant connectorsYes, in the promptNo

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

Sources

  1. modelcontextprotocol.io: connect to local servers, read 12 Nov 2026
  2. modelcontextprotocol.io: transports specification 2025-11-25, read 12 Nov 2026
  3. modelcontextprotocol.io: security best practices, read 12 Nov 2026
  4. Microsoft: VS Code enterprise policies, read 12 Nov 2026
  5. Cursor: MCP docs, read 12 Nov 2026
  6. Anthropic: Claude Code server-managed settings, read 12 Nov 2026
  7. Google: Chrome extension permission warnings, read 12 Nov 2026
  8. Perplexity: Comet, read 12 Nov 2026
  9. Microsoft Learn: Edge extension management reference, read 12 Nov 2026
  10. Google: Chrome Enterprise Help, ExtensionSettings policy, read 12 Nov 2026
  11. Anthropic: prompt injection defenses in browser use, read 12 Nov 2026
  12. Microsoft Learn: Purview and generative AI apps, read 12 Nov 2026
  13. Microsoft Learn: manage application permissions, read 12 Nov 2026
  14. OWASP GenAI: LLM06 excessive agency, read 12 Nov 2026

Last reviewed 12 Nov 2026.