Runtime control for every layer of your AI agents
Prism checks everything your AI agents do, at every layer, and stops what your policies don't allow. Decisions happen outside the model, in under 30ms.
Protection at every layer of the agent
Most AI security only guards what goes in and what comes out. Prism checks every step in between.
Input: prompt injection and jailbreaks.
Memory: poisoned or unauthorized writes.
Reasoning: plans that drift or get hijacked.
Tools: tool calls and MCP requests outside policy.
Output: sensitive data, masked before it leaves.
Prism vs LLM guardrails
Guardrails sit around the model. Prism sits on the execution path, outside it.
Where it sits: guardrails sit around the model, at the input and output; Prism sits on the execution path, at every layer of the agent.
Who decides: guardrails use another model judging the model; Prism uses a rule-based policy engine, outside the LLM.
Default: guardrails allow unless something looks wrong; Prism denies unless a policy allows it.
How Prism decides
Three checks on every action, outside the LLM. The first one to say no stops it: context (where does this sit in the conversation?), content (is what is being passed actually safe?) and intent (why is this being attempted?).
Outcomes: allow, deny, redact or escalate.
Policies in plain language
Say what each agent is allowed to do. Everything else is denied by default.
MCP security
Prism wraps any MCP server and checks every call, without changing the agent. Each server gets only the access it needs.
Deploy on-prem or cloud (SDK, proxy or gateway)
Pick the route that fits how your agents are built: SDK (a few lines of code in your agent), proxy (for agents you can't change) or gateway (one setup covers every agent behind it). Runs on Docker or Kubernetes (Helm), works with LangChain and LangGraph, written in Rust, under 30ms at p95.
An audit trail for every action
Every decision is logged with the policy it matched and why. Export it as JSON or to Prometheus.
FAQ
What does Prism protect?
Every layer of an AI agent: the input it receives, the memory it reads and writes, its reasoning, the tools and MCP servers it calls, and the responses it sends. Each hand-off between layers is checked against your policies.
What is a prompt injection attack, and how does Prism stop it?
A prompt injection hides instructions in user input, a document, a tool response or another agent's message to make the agent do something it shouldn't. Prism checks the input, and then checks what the agent tries to do at every layer after it: what it writes to memory, which tools it calls and what it says. An injection that slips past one check is stopped at the next.
How is Prism different from LLM guardrails?
Prompt guardrails and model-based judges sit around the model. Prism sits on the execution path, outside the LLM, and allows, blocks or halts each action based on explicit policies.
Does Prism use an LLM to make decisions?
No. Prism looks at the content, context and intent of each action, and a rule-based policy engine makes the allow or block call, outside the LLM.
How do I deploy Prism?
On-prem or cloud, through an SDK, proxy or gateway. It runs on Docker or Kubernetes (Helm chart) and works with LangChain and LangGraph.
How can MCP servers be secured?
Give each server only the access it needs (a calendar server should not write files), and check every call at runtime so a trusted server can't be turned against you.
What is MCP security?
MCP attacks target the trust between an agent and the tools it calls. Prism wraps any MCP server and enforces policy on every tool call and resource read, without changing the agent.