What is MACAW?
The trust layer for AI agents - core concepts, architecture, and what makes it different
12 questions
MACAW is the trust layer for AI agents. It provides security infrastructure that lets you control what AI agents can do, who they can do it for, and creates cryptographic proof of every action.
MACAW works by wrapping your existing AI code (OpenAI, Anthropic, LangChain, MCP) with policy enforcement. You define what's allowed, MACAW enforces it - at every boundary your AI crosses.
MACAW started as "Model Authorization and Cryptographic Agent Workflows" - can we track what the model is, what it's allowed to do, and back it with cryptographic evidence?
Then we realized it's not just LLMs. Agentic AI means we need to do this for all apps - autonomous workflows crossing multiple tools, data sources, and services.
Our big realization: instead of creating specialized behavioral solutions (prompt injection detection, hidden file access detection, etc.) which haven't worked, we need a fundamental infrastructure rethink. We'd already solved all of this for distributed systems - so "old is new again."
Based on 30 years of security engineering experience, it's not about how complex but how simple we can make it. Invisible, always on. That's why MACAW is designed to be a drop-in replacement - about 30 seconds to production.
Traditional security has fundamentally failed for agentic AI because LLMs have no syntactic boundary between instructions and data - they can't tell the difference between "summarize this email" and "ignore previous instructions." Pattern-matching defenses (prompt injection detectors, content filters) don't work because:
- LLMs are non-deterministic - same input can produce different outputs
- Attacks are semantic, not syntactic - can't detect meaning with regex
- The attack surface is unbounded - you can't enumerate what you haven't thought of
MACAW's insight: Instead of trying to enumerate and detect attacks, we bound the system deterministically. Agentic systems can be abstracted as simple, byzantine distributed systems - and we already know how to secure those.
The result: Breaking your AI system requires breaking cryptography, not crafting clever prompts. That's a fundamentally different security posture.
MACAW delivers this through:
- Identity propagation - User context flows to every AI operation
- Policy enforcement - Control what each user's AI can access
- Cryptographic proof - Every action signed and auditable
- Drop-in integration - About 30 seconds to production, not months
We model four surfaces where AI agents can be attacked:
Surface What It Is Attack Example S1: Prompts Instructions that tell AI what to do Prompt injection, jailbreaks S2: Tools External systems AI invokes Malicious tool responses, confused deputy S3: Data Information AI accesses Poisoned training data, data exfiltration S4: Context State AI accumulates Context manipulation, memory corruption Why these four? They follow from what an agentic system does: it receives instructions, calls tools, accesses data, and maintains state. We model four surfaces (prompts, tools, data, context) and enforce intent + integrity at each.
MACAW's security model enforces two properties at every boundary crossing. Both are necessary; neither is sufficient alone.
Intent (by-policy enforcement): Does this operation satisfy organizational policies?
- Does the user have permission for this action?
- Does policy allow this tool/model/data access?
- Are the parameters within allowed constraints?
Integrity (by-design elimination): Is this operation cryptographically authentic?
- Is the request signed by a legitimate source?
- Has the request been tampered with in transit?
- Does the cryptographic chain verify?
Why both? Consider the alternatives:
- Intent without integrity → attacker forges requests that look authorized
- Integrity without intent → authentic requests that violate policy still execute
Together, they bound the system deterministically. Unknown attacks are eliminated by design (integrity) or caught by policy (intent). The result: breaking your AI system requires breaking cryptography, not discovering novel prompt injections.
This is the same insight that secures distributed systems: you don't enumerate every possible network attack - you require signed, authenticated messages that satisfy policy. MACAW applies this to agentic AI.
Yes and no - different components have different licensing:
Component Status Notes Adapters Open source (Apache 2.0) OpenAI, Anthropic, LangChain, LiteLLM, Pydantic AI, MCP, MCP proxy. Contributions welcome. Client SDK Free binary Installed by macaw-ai install --client, or downloaded from the console. Common to all tiers.Control Plane SaaS / Hybrid Closed source. We made it SaaS because there's a ton of operational details to get right. MAPL Spec Open Policy language specification on website and in papers. Implementation is in SDK and SaaS. We'll open source additional parts over time.
Anyone using LLMs who cares about safety and controls should look at MACAW.
For developers building AI applications: Drop-in adapters that add security without changing your code architecture.
For enterprises in highly regulated industries (finance, healthcare, legal): Restrictive mode, crypto-at-rest, configurable signing, HSM/KMS support. MACAW is built to be highly configurable for these environments.
For teams scaling from prototype to production: start free on Developer, and move to Enterprise as needs evolve.
About 30 seconds to production. If you're using standard-compliant OpenAI, Anthropic, or MCP (e.g., FastMCP), it's literally lift and shift with one line of code change.
# Before from openai import OpenAI client = OpenAI() # After (one import change) from macaw_adapters.openai import SecureOpenAI client = SecureOpenAI(app_name="my-app")That's it. Same API, now with policy enforcement, cryptographic signing, and full audit trail.
Both, and more. MACAW is a distributed trust mesh: a Policy Enforcement Point (PEP) runs wherever a call runs, in whichever form fits.
How it attaches:
- Library - the client SDK and SecureAI adapters, inside your app (change one import)
- Sidecar - beside Claude Code or Codex, gating every tool call before it runs
- Proxy - SecureMCPProxy, inline in front of an MCP server you don't control
Not a central gateway (single chokepoint problems):
- One gateway for all traffic = maintenance headache, scaling issues, single point of failure
- MACAW = distributed PEPs at every boundary
Distributed trust mesh benefits:
- Any node going down won't affect others and can recover
- Real-time enforcement at the edge
- Works on edge devices out of the box
- No bottleneck, linear scaling
Consider the cost:
Time: 6-8 weeks of custom development per application for JWT validation, policy engine, audit logging, enforcement, error handling. And that's just v1.
Skill: Do you have security engineers who understand cryptographic signing, policy algebra, distributed enforcement, and AI-specific attack vectors?
Risk: Can you afford to get it wrong? A security gap in your AI system isn't a bug - it's a breach waiting to happen.
Focus: Where do you want your engineers spending their time - building your product, or reinventing security infrastructure?
MACAW integration: about 30 seconds. Same security guarantees that took us years to build and harden.
No - MACAW extends your identity provider, not replaces it.
Think of it as different layers:
Layer What It Solves Examples Identity (Okta/Auth0) Who is this person? Authentication, SSO, directory Agentic Access Control (MACAW) What can their AI do? Policy enforcement, workflow governance, crypto audit Okta tells you Alice is authenticated. MACAW tells you Alice's AI agent can only use GPT-3.5, access public documents, and make 100 calls per hour.
This is the trajectory: firewall → identity (Okta) → API security (Zscaler) → agentic access control (MACAW). Or at the protocol level: Kerberos → mTLS → MACAW.
MACAW integrates with your existing IdP - Okta, Auth0, Azure AD, Keycloak, Google, or any JWT issuer.
SecureAI adapters (maintained, open source):
- OpenAI - SecureOpenAI drop-in replacement
- Anthropic/Claude - SecureAnthropic drop-in replacement
- LangChain - drop-in LangChain wrappers
- LiteLLM - SecureLiteLLM, covering 100+ providers
- Pydantic AI - SecurePydanticAI for agents, models and tools
- MCP (Model Context Protocol) - SecureMCP for your own tool servers
- MCP proxy - SecureMCPProxy, inline in front of external MCP servers
Coding agents: Claude Code and Codex, through the MACAW sidecar.
Need another framework? Contact us, or build your own adapter on the client SDK.