agentdelivery
Dashboard
Now Live

AI Agent Guardrails: Control What Agents Do Before They Do It

The governance layer that sits in front of the webhooks your AI agents call. Policy gates, approval workflows, atomic bundles, and OTEL traces — before any action executes.

Built for engineering, DevOps, and security teams running revenue-critical webhook or agent workflows: govern autonomous actions before they hit downstream systems, with human review, rollback-aware multi-step execution, typed SDKs, per-agent credentials, and full auditability.

Works alongside any orchestration runtime — Google ADK, LangChain, CrewAI, AutoGen, or custom. This is the governance layer, not the runtime.

See Pricing ↓
Agent SDKs

Typed execute endpoint

Agent SDKs provide a typed execute endpoint with per-agent credentials. Each agent operates under its own identity and policy scope.

Policy Gates

Budget, rate & content rules

Enforce spend limits, throughput caps, and payload validation before any agent action executes. Non-conforming requests are blocked with a clear reason.

Bundles

Atomic multi-action execution

Group multiple agent actions into a single bundle. If any step fails, preceding steps are rolled back automatically.

Approval & Traces

Human-in-the-loop & OTEL

Require human approval before sensitive actions proceed. Every execution is recorded as an OTEL trace for full auditability.

How it fits your stack

AgentDelivery ACP is the governance layer between your agent runtime and the systems it acts on. Bring your own orchestration framework — we govern the actions.

Your runtime
Agent orchestration

Google ADK, LangChain, CrewAI, AutoGen, Bedrock Agents, or custom

→
AgentDelivery ACP
Action governance

Policy gates · approvals · bundles · OTEL traces

→
Your systems
Webhook endpoints

Payments, CRM, internal APIs, partner integrations

AI guardrails vs. agent action guardrails

Most AI guardrails govern what a model says. Once an agent has tool calls with write access to real systems, you also need guardrails on what it does.

Model guardrailsAction guardrails (AgentDelivery)
ControlsWhat the model reads and writes: system prompt, inputs, outputsWhat the agent does: the actions it triggers in payments, CRM, and internal APIs
Typical controlsSystem prompt rules, prompt injection filters, PII redaction, output validation (e.g. NeMo Guardrails, LangChain middleware)Budget and rate gates, content rules, human approval, idempotent execution, atomic rollback, audit trail
Where it runsInside or around the LLM callBetween the agent and your webhook endpoints, before execution
What it preventsInappropriate content and sensitive information in outputsDuplicate refunds, runaway costs, unauthorized deletes, half-finished multi-step changes

You need both. Model guardrails reduce how often an agent decides to do the wrong thing. Action guardrails limit what happens when it does anyway, whether the cause is a prompt injection attack, a hallucinated tool argument, or a retry loop. An injected instruction that gets past the model still has to pass the budget gate, the approval step, and the idempotency check before anything changes.

AgentDelivery does not filter prompts or redact personally identifiable information. It governs the action itself, so it complements the model-level guardrails you already run.

How AgentDelivery guardrails work

Every agent action takes the same path. Each step runs before your systems see the request, so a blocked action never executes.

  1. Identify the agent. Each agent calls the typed execute endpoint with its own credentials, not a shared API key. Its policy scope decides which actions it may request.
  2. Check policy. Budget, rate, and content gates are evaluated before execution. Spend ceilings and rate caps stop a runaway agent loop; content rules reject payloads with missing or malformed fields. A blocked request returns a clear reason to the agent.
  3. Require human confirmation where it matters. Approval gates pause sensitive actions and notify the configured approver. Once approved, execution resumes automatically. Human oversight stays on the few actions that need it, not on every call.
  4. Execute once, or roll back. Idempotent execution means a crash, a webhook retry, or an LLM retry after a timeout never fires the same action twice. Bundles group multi-step actions; if one step fails, the preceding steps are rolled back.
  5. Record every decision. Each execution, policy decision, and approval is recorded as an OTEL trace. Paid plans add an immutable audit trail (60 to 365 days) for incident reviews and compliance requirements.

Guardrail examples for common agent actions

Match the guardrail to the risk of the action. Low-risk actions run straight through; irreversible actions wait for a person.

Agent actionRiskGuardrail
Issuing refunds and other financial transactionsRunaway cost; the same refund paid twiceDaily budget gate per agent plus idempotent execution
Deleting records or changing accountsIrreversible data lossHuman approval before execution
Sending emails and notificationsA loop sends the same message hundreds of timesRate gate per agent plus duplicate suppression
Provisioning (entitlement, confirmation, ledger entry)A partial failure leaves systems out of syncAtomic bundle with rollback
Any action built from model outputMissing or malformed fieldsContent rule: required fields and types

A policy is a small JSON document. This one caps a refund agent at €500 a day and 100 actions a minute, and rejects any request without a customer and an amount:

{
  "budget_eur_day": 500,
  "rate_per_minute": 100,
  "require_fields": ["customer_id", "amount"],
  "block_on_violation": true
}

The agent then acts through the SDK. Every call is idempotent, policy-gated, and traced:

from duerelay.agent import Client

client = Client(agent_key="dar_live_...")
result = client.execute("process-refund", {
    "customer_id": "cus_123",
    "amount": 4900,
})

Included in every plan

There’s no separate “agent” tier to buy. Every AgentDelivery plan ships the full Agent Control Plane — policy gates, approvals, atomic bundles, and OTEL traces. Plans differ on volume, not safety.

Plan Monthly Events / mo Agent Control Plane
Free €0 1,000 ✓ Production (capped)
Starter €19 25K ✓ Included
Core €49 100K ✓ Included
Scale €89 250K ✓ Included
Enterprise from €299 1M+ ✓ Included

Every plan runs the Agent Control Plane in production — the Free plan included, capped at 1,000 events/month with no credit card. Exercise SDKs, policy gates, and bundles end-to-end before you upgrade.

Frequently asked questions

What is an Agent Control Plane?

An Agent Control Plane is a governance layer that decides what actions an AI agent is allowed to execute. AgentDelivery’s ACP sits in front of the webhooks your agents call — enforcing policy gates (budget, rate, content), requiring human approval for sensitive actions, grouping multi-step operations into atomic bundles with rollback, and emitting OTEL traces for full auditability.

How is this different from Google’s Agent Control Plane?

Google’s Agent Control Plane (part of Vertex AI / Google ADK) is an orchestration runtime — it runs and manages AI agents. AgentDelivery’s Agent Control Plane is a governance layer — it controls what webhook actions agents are allowed to trigger, regardless of which runtime runs them. The two are complementary: orchestrate with Google ADK, govern with AgentDelivery.

Which AgentDelivery plan includes the Agent Control Plane?

All of them. The ACP is included in every plan — Free (€0), Starter (€19/month), Core (€49/month), Scale (€89/month), and Enterprise. There’s no separate agent tier to buy: plans differ on volume (events, endpoints, retention), not on safety. The Free plan runs the same ACP in production, capped, with no credit card, so you can exercise it before upgrading.

Does this work with LangChain, CrewAI, AutoGen, or Google ADK?

Yes. AgentDelivery’s ACP is framework-agnostic. It sits in front of any webhook-driven action your agent takes, regardless of which orchestration framework runs the agent. Typed SDKs let agents call the execute endpoint directly with per-agent credentials and policy scope.

Can I try the Agent Control Plane for free?

Yes. The Free plan runs the real ACP in production, capped at 1,000 events/month with no credit card — exercise SDKs, policy gates, and bundles end-to-end before upgrading. The ACP is included on every plan.

Do AgentDelivery guardrails stop prompt injection?

Not at the model level: AgentDelivery does not inspect prompts or model outputs. It limits the damage a prompt injection attack can do. An injected instruction still has to pass the agent's budget and rate gates, content rules, and any approval gate before an action executes, and every attempt is traced. Use it alongside model-level guardrails such as system prompt rules and input filters.

What is the difference between AI agent guardrails and access control?

Access control (role-based access control, OAuth scopes, API keys) decides what an agent can reach. Guardrails decide what it is allowed to do once it gets there: how much it can spend, how often it can act, which actions need human approval, and what happens if a multi-step change fails halfway.

What happens when an agent action is blocked?

The request is rejected before it reaches your endpoint, so nothing executes. The agent receives a clear reason (for example, the daily budget is exhausted or a required field is missing), and the decision is recorded in the execution trace.

Ready to govern your agents?

Start free in production — the real control plane, capped, no credit card — or jump straight to a paid plan. The control plane ships with every one.

Start free See plans & pricing