Typed execute endpoint
Agent SDKs provide a typed execute endpoint with per-agent credentials. Each agent operates under its own identity and policy scope.
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.
Agent SDKs provide a typed execute endpoint with per-agent credentials. Each agent operates under its own identity and policy scope.
Enforce spend limits, throughput caps, and payload validation before any agent action executes. Non-conforming requests are blocked with a clear reason.
Group multiple agent actions into a single bundle. If any step fails, preceding steps are rolled back automatically.
Require human approval before sensitive actions proceed. Every execution is recorded as an OTEL trace for full auditability.
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.
Google ADK, LangChain, CrewAI, AutoGen, Bedrock Agents, or custom
Policy gates · approvals · bundles · OTEL traces
Payments, CRM, internal APIs, partner integrations
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 guardrails | Action guardrails (AgentDelivery) | |
|---|---|---|
| Controls | What the model reads and writes: system prompt, inputs, outputs | What the agent does: the actions it triggers in payments, CRM, and internal APIs |
| Typical controls | System 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 runs | Inside or around the LLM call | Between the agent and your webhook endpoints, before execution |
| What it prevents | Inappropriate content and sensitive information in outputs | Duplicate 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.
Every agent action takes the same path. Each step runs before your systems see the request, so a blocked action never executes.
Match the guardrail to the risk of the action. Low-risk actions run straight through; irreversible actions wait for a person.
| Agent action | Risk | Guardrail |
|---|---|---|
| Issuing refunds and other financial transactions | Runaway cost; the same refund paid twice | Daily budget gate per agent plus idempotent execution |
| Deleting records or changing accounts | Irreversible data loss | Human approval before execution |
| Sending emails and notifications | A loop sends the same message hundreds of times | Rate gate per agent plus duplicate suppression |
| Provisioning (entitlement, confirmation, ledger entry) | A partial failure leaves systems out of sync | Atomic bundle with rollback |
| Any action built from model output | Missing or malformed fields | Content 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,
})
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.