AI agents & MCP
What does the AI agents & MCP cluster cover?
AdminKit groups this topic into the AI agents & MCP cluster: The Model Context Protocol lets AI agents call tools and read resources over a network connection, which means an unauthenticated or misconfigured MCP server can hand an agent — or an attacker — more access than intended.
Guides (15)
All guides →- Check if Your MCP Server Is Exposed With AdminKit
- Connect an AI Agent to the AdminKit MCP Server | AdminKit
- Audit SPF and DMARC With an AI Agent | AdminKit
- Find Open Ports You Own, From an AI Assistant
- Is Port 11434 (Ollama API) Exposed? | AdminKit
- MCP Server Authentication Checklist | AdminKit
- MCP Tool Poisoning Attacks Explained | AdminKit
- Scan an MCP Endpoint in CI Before Agents Trust It | AdminKit
- How to Vet an MCP Server Before You Connect | AdminKit
- How to Check for MCP Tool Poisoning | AdminKit
- How to Read an MCP Endpoint Check Result | AdminKit Guide
- How to Secure an MCP Server | AdminKit Guide
- MCP Tool Annotations Explained | AdminKit Guide
- The MCP Confused Deputy Problem | AdminKit Guide
- Security Gateway for MCP Servers | AdminKit Guide
Glossary (34)
Full glossary →- A2A (Agent2Agent Protocol) — A2A (Agent2Agent Protocol) is an open spec letting independent AI agents, built on different frameworks, discover each other's capabilities via a published Agent Card and delegate tasks between them. It solves a different problem than MCP: MCP connects an agent to tools, A2A connects one agent to another. AdminKit's MCP & Agent Gateway governs the MCP side.
- Cancellation (MCP) — Cancellation is how either side of a Model Context Protocol connection asks the other to stop an in-progress request, sending a notifications/cancelled message that names the request's ID and an optional reason. AdminKit's security gateway for MCP servers logs these notifications, alongside progress updates, as they pass through a long-running call.
- Completion (MCP) — Completion is a Model Context Protocol request, completion/complete, that lets a server offer IDE-like argument autocompletion for a prompt or a resource template's URI, returning up to 100 ranked suggestions per response. AdminKit's MCP gateway sits in the request path every call, including completion requests, passes through on its way to a server.
- Confused deputy problem — The confused deputy problem is a security flaw where a trusted program is tricked by a less-privileged caller into misusing its own authority on that caller's behalf -- a risk AdminKit's MCP server security guide covers for agent-tool gateways that forward a token without checking who it was actually issued for.
- Context window — A model's context window is the maximum number of tokens -- prompt, instructions, tool output and the model's own reply -- it can process in one request, a limit each vendor sets for its own models. AdminKit's guide to securing an MCP server treats anything an agent reads into that window, including tool output, as untrusted by default.
- Elicitation (MCP) — Elicitation is a Model Context Protocol capability letting a server pause mid-task and ask the client to collect more information from the user, rather than requesting everything a tool needs up front. AdminKit's guide to securing an MCP server covers why elicitation requests need the same explicit user review as a tool call.
- JSON-RPC — JSON-RPC is a lightweight remote-procedure-call format, specified at jsonrpc.org, that encodes a method, parameters and an ID as JSON. Version 2.0 is the wire format the Model Context Protocol requires for every client-server message. AdminKit's MCP endpoint check probes a server's initialize and tools/list JSON-RPC calls directly.
- JWKS (JSON Web Key Set) — A JWKS (JSON Web Key Set) is a JSON object publishing an authorization server's current public keys, each one a JSON Web Key, so a resource server can verify a JWT's signature without a hardcoded key. The AdminKit MCP & Agent Gateway, which Netbase deploys and runs for customers, validates OAuth tokens against a server's JWKS the same way.
- JWT (JSON Web Token) — A JWT (JSON Web Token) is a compact, signed string of claims -- who issued it, who it's for, when it expires -- used as an OAuth 2.0 bearer token so a resource server can verify a request's sender without calling the issuer. AdminKit's guide to the MCP confused deputy problem covers why checking a JWT's audience claim matters.
- MCP (Model Context Protocol) — MCP (Model Context Protocol) is an open standard defining how AI agents and assistants connect to external tools, data sources and services through one shared interface, instead of a custom connector for every integration. AdminKit's MCP gateway sits between an agent and the MCP servers it calls, applying the protocol's own security guidance to that traffic.
- MCP logging — MCP logging is a Model Context Protocol capability letting a server send structured, leveled log messages to the client that connects it to an AI agent, for debugging and visibility rather than for the agent's own reasoning. The AdminKit MCP & Agent Gateway, which Netbase deploys and runs for customers, keeps its own operator-facing audit log alongside this client-facing one.
- MCP Registry — The MCP Registry is the official, centralized metadata directory at registry.modelcontextprotocol.io for publicly accessible MCP servers, verifying who published each one through namespace authentication rather than scanning what the server's code actually does. AdminKit's guide to securing an MCP server covers why a server's listing there is not, by itself, a safety signal worth trusting.
- OAuth 2.0 Authorization Server Metadata — OAuth 2.0 Authorization Server Metadata, defined in RFC 8414, is a JSON document an authorization server publishes at a well-known path so a client can learn its endpoints and supported features from the issuer URL alone. AdminKit's MCP server hardening checklist requires publishing this metadata for exactly that reason.
- OAuth 2.0 Dynamic Client Registration — OAuth 2.0 Dynamic Client Registration, defined in RFC 7591, lets a client obtain its own client ID by posting metadata to an authorization server, instead of a developer provisioning credentials manually in advance. AdminKit's MCP server hardening checklist requires supporting it, since general-purpose clients meet unfamiliar servers constantly.
- OAuth 2.0 Protected Resource Metadata — OAuth 2.0 Protected Resource Metadata, defined in RFC 9728, lets a resource server such as an MCP server publish which authorization server issues valid tokens for it, discoverable from a 401 response alone. AdminKit's MCP server hardening checklist requires publishing it so unfamiliar clients can connect.
- OAuth for MCP — The Model Context Protocol's authorization specification defines how an MCP client authenticates to a server using OAuth 2.1, rather than an ad hoc scheme, and explicitly warns against naive token passthrough between services. The AdminKit MCP & Agent Gateway, which Netbase deploys and runs for customers, enforces OAuth per this specification.
- PKCE (Proof Key for Code Exchange) — PKCE (Proof Key for Code Exchange), defined in RFC 7636, stops a stolen OAuth authorization code from being redeemed by anyone but the client that requested it -- mandatory for every client in OAuth 2.1. AdminKit's MCP server hardening checklist covers implementing the OAuth 2.1 flow PKCE belongs to.
- Progress notification (MCP) — A progress notification is how the Model Context Protocol reports incremental status on a long-running request, sent as an optional notifications/progress message tied to a progressToken the client attached to its original request. AdminKit's MCP gateway sits in the request path where these notifications, along with the calls they describe, pass through.
- Prompt (MCP) — A prompt, in the Model Context Protocol, is a predefined, parameterized template a server exposes for a client to surface to its user -- as a slash command, say -- distinct from a model-invoked tool or a data resource. AdminKit's MCP endpoint check surfaces a server's exposed primitives for review, prompts included.
- Prompt injection — Prompt injection is an attack where text an AI agent reads -- a web page, a document, a tool's response -- contains instructions crafted to make the agent act against the user's intent, since models don't reliably separate trusted instructions from untrusted content. AdminKit's guide covers a related MCP confused-deputy risk.
- Resource (MCP) — A resource, in the Model Context Protocol, is a piece of data -- a file, a database record, an API response -- a server exposes to a client by URI, distinct from a tool, which performs an action instead of returning data. AdminKit's guide to securing an MCP server covers why resources need the same scoping review as tools.
- Resource template (MCP) — A resource template is how a Model Context Protocol server exposes a parameterized family of resources, such as file:///{path} for every file in a directory, as one RFC 6570 URI template rather than listing each resource individually. AdminKit's guide to securing an MCP server covers why an exposed resource list, templates included, needs the same scoping as tools.
- Roots (MCP) — Roots are a Model Context Protocol mechanism for a client to tell a server which filesystem directories it may operate within, advertised as one or more URIs the server is expected to honor voluntarily rather than an enforced sandbox. AdminKit's MCP & Agent Gateway applies the same idea to tools with an allowlist.
- Sampling (MCP) — Sampling is a Model Context Protocol primitive letting a server ask the client to run a completion against the client's own LLM rather than needing its own model access, gated on the user explicitly reviewing and approving both the prompt and the result. AdminKit's guide to securing an MCP server covers that same consent requirement.
- Server-sent events (SSE) — Server-sent events (SSE) is a WHATWG web standard letting a server push a one-way stream of text events to a client over one long-lived HTTP connection. MCP's original transport paired SSE with HTTP; AdminKit's own MCP connector instead uses the Streamable HTTP transport that replaced it.
- SSRF — SSRF (Server-Side Request Forgery) is a vulnerability where an attacker tricks a server, or an AI agent calling tools on its behalf, into requesting a destination the attacker chooses rather than the one intended, often reaching internal or metadata addresses. AdminKit's MCP hardening guide covers where this risk enters an agent's tool calls.
- stdio transport (MCP) — The stdio transport is one of MCP's two standard transports, letting a client spawn an MCP server as a local child process and exchange JSON-RPC messages over its standard input and output instead of a network socket. AdminKit's own adminkit-mcp connector defaults to stdio for local use.
- Streamable HTTP transport (MCP) — Streamable HTTP is the MCP transport for a networked server, letting a client connect over ordinary HTTP request and response bodies instead of a locally spawned process; it replaced an earlier HTTP-plus-SSE transport. AdminKit's adminkit-mcp connector supports it via an --http flag for remote agents.
- Structured content (MCP) — Structured content is the optional structuredContent field a Model Context Protocol tool result can return alongside its usual content array, carrying the result as a plain JSON object validated against the tool's declared outputSchema instead of text a client has to parse. AdminKit's guide to securing an MCP server covers why that output still needs validation, not blind trust.
- System prompt — A system prompt is the instruction set an application gives an AI model before a task starts, setting its role and behavior boundaries, separate from user input and content the model reads afterward. AdminKit's guide to securing an MCP server flags tool output that merely imitates a system prompt as a red flag.
- Tool allowlist — A tool allowlist restricts an AI agent, or the gateway mediating its access, to a named, pre-approved set of tools it may call, rejecting any call outside that set even if the server exposes more. AdminKit's MCP/Agent Gateway enforces exactly this kind of allowlist, so a compromised or misconfigured server can't silently widen what an agent is allowed to do.
- Tool annotations (MCP) — Tool annotations are optional Model Context Protocol metadata, like readOnlyHint and destructiveHint, that describe a tool's expected effects so a client can decide how much friction to apply before a call runs -- hints the specification treats as untrusted, not a security boundary. AdminKit's MCP endpoint check infers a similar severity signal from each tool's own description.
- Tool poisoning — Tool poisoning is an attack on AI agents using the Model Context Protocol (MCP), where a tool's description is crafted to manipulate the agent reading it rather than exploiting the tool's actual function, since the agent trusts that description as context. AdminKit's MCP check lists tools exposed without authentication and flags high-risk names.
- Transport security (MCP) — MCP transport security is the set of protections the Model Context Protocol specification requires per transport: the OS process boundary and environment credentials for stdio, and Origin validation against DNS rebinding plus authentication for Streamable HTTP. AdminKit's guide to securing an MCP server covers why HTTP-based transports need auth that stdio can skip.
Related clusters
Machine protocols
MQTT, Modbus, RDP, VNC and the other protocols your devices and legacy systems speak were mostly designed for trusted local networks, not the open internet — exposing one is a common way in for an attacker.
Security basics
TLS certificates, HTTP security headers and open ports are the fundamentals every internet-facing service should get right, independent of which protocol, operating system or cloud provider it runs on — most breaches start with one of these basics left unchecked.
Standards & references
Frequently asked questions
What stops an MCP server from giving an AI agent too much access?
Nothing in the protocol itself enforces it — the Model Context Protocol specification places consent, authorization and access-control decisions on the host application and the server implementation, not on MCP's wire format. A server that exposes a destructive tool without its own authentication or confirmation step will let any connected agent call it.
Is MCP the same thing as a REST API?
No — MCP is a JSON-RPC 2.0 based protocol, not a REST/HTTP-verb convention, built specifically so an LLM host can discover a server's tools, resources and prompts at runtime through a standard handshake, rather than needing a hand-written client built against each server's own API ahead of time.
How can I tell if my MCP server is accidentally reachable without authentication?
Connect to it the way an agent would: send an MCP initialize request and see whether it responds without any credentials, then check whether tools/list returns sensitive tools to that same unauthenticated connection. AdminKit's MCP endpoint check automates exactly that probe.