Security teams ask engineers which AI tools they use. The answer they get is a list of applications. That list is the wrong unit.
An AI coding agent is not dangerous because of its name. It is dangerous because of what it can reach: the servers it connects to, the commands it may run, the sign-ins it borrows. So I stopped counting applications and counted reach, on my own laptop.
The count #
| What | Number |
|---|---|
| AI applications that can act for me | 13 |
| MCP server entries those applications can call | 43 |
| Entries named in a settings file | 34 |
| Entries no settings file names | 9 |
| Of those 9, entries with nothing that can stand in front | 5 |
| Entries with a credential in plain text | 3 |
43 counts entries, not distinct servers. There are 26 distinct names. The same server declared for two applications counts twice, because each application reaches it on its own, with its own sign-in.
I build agentic systems every day, so my laptop is heavier than most. One laptop is also not a survey. But the shape of the result is what matters, and I expect it to repeat on any engineer's machine.
Four places a server can come from #
An inventory script reads the first place. The other three are where the 9 came from.
1. A settings file: 34 entries
Each agent keeps its own file, in its own format.
| Agent | Where it names its servers |
|---|---|
| Claude Code | ~/.claude.json , per user and per project, plus.mcp.json in a repository |
| Codex | ~/.codex/config.toml , one[mcp_servers.<name>] table per server |
| Cursor | ~/.cursor/mcp.json |
| VS Code | the user's settings.json ormcp.json |
| Claude Desktop | claude_desktop_config.json in the application's support folder |
| Junie | ~/.junie/mcp/mcp.json |
This is the part every scanner already covers. A repository's own .mcp.json is worth a second look: it arrives with a git clone, and three of my entries are declared that way.
2. A plugin: 7 entries
A plugin is a folder, and the folder can carry a .mcp.json of its own:
{
"mcpServers": {
"team-chat": {
"type": "http",
"url": "https://mcp.example.com/mcp"
}
}
}
The agent loads that server when it loads the plugin. Nothing is written to the settings file.
On my laptop the settings file of one agent names 4 servers. That agent can call 11. The other 7 came from plugins:
- 3 shipped with the agent itself. I never chose them.
- 2 came from the agent's own plugin marketplace.
- 2 sit in that agent's plugin cache under the marketplace of a different agent.
Four of the seven are local programs. Three are remote: a calendar, a team chat and a deployment platform. A remote plugin server signs in through the agent's own login, so the token lives inside the agent and the traffic goes straight from the agent to the service. There is no local process to wrap and no key of yours to take away.
3. An editor extension: 1 entry
VS Code lets an extension provide MCP servers from code. The extension declares a provider in its package.json:
"contributes": {
"mcpServerDefinitionProviders": [
{ "id": "example.server", "label": "Example MCP" }
]
}
and at run time calls vscode.lm.registerMcpServerDefinitionProvider to hand the editor the server's definition. The definition is built in code each time the extension starts, so it can change between two launches without any file changing. The editor's own agent can then call it. A scan of settings files reports zero.
4. Not MCP at all: 1 entry
A desktop AI app keeps a small program running on my laptop. An agent that runs at the vendor uses it to run commands and read files here. It speaks its own protocol, so nothing that watches MCP sees it.
What I found in that app's own settings:
- Five standing rules that approve the remote agent's actions without asking me.
- A switch, turned on, that lets the remote agent send passkey sign-in requests to my machine.
None of the nine was hidden with bad intent. Each is a product feature that works as designed. That is the point: the gap is not malware, it is ordinary software doing what it says, in a place nobody is looking.
The five #
Of the nine, four are local programs that a control can be placed in front of once you know they exist. Five are not:
- The three remote plugin servers, which sign in through the agent's own login.
- The server an extension registers inside the editor.
- The desktop app's program, which is not MCP.
For these five the honest position today is an inventory, the vendor's own switches, and a decision about whether the plugin, the extension or the app is allowed at all.
Credentials in the clear: 3 entries #
Two shapes, both common in the examples that server authors publish:
"env": { "EXAMPLE_API_KEY": "<the real key, typed here>" }
"headers": { "Authorization": "Bearer <the real token, typed here>" }
On my laptop these files are readable by my user only. That does not help much. Every AI agent on the machine runs as me, and so does everything those agents run.
What this means for a security team #
- An inventory built from settings files undercounts. On my laptop it misses 9 of 43, about one in five. The ones it misses are the ones with the least control.
- A plugin is a supply chain. Approving a plugin approves whatever servers it declares, today and after its next update. Three of mine came with the agent and asked nobody.
- "We allow only approved AI tools" is not a policy. The approved tool is a shell. What it connects to changes with every plugin and every update, and the engineer decides.
- A remote server that uses the agent's login has no local chokepoint. The control point is the plugin, or the account the agent signs in with.
- Plain-text credentials are back. We spent a decade taking keys out of files. Agent settings put them back.
Count it yourself #
These run on macOS and Linux and need jq. They cover the two agents I use most. Add the other files from the table above for the rest.
Servers named in settings files:
jq -r '[(.mcpServers // {} | keys[]),
(.projects // {} | to_entries[] | .value.mcpServers // {} | keys[])]
| unique | .[]' ~/.claude.json
grep -E '^\[mcp_servers\.[^.]+\]#x27; ~/.codex/config.toml
Servers declared by plugins, with the address or the program each one starts:
find ~/.claude/plugins/cache ~/.codex/plugins/cache -name .mcp.json \
-exec jq -r '(.mcpServers // .) | to_entries[]
| "\(.key)\t\(.value.url // .value.command)"' {} + 2>/dev/null | sort -u
Editor extensions that register a server from code:
find ~/.vscode/extensions ~/.cursor/extensions -maxdepth 2 -name package.json \
-exec grep -l '"mcpServerDefinitionProviders"' {} + 2>/dev/null
Settings files that hold a key in the clear (it prints file names, never the key):
grep -lE '"(Authorization|[A-Za-z_]*(KEY|TOKEN|SECRET)[A-Za-z_]*)"[[:space:]]*:[[:space:]]*"[^"$]{16,}"' \
~/.claude.json ~/.cursor/mcp.json 2>/dev/null
There is no single command for the fourth place. List the programs each AI desktop app keeps running, then open that app's settings and read its approval rules.
Then ask the question that matters for each entry: if this one sent data out or ran a command, would anything stop it, and would anyone know?
What I did about mine #
RegulAI is the product we built for this. 38 of the 43 entries now pass through one gateway that allows, asks first or blocks each call before it runs: the 34 from settings files and the 4 local plugin servers. The other five are listed in the console with what each can reach, because a control you cannot place should at least be a fact you can see.
The numbers above come from our own scanner. The commands are there so you can check the same things by hand, with or without us.