Zero Trust for AI agents means treating every agent as an identity that must prove itself on every request, giving it the least access that lets it do its job, and designing the whole system on the assumption that one agent will eventually be compromised. Anthropic's guide, "Zero Trust for AI Agents," turns that idea into a tiered framework (Foundation, Enterprise and Advanced) with nine control families, an eight phase implementation workflow and a section on defensive operations. It is the most practical public blueprint we have seen for putting autonomous agents into a company without handing them the keys.
This post explains the framework in our own words, then maps the framework against a security platform, ours, and says plainly which parts a platform like Safeguard covers, which parts it covers partly, and which parts are deliberately left to the infrastructure you already own: hardware roots of trust, certificate authorities, sandboxes and hypervisors. If you are a CISO, read the first half and the coverage map. If you are an architect or a platform engineer, the walk through the control families and the worked example are for you.
A note on attribution. The framework is Anthropic's work, published as a guide for people deploying agents in the enterprise. We summarize and build on it here, we do not reproduce it, and we recommend reading the original in full. Anything we say about what Safeguard does comes from our own product documentation, and we have tried to label maturity honestly rather than round it up.
Key takeaways
- The framework rests on three ideas: never trust and always verify, assume breach, and least privilege, extended for agents into "least agency," which limits what each tool can do, how often and where.
- Its sharpest design test asks whether a control makes an attack impossible or merely tedious. Friction such as rate limits and SMS codes degrades against attackers with unlimited patience and near-zero cost per attempt.
- Controls come in three tiers: Foundation (the raised floor), Enterprise (where most organizations should aim) and Advanced (high-risk or tightly regulated environments).
- Static API keys and shared service-account passwords count as already compromised. Short-lived, narrowly scoped tokens from an identity provider are the baseline.
- Roughly half the framework is security tooling: finding flaws, guarding runtime input and output, inventorying agents, detecting and responding, proving compliance. The other half is infrastructure: hardware-bound credentials, certificate authorities, sandboxes, just-in-time privilege and immutable platforms.
- Safeguard is built for the tooling half. It is strongest on supply chain, application testing and governance, solid on agent inventory and runtime guardrails, and still building depth in behavioral detection and automated response. The infrastructure half stays yours by design.
What the guide is, and how it is organized
Anthropic opens with a premise that is easy to nod along to and harder to absorb: perimeter defenses cannot keep up with a threat environment in which frontier models compress the time between a vulnerability and a working exploit from months to hours, at a cost measured in dollars. That matters twice for anyone deploying agents. The infrastructure the agents run on is exposed to AI-accelerated offense like the rest of your estate, and the agents themselves interpret goals, choose tools and run multi-step operations without a human approving each step.
The document has five parts: the characteristics and vocabulary of agentic systems (I), the current threats (II), Zero Trust applied to agent services in three capability tiers (III), an eight phase implementation workflow (IV) and defensive operations (V). Part III is the heart of it. Foundation is minimum viable security for small or first deployments. Enterprise adds the depth for larger teams and multiple agent deployments. Advanced is aspirational for most organizations and baseline for high-risk or stringent regulatory settings. Each tier strengthens the one before. The guide also notes that its controls depend on supporting infrastructure around the deployment, and that tooling and adoption are still maturing. That sentence is the reason this post exists, because it is exactly where a security platform and your infrastructure meet.
The three principles, and the test that matters most
The guide traces Zero Trust through NIST SP 800-207 (2020) and national implementation guidance. In one line, it is what Anthropic summarizes as "trust nothing, verify everything, assume breach has already occurred." Three principles carry the load.
Never trust and always verify. Every request is authenticated and authorized wherever it comes from. A call from inside the network gets the same scrutiny as one from outside.
Assume breach. Design as if compromise will happen, and limit what an intruder can do once in. Segment by identity, use fine-grained access control, and make sure one compromised system does not grant another.
Least privilege. Give an identity only what a task needs. For agents the guide adopts OWASP's term, least agency, which restricts what each agent tool can do, how often and where. A database tool gets read-only queries. An email summarizer gets no send or delete rights.
Then comes the idea that shapes every tier recommendation: the impossible-versus-tedious test. For any control, ask whether it makes the attack impossible or only makes it tedious. Extra network hops, rate limits, odd ports and SMS codes all work by friction, and friction fails against an adversary that grinds through tedious steps at scale. The controls that survive share a pattern: hardware-bound credentials, expiring tokens, cryptographic identity, and network paths that do not exist rather than paths that are merely inconvenient. When in doubt, prefer a control that removes a capability over one that throttles it.
Why agents change the security model
Part I names five properties that set agents apart: they act without a human at each step, they use tools (increasingly through the Model Context Protocol, MCP), they interpret instructions and so can be steered by ambiguous ones, they keep context across sessions, and they coordinate with other agents. Each maps to a failure class. The guide also introduces blast radius, the damage if something goes wrong. An agent with read-only access to one database has a small one. An agent with administrative access to cloud infrastructure has an enormous one. Assume every agent's blast radius will be tested, and spend effort in proportion to it.
The threats the framework is built against
Part II is a threat catalog drawn largely from OWASP's agentic threat work. Every control in Part III answers one of these.
Prompt injection. Direct injection overrides instructions through user input, using explicit overrides, encodings or adversarial suffixes. Indirect injection is worse: instructions planted in web pages, emails or documents the agent reads. The user never sees the payload, and the guide cites Microsoft Research for the point that models cannot reliably tell information from instruction.
Tool and resource misuse. An agent can be steered into misusing tools while staying inside its permissions. Tool poisoning corrupts tool descriptors or metadata, a rug pull swaps a trusted tool for a malicious one, and tool chaining combines individually safe tools into a harmful sequence. Every step runs through trusted binaries under valid credentials, so host-centric monitoring sees no malware. Loop amplification adds denial of service and billing spikes.
Identity and privilege abuse. Agents often run with elevated service accounts. Unscoped privilege inheritance hands a manager agent's full access to a worker, the confused deputy problem lets a low-privilege agent relay instructions to a high-privilege one, and cached credentials let an attacker act across session boundaries.
Supply chain. Agent ecosystems compose tools and personas at runtime. The guide cites Anthropic research showing that 250 malicious documents can backdoor models from 600 million to 13 billion parameters, a dependency confusion attack against a machine learning framework that exfiltrated data at install time, and reports of roughly 100 malicious models on public platforms.
Memory and context poisoning. Corrupted memory biases future reasoning, poisoned retrieval stores feed bad context to every query, shared context leaks between tenants, and slow drift, where no single change looks malicious, is the hardest to see.
The nine control families, and where Safeguard fits in each
For each family in Part III: what the guide asks for, what stays in your infrastructure, and what Safeguard does. Anything that is a property of hardware, a network, a hypervisor or a token service is yours. Anything that is a property of software, its dependencies, its policies, its evidence or its behavior is where a platform earns its keep.
1. Agent identity and authentication
What the guide asks for. Foundation: persistent, unique agent identifiers backed by cryptographic material rather than labels, tracked from creation to retirement, appearing in every log and access request. Enterprise: X.509 certificates per agent with full lifecycle management, plus mutual TLS with certificate pinning. Advanced: credentials held in hardware security modules or trusted platform modules, remote attestation before access is granted, and confidential computing for sensitive operations.
What is yours. The cryptographic root. Certificate issuance, hardware modules, attestation and enclaves are infrastructure primitives, and they come from your cloud, your identity provider or your own PKI. A security platform that tried to be your certificate authority would be solving a different problem and adding a new thing to trust.
What Safeguard covers. The inventory and the accountability around the identity. Two documented pieces make this concrete, so you can say which agent exists, what it is allowed to do and what it holds access to. AI agent discovery, in the Safeguard CLI and Desktop app, detects the supported AI coding agents on a computer along with what each is allowed to do, the skills, plugins, MCP servers and models it uses, and what it did. It reads the agents' own configuration and activity files, and each report states per agent whether sessions were read, unsupported or absent, so a gap is never shown as "nothing happened." Guard keeps an inventory of MCP servers and agents in your environment, with block, unblock and quarantine actions per agent and policies that can target one agent instead of all of them.
That is attribution, which is the precondition the guide names. It is not the cryptographic proof. If you issue each agent a certificate from your own CA, Safeguard's records are where that agent's identifier meets its policy, its audit trail and its owner.
2. Service authentication
What the guide asks for. Foundation: short-lived tokens from an identity provider, OAuth 2.0 or similar, with expiry measured in minutes and automatic refresh, and no credentials in code or configuration. Enterprise: mutual TLS with pinning. Advanced: hardware-bound credentials with attested issuance, rooted in attested hardware even for service-to-service calls inside production.
What is yours. The token service, the certificate authority and its revocation machinery (certificate revocation lists or OCSP), pinning in your clients, and the hardware. The guide itself recommends that organizations without PKI expertise use cloud-native managed identity services and established secret management platforms, naming HashiCorp Vault as one example, instead of running a certificate authority. We agree, and nothing in our platform argues otherwise.
What Safeguard covers. Two things. The first is keeping Safeguard's own credentials short and scoped. Safeguard's Credentials Vault holds scan credentials, such as the logins a DAST scan needs for a staging site, in an encrypted vault, or lets you point at a record in your own privileged access system so the value is read inside your network at scan time and never stored in Safeguard. Scans refer to an entry by a handle (for example sgvault://dast-staging), a runner can test access without ever showing the value, and the CLI has matching commands. This is a deliberate fit with the guide's direction: the secret stays where your identity infrastructure keeps it. To be precise about scope, this vault is about the credentials that Safeguard's own scans need. It is not a broker that issues runtime tokens to your agents, and we do not present it as one.
3. Access control and privilege management
What the guide asks for. Foundation: role-based access with deny by default, roles matched to agent functions, static least-privilege roles per agent function that are reviewed and certified periodically. Enterprise: attribute-based access control that weighs time, location, data sensitivity and risk score, plus dynamic privilege that rises for a task and returns to baseline afterward. Advanced: continuous authorization evaluated at every action, and just-in-time, just-enough administration with automatic expiry.
What is yours. The authorization engine in front of your databases, APIs and cloud accounts, and above all the just-in-time machinery that mints a scoped permission for a duration and revokes it. Doing this well is an identity-platform problem. The guide itself calls just-in-time access very powerful and not easily implemented, and recommends doing it even partially. We treat full automatic expiry of privilege as an infrastructure primitive, and we do not claim to provide it.
What Safeguard covers. Least agency at the tool boundary, which is the layer the guide cares most about for agents. Guard policies decide, for each MCP tool call that flows through the Guard SDK or a Guard proxy, whether it is allowed, monitored, redacted, rate limited, held for approval or blocked. A rule can target a specific server or agent. So you can write the guide's examples directly: an agent that summarizes mail gets calls that read and list, and the call that sends is held for approval or refused; a database tool is allowed queries and a schema change is blocked. Because the proxy deployment sits in front of MCP servers whose code you do not control, you can enforce this on third-party and vendor-hosted servers too, from one place, and requests the policy blocks never reach the upstream server.
4. Resource boundaries and isolation
What the guide asks for. Foundation: identity-based isolation, where every agent workload has its own cryptographic identity and each service accepts connections only from named callers, with network segmentation as a backstop. Enterprise: sandboxed execution in containers with restricted capabilities, using runtimes such as gVisor that add syscall filtering, and the guide calls this table stakes for any agent that handles untrusted input. Advanced: hardware isolation with confidential computing (AMD SEV or Intel TDX), microVMs and attestation of the execution environment.
What is yours. All of it, and this is the clearest boundary in the whole framework. A sandbox is a property of the machine, the kernel or the hypervisor that runs the agent. Syscall filtering, microVMs, confidential computing and network segmentation are things your cloud, your Kubernetes platform or your agent runtime provide. The guide's own pro-tips point to agent runtimes that ship sandboxing natively. A platform that sits above the workload cannot honestly claim to isolate it.
What Safeguard covers, by design, is verification around the sandbox. Three things. First, it inventories what runs inside: the AI-BOM catalogs models, ML dependencies, notebooks, prompts, vector stores, agents, MCP servers and inference endpoints across your code, your cloud connectors and connected SaaS, so you know what your isolation boundaries actually contain. Second, it scans the container images and dependencies you put into the sandbox, so a "restricted" container is not built on a vulnerable base. Third, its governance suite can collect evidence from connected cloud and identity systems that those boundaries exist, which turns "we sandbox our agents" from a sentence in a policy into something an auditor can follow to a source.
5. Observability and auditing
What the guide asks for. Foundation: comprehensive logs of tool invocations, data access and external communications, with agent identity and context, retained as regulation requires. Enterprise: immutable, append-only audit trails with cryptographic verification of integrity and replication. Advanced: real-time streaming to a SIEM with correlation and alerting. For traceability, the guide asks for request IDs that link agent actions to the trigger (Foundation), distributed tracing across multi-agent workflows with OpenTelemetry or similar (Enterprise), and full provenance chains with intermediate reasoning steps and replay (Advanced).
What is yours. Append-only storage, log replication and cryptographic log verification are storage-layer properties. The agent runtime and framework are where the reasoning steps and tool outputs are produced, so they are the source for full provenance and replay.
What Safeguard covers. The audit trail of the control plane that sits on top. Every request Guard evaluates is written to an append-only audit trail with the agent, the server, the tool, the decision and the matching rule, the scores behind the decision, any PII that was detected or fields that were redacted, latency and outcome. The trail keeps the current period plus a retention window, 90 days by default on a self-hosted proxy deployment, and rolls events up into hourly and daily aggregates for trend reporting. For agent activity on developer machines, AI agent discovery reads session records for supported coding agents, and Claude Code and Codex activity can also arrive through their OpenTelemetry export. Every guardrail decision in the supply chain policy layer is logged to the audit stream and emitted as an OpenTelemetry span for SIEM ingestion.
6. Behavioral monitoring and automated response
What the guide asks for. Baselines first. Foundation: manually defined expected behavior. Enterprise: automated learning of normal tool usage, access frequencies and data volumes. Advanced: continuous refinement with drift detection, so slow poisoning shows up. Anomaly detection climbs from threshold alerts with an automated first-pass triage (Foundation), to statistical detection with tunable sensitivity (Enterprise), to machine learning models with contextual awareness (Advanced). Response climbs from alerts to security staff with model-drafted triage context, to automatic containment such as terminating sessions and revoking credentials, to orchestrated SOAR playbooks with graduated escalation.
The guide has a rule here that every team building automated response should adopt: automate the bookkeeping around incidents, not the decisions. Let models take notes, collect artifacts, run parallel investigation tracks and draft the postmortem. Let humans make containment calls, disclosure calls and customer communication calls.
What is yours. Session termination and credential revocation at machine speed are carried out through your identity provider and your platform. A response product can ask for them, but the revocation lives in your token service.
What Safeguard covers, and where we are still building. This is the family where we are most careful with maturity. What exists today: Guard attaches a risk score, a jailbreak score and an anomaly score to each request it evaluates and records them, so an agent whose calls suddenly score differently leaves a trail you can query. Threshold-style rules and per-agent policy let you turn that into a hold for approval or a block. SecOps raises deduplicated alerts, and the runtime protection engine evaluates the runtime events supplied to it against ATT&CK-mapped rule packs for things such as a shell spawned in a container, a reverse shell, a container escape attempt or privilege escalation. Those rules raise alerts and findings. They do not block or terminate workloads, and the engine reads events you provide rather than shipping its own collector.
We are building toward, and do not claim as finished, learned per-agent baselines with drift detection, graduated orchestrated playbooks and an ATT&CK coverage view. If you need the Advanced behavioral tier today, pair a dedicated detection stack with Safeguard's inventory, guardrails and audit data.
7. Input validation and output controls
What the guide asks for. Input sanitization: schema and length checks at Foundation, pattern matching for known injection techniques and encoded payloads at Enterprise, and layered validation at Advanced that adds AI-based classifiers trained on adversarial examples and "spotlighting," a technique that clearly delimits untrusted content so the model treats it as less trustworthy. The guide notes that input sanitization does not carry over cleanly from databases to agents, because agent input is free-form. Output filtering: scanning for PII and sensitive business data with block or redact (Foundation), semantic analysis of outputs before delivery (Enterprise), and human-in-the-loop approval for high-risk actions (Advanced).
What is yours. Prompt construction, such as spotlighting, lives in your application and in the model provider's training and classifiers. The guide points to Anthropic's constitutional classifiers research, and spotlighting research from Microsoft that reported cutting indirect injection success from over 50 percent to under 2 percent in its tests. Those are properties of how you build the prompt and which model you run.
What Safeguard covers. The runtime guardrail layer, in two forms. For MCP tool traffic, Guard applies policy to each call and its response, with actions to allow, monitor, redact, rate limit, require approval or block, and the audit record notes detected PII and redacted fields. For AI coding agents on a computer, the AI Gateway decision engine in the Safeguard CLI checks prompts, responses and tool calls for direct and indirect prompt injection, jailbreak patterns, system prompt leakage, excessive agency and personal data leaving the machine. Agent protection hooks (documented for Claude Code and Cursor, with a generic hook protocol) run it on each event. It starts in monitor mode, and in enforce mode critical findings are blocked and high ones put to the person in the agent's own interface. It fails open if a hook cannot finish in time unless your policy chooses fail-closed.
Two scope notes. The AI Gateway engine is a library inside the CLI that serves the coding-agent hooks, not an inline proxy in the path of your applications' own model traffic. And Guard decides on calls at request time, so inspecting a tool's own description for hidden instructions (the tool poisoning case) happens earlier, by vetting and pinning the servers you allow, as in the supply chain section.
8. Integrity and recovery
What the guide asks for. Configuration integrity: configurations in version control with review (Foundation), signed configurations verified before deployment (Enterprise), and immutable infrastructure deployed as attested images that are replaced rather than modified (Advanced). Recovery: documented, periodically tested rollback (Foundation), automated rollback on failed health checks (Enterprise), and self-healing systems with circuit breakers and automatic replacement (Advanced). The guide makes a point that is easy to skim past: enable automatic updates wherever an automated update causing an outage is acceptable, because delay is now the main risk, and treat "auto-update on" and "verify signatures before deployment" as complementary.
What is yours. Immutable images, attested deployment, health-check rollback and self-healing orchestration are properties of your delivery platform. We do not offer to replace your orchestrator or your image pipeline, and we would not trust a security tool that did.
What Safeguard covers. The supply chain side of the same idea. Attestation and signing give artifacts signed provenance you can verify later, and policy gates can require it. For agent configuration, AI agent discovery reads the permission and tool settings of supported coding agents, so a drift in an agent's allowed actions is something you can see and compare. We rate configuration integrity as partial: version control, review and signing of your own agent configurations stay in your pipeline, and Safeguard's role is the inventory, the policy gate and the evidence.
9. AI governance policies
What the guide asks for. Documented acceptable use and incident response that covers agent compromise, including shadow AI where staff use language models without IT approval (Foundation). A cross-functional governance committee with an approval process for new agent deployments (Enterprise). Policy checks inside deployment pipelines with automated violation detection and compliance metrics (Advanced).
What is yours. The committee, the decisions and the accountability. No tool owns those.
What Safeguard covers. This is home ground. Safeguard's governance and compliance suite holds a large framework library with controls, policy templates and automated tests that map evidence from the systems you connect. For the regimes that matter to most commercial buyers, that includes SOC 2, GDPR, HIPAA and the EU AI Act, and the platform's own posture is SOC 2 Type I and Type II audited, with reports available on request through the Trust Center. Shadow AI shows up in AI-BOM discovery, which surfaces connected but unsanctioned AI tools for governance review. The Advanced tier's "policy checks in the pipeline" is what Safeguard's policies and gates do for software: they evaluate the platform's scans of your connected repositories and can block, warn or notify, with time-boxed exceptions that appear in the audit log and expire.
The coverage map
Here is the whole picture on one page. "Strong" means core to the product and mature. "Solid" means shipped and documented, with the scope limits stated above. "Partial" means some of the control is there and some of it is still being built. "Yours" means an infrastructure primitive that stays with your cloud or platform by design.
| Framework area | Safeguard coverage | Where it lives |
|---|---|---|
| Supply chain: SCA, SBOM, reachability, model and dependency risk | Strong | Safeguard |
| Install-time package protection | Strong | Package Firewall |
| AI-BOM and model artifact checks | Strong | AI-BOM and AI-SPM |
| Governance and compliance evidence | Strong | GRC suite |
| Finding flaws before ship: SAST, DAST | Strong | Application testing |
| Agent inventory and attribution | Solid | Agent discovery and Guard |
| Runtime input and output guardrails | Solid | Guard and AI Gateway |
| Scan credential protection | Solid | Credentials Vault |
| Audit trail of agent tool calls | Solid | Guard audit trail |
| Behavioral baselines and drift | Partial | SecOps and Guard scores |
| Detection and automated response | Partial | SecOps |
| ATT&CK coverage mapping, agentic SOAR | Partial | Being built |
| Configuration integrity and rollback | Partial | Attestation, discovery |
| Hardware-bound credentials, attestation | Yours | HSM, TPM, cloud |
| Certificate authority, mTLS, pinning | Yours | Your PKI |
| Sandboxes, microVMs, syscall filters | Yours | Your runtime |
| Just-in-time, auto-expiring privilege | Yours | Your identity platform |
| Immutable and self-healing infrastructure | Yours | Your platform |
Read the last five rows as a design choice. These controls pass the impossible-versus-tedious test because they are enforced by hardware and by network paths that do not exist. They can only be enforced at the layer that owns the hardware and the network. A tool that runs above that layer can verify that they are in place and enforce policy around them, but if it claimed to provide them it would be asking you to trust a promise where the guide asks for a proof.
The supply chain half, in detail
The guide gives supply chain its own phase, and this is where a platform contributes the most. Its recommendations, and how each works in practice:
Know what is in your agent stack. Inventory the framework, MCP servers, SDKs and container images. Safeguard builds an SBOM from source, lockfiles and images in SPDX and CycloneDX, and extends the idea to AI assets with the AI-BOM, following the machine learning bill of materials model the guide points to. Inventory is the join key for every other control here.
Evaluate dependency health and trim the tree. Most open source has no service-level agreement. The guide recommends the OpenSSF Scorecard, which scores signals such as branch protection, fuzzing, signed releases and maintainer activity in CI, and suggests pointing a frontier model at the lockfile to find overlapping libraries. A complete transitive SBOM makes both exercises better.
Narrow remediation with reachability. Safeguard's prioritization combines static reachability (a call graph from your source, lockfile and bytecode), exploit probability, known-exploited status and asset context into one ranked backlog. It is static only, and how much noise it removes depends on your codebase, so measure it in an evaluation.
Block hostile packages at install. Safeguard's Package Firewall is an install-time proxy in front of npm and pip. Every fetch passes through it, transitive dependencies included, and it can allow, warn on or block typosquatted packages, dependency confusion attempts and known-malicious packages, with an audit mode to measure impact first and a quarantine mode for review.
Check models before they load. AI-SPM inspects model artifacts such as pickle, PyTorch, safetensors, GGUF and ONNX files for hidden code and unsafe deserialization.
Vet and pin the tools agents reach. The guide's tip for MCP is to run the server yourself on an immutable platform after verifying the code, sign it, and repeat that on updates. Safeguard helps with verification: scan the server's dependencies, record it in the AI-BOM, and front it with a Guard proxy so even a server you cannot rebuild is held to your policy at the call.
Ask vendors the hard question. The guide suggests third-party review ask suppliers how they are preparing for accelerated exploit timelines. Safeguard's third-party risk module supports requesting SBOMs and tracking vendor posture, and we welcome the same question.
A defender's journey: one agent, eight phases
Part IV is valuable because it is a sequence. Here it is applied to an ordinary example, a customer-support agent that reads tickets, looks up an order and drafts a reply.
Phase 1, identify requirements. Get security, legal, compliance and the product owner to agree first. The data is customer personal data, so GDPR applies, and HIPAA too if health details can appear in tickets. In Safeguard, pick those frameworks in the GRC suite so controls, evidence tests and gaps are visible from day one.
Phase 2, manage supply chain risk. Generate the SBOM for the agent service, register the model and MCP servers in the AI-BOM, scan the images, and route build installs through the Package Firewall. Verify any open source MCP server before you run it. When a scan reports a vulnerable dependency, remediation opens a policy-gated pull request, your own CI runs your tests on it, and auto-merge stays off unless you turn it on.
Phase 3, define agent boundaries. Write down approved actions, prohibited actions, escalation triggers and scope. This agent may read a ticket, read one order by ID and draft a reply. It may not send, refund or read other customers' records. Any draft that mentions a refund escalates. Then work out the blast radius honestly. Each agent gets its own ID and credentials, because sharing one credential across several agents means you have not compartmentalized anything. Register the agent in Guard's inventory under its own record so everything after is attributable.
Phase 4, defend against prompt injection. A ticket body is untrusted input and may carry instructions aimed at the agent. In your application, delimit untrusted content and keep the instruction channel separate. At the boundary, put a Guard proxy in front of the order-lookup MCP server, and for developers using coding agents install the agent protection hooks, starting in monitor mode and moving to enforce once you have seen the false positive rate. Limit who and what can reach the agent at all.
Phase 5, secure tool access. Allow-list tools per function and deny the rest. Authenticate tools with short-lived tokens bound to the agent, never static keys. Then write the Guard policy that expresses least agency: the order tool may read by order ID, an unbounded query is rate limited, any write is blocked, any response containing another customer's record is redacted or held. Rate limits are friction, so treat them as a safety net. High-risk calls pause for approval, and the decision is logged.
Phase 6, protect agent credentials. Unique, short-lived credentials injected at runtime from your secret management system, bound to hardware in production if your platform allows. This phase is almost entirely your infrastructure. Safeguard's part is keeping its own scans free of long-lived secrets through Credentials Vault references.
Phase 7, safeguard agent memory. Isolate sessions and users, validate stored context at retrieval, tag memory with its source and expire unverified context quickly. These are framework and storage properties, and they are yours. Safeguard records the vector stores and retrieval sources in the AI-BOM, so "where can poisoned context come from" has an answer, and Guard's redaction keeps personal data out of long-lived stores and logs.
Phase 8, measure what matters. The guide asks for detection speed (an hour for critical systems), explainability and behavioral conformance, and offers two quarterly questions: would we know within an hour if an agent went rogue, and can the team take a week off without worrying? The audit data and alerts help with the first. For the second, see the honest maturity note above.
At the end of one pass you have a one-page record per agent: identity, supply chain bill, boundaries, tool policy, credential source, memory rules and metrics. That page is what you copy for the second agent.
Defensive operations at the speed of autonomous threats
Part V turns the lens around: the other half of the work is running operations fast enough to face attackers who are AI-accelerated too. The advice is concrete. Move humans off bookkeeping (evidence, enrichment, write-ups) and onto decisions (containment, disclosure, customer communication). Put a model at the front of the alert queue for a read-only first-pass investigation, starting with one noisy rule and measuring agreement against a human for two weeks. Map detection to MITRE ATT&CK, prioritizing lateral movement and credential access. Apply Zero Trust to defensive agents too, with hardened environments and least privilege.
Safeguard's SecOps supplies the normalized event stream, Sigma and indicator detection and deduplicated alerts that the triage pattern needs, and its MCP server lets the assistant you choose query risk and pull SBOMs through tenant-scoped tools. The platform can also run with no language model at all, or with the model you bring, which speaks to the guide's point about not blindly trusting defensive automation. The orchestrated response layer and the ATT&CK coverage view are still being built, and we would rather say so than imply the tier is finished.
Why the boundaries are deliberate
It would have been easy to write a feature list that ticked every box in the guide. We did not, for three reasons.
The impossible-versus-tedious test favors the layer that owns the hardware. A credential bound to a hardware module cannot be exported from a compromised host, and that guarantee comes from the module and whoever operates it. If a security platform held those credentials for you, the guarantee would shrink to a policy promise, the opposite of what the framework is after.
Trust should not concentrate. Your certificate authority, hypervisor and secret store each constrain the others. A platform that absorbed all of them would be the single point of failure the architecture is meant to avoid. We would rather verify beside your infrastructure than be one more thing trusted entirely.
You already have these. Cloud providers and platform teams have invested heavily in managed identity, key management, sandbox runtimes and confidential computing, and the guide steers organizations to those managed services. The work left for a security platform is what nobody else is placed to do: knowing what is in the software, checking it before it ships, guarding runtime calls, keeping the inventory and proving it to an auditor.
That gives you a division of labor to write into a plan:
| Question | Who answers it |
|---|---|
| Is this component, model or tool safe to load? | Safeguard |
| Is this agent known and allowed to call that tool? | Safeguard, with your identity provider |
| Is this call or response acceptable right now? | Safeguard Guard, with your application |
| Can a stolen credential leave the host? | Your hardware and cloud |
| Can a compromised agent reach beyond its box? | Your sandbox and network |
| Can an agent hold privilege longer than the task? | Your identity platform |
| Can I show an auditor all of this is true? | Safeguard governance, with evidence from your systems |
Common mistakes
- Reading the tiers as a purchase list. They are a maturity path. Advanced controls on a system with no inventory and shared credentials are theater.
- Counting friction as a control. Rate limits, rotated static keys and obscure ports are speed bumps under the framework's own test.
- Splitting an agent into several that share one credential. You get multi-agent complexity without compartmentalization.
- Putting a human on every step. Approval fatigue turns the reviewer into a rubber stamp. Hold the high-risk actions and let the rest run under policy.
- Trusting the tool list. A tool's description is input. Vet and pin MCP servers, and watch for changes.
- Guarding only the input. Output controls limit data loss even when injection succeeds.
- Letting shadow AI sit outside the program. Every unapproved tool bypasses every control above. Discover first, then govern.
FAQ
What is Zero Trust for AI agents?
It is the application of Zero Trust, which means never trust, always verify and assume breach, to autonomous agents that choose tools and take multi-step actions. Each agent gets a distinct verifiable identity, the minimum access for its task, controls on every tool call, and monitoring that assumes some agent will eventually be manipulated.
Who wrote the framework, and where can I read it?
Anthropic published it as "Zero Trust for AI Agents," a security framework for deploying autonomous AI agents in the enterprise. This post summarizes it and adds our own mapping, and the original is the authoritative text. Anthropic offers it as a framework for your own evaluation, not as assurance for any particular environment.
Which tier should we aim for?
The guide says most organizations with significant deployments should target Enterprise. Foundation suits small teams and first deployments, and Advanced is the baseline for high-risk or tightly regulated settings. Because each tier builds on the last, start at Foundation for every agent and move up where your threat model demands it.
Does Safeguard replace our identity provider, certificate authority or sandbox?
No, and it is not meant to. Those are infrastructure primitives that belong to your cloud and platform. Safeguard covers the tooling around them: finding flaws before ship, guarding runtime tool calls, inventorying agents and their access, detecting and alerting, and producing compliance evidence.
Can Safeguard stop prompt injection?
It reduces the exposure rather than eliminating it, which is also what the guide says of every layer. Guard applies policy to MCP tool calls and responses, and the AI Gateway engine checks prompts and tool output for injection and jailbreak patterns for supported coding agents, in monitor or enforce mode. Combine that with input isolation in your application, minimal tool permissions and approval for high-risk actions.
Is Safeguard's behavioral detection finished?
Not at the Advanced tier of the guide. Guard records risk, jailbreak and anomaly scores per request, and SecOps provides event ingestion, rule-based detection and deduplicated alerts. Learned per-agent baselines with drift detection, orchestrated response and an ATT&CK coverage map are areas we are still building, so plan to pair them with a dedicated detection stack for now.
How does this relate to SOC 2, GDPR, HIPAA and the EU AI Act?
The framework's governance and audit controls produce much of the evidence those regimes ask for: documented acceptable use, access control, logging and traceability, incident procedures. Safeguard's governance suite maps controls and evidence to these frameworks, and the platform itself is SOC 2 Type I and Type II audited, with reports on request.
What should we do first this week?
Make an inventory: which agents run on developer machines and in your cloud, which MCP servers and models they use, and which credentials they hold. Scoping and audit both depend on it.
Fix it without waiting for upstream
Whatever the vulnerability, most of the risk sits in two gaps. The first is the time between a fix being published and that fix actually running in your production builds. The second, and worse, is the time before any fix exists at all, while a maintainer works out a patch and a release schedule. Waiting through both gaps is a habit, not a requirement. Safeguard gives teams three ways to close them.
1. Autonomous remediation: pull requests, not tickets
When a fixed version exists, Griffin, Safeguard's security model, opens a policy gated pull request that moves the affected dependency to the safe version, and your own CI runs your tests on it before anyone merges. You can run it on one repository or in bulk across every project that carries the vulnerable version. Remediation categories include dependencies, licenses, security posture and findings, and each one is set separately. Reachability analysis ranks the vulnerable code paths your application actually calls first, so the first pull requests you merge are the ones that matter most. Auto-merge is a separate switch and stays off by default, so your team decides what merges on its own and what still needs a human approval.
2. Gold Open Source: the safe version in seconds, free
gold.safeguard.sh is free and needs no login. Search any CVE or package to see affected and fixed versions, CVSS, EPSS, CISA KEV status and a recommended safe version, or use the "Am I affected?" checker. The same data is available through a free read API, README status badges and RSS threat feeds.
3. Gold Registry: start from components that are already fixed
Safeguard Gold rebuilds patched versions of open-source packages and images from source, signs each build, attaches an SBOM, SLSA provenance and VEX, and serves them from registry.safeguard.sh to your organization. Every Gold artifact is held continuously to zero exploitable critical or high CVEs and a completed license check, with signed build provenance (signed with Safeguard's key and verifiable with cosign, SLSA Build Level 3 as the design target) and a public evidence page you can hand to an auditor. An artifact loses its Gold badge if it regresses. Teams can point their own package directory at the registry so hardened equivalents resolve without changing how developers install anything.
When upstream has no fix yet, or will not ship one, Safeguard first works to get the fix accepted upstream. If the issue is severe or upstream will not move, Safeguard builds a fork, fixes the vulnerability there and publishes a hardened Gold build, so you are not stuck on a maintainer's release schedule. You can also request a hardened build of a specific package. Ask which packages it covers before you plan around it.
| Your situation | What to use |
|---|---|
| A fixed version exists | Autonomous remediation opens the upgrade pull request; Gold Open Source confirms the safe version |
| You need to know today whether you are affected | Gold Open Source lookup and "Am I affected?" checker, free and without login |
| You want vulnerable versions to stop shipping | Safeguard policies and gates in CI |
| Upstream has no fix yet, or will not ship one | A custom Gold request; fork and patch |
| You want to start clean on new projects | Pull hardened components and images from Gold Registry |
One honest limit: when the vulnerable code lives in a vendor appliance, a hosted service or an operating system runtime you do not build yourself, the fix still has to come from that vendor or distribution. The steps above apply to the open source dependencies and container images you build and ship, which is where most teams carry the largest and least tracked share of their exposure.
See how Safeguard would help
This first demo connects Claude to the Safeguard MCP server with OAuth and lets you choose which tools Claude may use. It is a small, concrete picture of least agency: the assistant gets the tools you allow and nothing more, and the same idea scales up to the Guard policies described above.
Click through it at your own pace, or open it full screen.
This demo is a real Safeguard CLI session: install, ask for a fix, approve each step, scan. For an agent service, the same flow applies to the framework, SDKs and parsers it depends on, the supply chain phase of the guide.
Click through it at your own pace, or open it full screen.
The Safeguard desktop app is where AI agent discovery shows what coding agents are present on a computer and what they may do. That inventory is the first step of every phase in this post, because you cannot scope, audit or govern what you have not found.
Quick check
A team rotates its agents' API keys every 30 days and calls that Foundation tier. Does it meet the guide's bar?
No. The guide treats static keys on a rotation schedule as a known gap. Rotating a credential that can be read from a lockfile does not meaningfully raise the cost for an AI-assisted attacker. The Foundation baseline is short-lived, narrowly scoped tokens issued by an identity provider.
Which parts of the framework should a security platform claim to provide: hardware-bound credentials, tool call policy, or sandboxes?
Tool call policy. Hardware-bound credentials and sandboxes are properties of hardware, hypervisors and runtimes that your cloud or platform provides. A security platform verifies and enforces policy around them, and provides the tooling half: inventory, guardrails, detection and evidence.
Sources
- Anthropic: "Zero Trust for AI Agents: A security framework for deploying autonomous AI agents in the enterprise" (guide, 2026). The framework this post summarizes; read the original for the full tier tables and workflow. Product context: Claude Code
- NIST SP 800-207: Zero Trust Architecture
- OWASP: Agentic AI Threats and Mitigations
- Anthropic Research: Constitutional Classifiers
- Anthropic Research: A small number of samples can poison LLMs of any size
- Hines et al.: Defending Against Indirect Prompt Injection Attacks With Spotlighting
- OpenSSF Scorecard
- Claude Code security documentation
- Safeguard docs: Guard Policies
- Safeguard docs: Guard Proxy Deployment
- Safeguard docs: Guard Audit Trail
- Safeguard docs: AI Gateway
- Safeguard docs: AI agent discovery
- Safeguard docs: Credentials Vault
- Safeguard docs: AI-BOM Discovery
- Safeguard docs: AI-SPM
- Safeguard docs: Package Firewall
- Safeguard docs: Vulnerability prioritization and reachability
- Safeguard docs: SecOps
- Safeguard docs: Compliance