AI governance tells you the rules. Runtime agent security helps enforce them when the agent acts.
If you're standing up AI, you'll hear two things called "AI security" that do different jobs. Governance platforms define, validate, document, and prove your AI controls. Runtime agent security inspects and constrains what an agent actually does at the moment it acts. You likely need both, and it helps to be clear about which does what before you buy either.
Crawdad is the runtime-enforcement layer. It complements your governance system of record.
One writes the policy. The other enforces a piece of it, live.
An AI governance system is a system of record for responsible AI: it inventories your models and agents, maps controls to frameworks, runs approvals and validations, monitors, and produces the documentation and evidence a risk or compliance function needs. Its question is what should be allowed, and can we prove we governed it.
Runtime agent security operates at a different moment: the live interaction, where an agent reads content, calls a tool, touches data, and makes a network request. Its question is is this specific action, right now, within what this agent is allowed to do — and it can block, hold, or record that action before it happens.
Governance defines the rule. Runtime security is one of the places the rule becomes operational and provable. They're not competitors; a governance policy that says "agents must not exfiltrate credentials" needs something at the wire that actually stops it.
Side by side
| Question | AI governance platform | Runtime agent security (Crawdad) |
|---|---|---|
| Main objective | Define, validate, document, oversee, and prove responsible-AI controls | Inspect and constrain risky agent behavior at the moment of action |
| Typical users | Governance, risk, compliance, legal, model-risk leaders | AI, security, and platform engineering; technical operators |
| Control timing | Design, approval, testing, monitoring, audit, lifecycle | Live agent interaction: tool use, data access, network egress |
| Evidence produced | Policy mapping, inventories, reviews, validation records | Runtime decisions, enforcement events, agent and tool context |
| Relationship to the rule | Governs what should happen | Makes a subset of those rules operational and provable at the wire |
Governance sets the boundary. Crawdad enforces it where the agent acts.
A governance program might require that a customer-facing agent never touches production credentials, only reads from approved sources, and produces an auditable record of its actions. Those are rules. Crawdad is one way they get enforced in reality:
- The rule "this agent's job is X, not Y" becomes a charter Crawdad enforces at the wire, on the observed action, on the device.
- The rule "credentials must not leak" becomes an architectural guarantee: the real key lives in a store the agent never touches.
- The rule "we must be able to prove what the agent did" becomes a signed, hash-chained log an outside party can verify independently.
Crawdad doesn't replace your governance system of record. It gives that system a runtime enforcement signal and a verifiable evidence trail for the agent-action layer — the part governance can define but can't itself execute.
When you need which
- You need governance when your job is to define, approve, document, and prove AI controls across the organization, and to satisfy risk, legal, or regulatory requirements.
- You need runtime agent security when agents are actually running with real credentials, tools, and untrusted context, and something has to inspect and constrain what they do before harm occurs.
- You need both when you have governance requirements and live agents — which is most organizations deploying agents seriously. Governance without runtime enforcement is a policy no one is checking at the moment it matters; runtime enforcement without governance is control without a system of record.
Crawdad runs on the device, judges the action, and writes a record you can verify yourself.