38 terms that come up in AI security and governance reviews, each with a definition, why it matters to a buyer, and where to read more.
The components and patterns that sit between your callers and the models they use.
A single service in front of many model providers that handles routing, provider credentials, retries and caching so applications call one endpoint instead of many.
Why it matters. It is where cost and reliability are controlled, and where traffic becomes measurable.
AI gateway vs AI firewallA layer that decides whether AI traffic may proceed, by inspecting prompts and responses, enforcing policy and recording the decision. It complements routing rather than replacing it.
Why it matters. Routing asks where a request should go. A firewall asks whether it should go at all.
What is an AI firewallThe part of an AI firewall that inspects traffic at the point of inference: the prompt before it reaches a model, and the response before it reaches the caller.
Why it matters. It is the difference between monitoring what happened and preventing it.
Product overviewPolicy that decides which model or backend serves a request, based on the caller, workload, cost, capability or data classification.
Why it matters. It turns cost and capability decisions into rules, instead of tribal knowledge.
Model routing guideThe list of models your organisation permits, each with its provider, backend URL, key and limits. Strict mode refuses models that are not on the list.
Why it matters. It converts unapproved usage from a silent success into an attributable event.
Model InventoryAn endpoint that accepts the OpenAI request and response shapes, so existing SDKs and tools work after a base URL change rather than a rewrite.
Why it matters. It decides how much work adoption costs the teams you are governing.
API referenceAI usage that happens outside approved channels: personal model keys, unregistered providers, or tools nobody assessed.
Why it matters. It is invisible until something goes wrong, and then it defines the blast radius.
Find and stop shadow AIWhat gets inspected, how decisions are made, and what happens when inspection cannot run.
An attempt to make a model follow attacker-supplied instructions instead of the application's, often hidden in retrieved documents or user content.
Why it matters. It is the most common way an AI feature becomes an attack path into your systems.
Block prompt injectionA prompt crafted to bypass a model's or a platform's safety instructions, usually by reframing the request or applying role-play pressure.
Why it matters. A single successful jailbreak can produce content you cannot send to a customer.
Guardrails guideA rule that inspects traffic and takes an action: block, mask, accept, or log. Guardrails can be built in, authored by you, or expressed as natural-language policy.
Why it matters. The action matters more than the detection: blocking is a control, logging is evidence.
Guardrails guideDetecting personal data in a prompt and replacing it before the request leaves your network, so the provider never sees the original value.
Why it matters. It keeps AI features usable without turning every prompt into a privacy event.
Mask PII before providersScoring the meaning of a request against a policy written in plain language, rather than matching keywords or patterns.
Why it matters. Attackers rephrase. Meaning-based policy is what survives paraphrasing.
Semantic intent analysisA design decision that refuses traffic when inspection cannot run, rather than forwarding it unscanned.
Why it matters. It is the difference between a security control and a monitoring tool.
Guardrails guideThe opposite policy: traffic continues when inspection is unavailable. Useful for availability-sensitive paths, dangerous as a default.
Why it matters. If it is your default, your control disappears exactly when it is needed.
Guardrails guideContent leaving your environment that should not, whether in a prompt, a retrieved document, or a model response.
Why it matters. Outbound inspection is where you catch what inbound inspection missed.
Guardrails guideA rolling score for a user, agent or address based on behaviour: rules that fired, denials, unusual models or volumes. High scores can be blocked automatically.
Why it matters. It turns many small signals into one decision you can explain and reverse.
Risk profilesA testing surface that runs a prompt against your enabled rule base without sending it upstream, showing which rules fire, semantic scores and the verdict.
Why it matters. Rule authoring stops being guesswork and stops risking production traffic.
Rules ManagerHow callers are identified, authorized, and limited.
Giving an autonomous agent its own credentials and lifecycle, rather than a shared API key copied from a person or a service.
Why it matters. Without it, you cannot answer who acted, or revoke one agent without disturbing others.
Agent identities with mTLSAuthentication where both sides present certificates, so the caller is identified by a credential it holds rather than a secret it sends.
Why it matters. It is the trust model you already use for servers, applied to software agents.
Agent self-enrollmentAn agent generating a key pair, presenting a certificate signing request, and receiving a certificate, with the private key never leaving the agent.
Why it matters. Onboarding scales without a human handling secrets.
Agent self-enrollmentA protocol for agent-to-agent task exchange, where agents publish an agent card, register with a registry, and exchange work under verified identities.
Why it matters. Otherwise agent-to-agent work is blind trust between two pieces of software.
A2A protocolA standard way for models and assistants to call external tools. A tool call changes state rather than just returning text.
Why it matters. Ungoverned tool calls are privileged actions nobody reviewed.
Govern MCP tool callsA callback that asks the governance layer for a verdict before inference happens, so policy applies to the assistant itself rather than only to the model API.
Why it matters. It governs developer tooling without asking engineers to change how they work.
Claude inference hooksPermissions granted through roles rather than per user, so the admin surface, model access and tool policy stay manageable as teams grow.
Why it matters. It is how you avoid a growing list of exceptions nobody can audit.
Identity and accessSingle sign-on through your identity provider, plus automated user provisioning and deprovisioning as people join and leave.
Why it matters. Joiners and leavers should work the same way they do for every other system.
Identity and accessHow spend is reduced and availability is protected without weakening inspection.
The unit models bill by. A rough working figure is that a token is around four characters of English text, and both the prompt and the completion are counted.
Why it matters. Every optimisation is ultimately measured in tokens, which is where the bill comes from.
Total cost of ownershipStoring responses so identical or near-identical prompts are served without another upstream call, with keys scoped so answers cannot leak between callers.
Why it matters. It is the largest safe saving available, provided blocked content never enters the cache.
Reliability and cachingMatching a new prompt against cached ones by meaning rather than exact text, so a rephrased question can still be served from cache.
Why it matters. Real traffic rarely repeats verbatim, so semantic matching is where the hit rate comes from.
Completion cacheReducing prompt size before forwarding, under a gate that confirms the meaning survived. If the gate cannot run, the original text is sent.
Why it matters. Savings that change the answer are not savings, they are incidents.
Cut token costs safelyA check that compares a rewritten prompt with the original and allows the rewrite only when meaning is preserved.
Why it matters. It is what makes compression safe rather than merely cheaper.
Prompt compressionRetrying or rerouting a request to another backend when a provider is unavailable or rate limited, expressed per model.
Why it matters. A provider having a bad afternoon should become a slower request, not an outage.
Reliability and cachingThe maximum number of tokens a model can consider in one request, covering instructions, history and retrieved content together.
Why it matters. It is the hard limit that forces a decision about what you send, and what you cache.
Models and endpointsWhat is recorded, where it lives, and how it is proved.
A record of each AI transaction: identity, model, decision, the rule that made it, timing and outcome. Content is not stored.
Why it matters. It answers the question an auditor asks, without creating a new body of sensitive data.
Audit logs and exportRetaining decisions and truncated previews rather than full prompts and responses.
Why it matters. A platform that keeps a copy of everything is a new breach surface, not a control.
Audit logs and exportForwarding AI audit records to your existing security monitoring, typically over encrypted syslog or a pull API.
Why it matters. AI traffic should land where everything else you monitor already lands.
Audit logs and exportControlling where data is processed and stored, including whether any part of a prompt leaves your environment for inspection.
Why it matters. A hosted inspection service adds a data path your assessment may not have counted.
Data residency for AI trafficA stated period and location for what is kept, applied to decisions and metadata rather than full content.
Why it matters. Retention is a business decision that should be configured, not implied by a vendor default.
Settings referenceThe free, self-hosted edition with a published token allowance: 100,000,000 tokens per month over a rolling 30-day window.
Why it matters. A published allowance makes evaluation possible without a procurement cycle.
Community Edition licenseThe product overview walks through every layer, from identity and inspection to routing, cost control and audit.