← All posts

Every model through one address. Every yes from the right person.

15 November 2026 · Deliverd Engineering Team · 4 min read

An agent card sends one line into a round hub, which fans out to six model cards; below, a tool call waits at an amber pause, and a dotted blue line runs from the pause to a person with a blue tick, and back.

OpenRouter gives you one API for hundreds of models. You send a request to one address and it picks a provider that can serve it, falls back if that provider is down, and bills you in one place. Many teams use it as their model provider and never think about it again. Some build their agents on it directly, with OpenRouter's own Agent SDK.

The pause is there. The person isn't.

OpenRouter's Agent SDK already knows that some tool calls shouldn't just run. Mark a tool requireApproval: true and, when the model calls it, the run pauses. You resume it later with the ids of the calls you approve and the ones you reject.

What it can't know is who should decide. OpenRouter's own guide on human review suggests an admin page, a Slack message or a command-line prompt, and leaves the rest to you. That rest is the hard part: which person owns a £250 refund, what happens when they're away, how the agent hears "no, and here's why", and how you show an auditor in six months who allowed which call.

A named person, from their inbox, Slack or Teams

@deliverd/sdk 0.38.0 adds an adapter for OpenRouter's Agent SDK. It plugs into the SDK's PermissionRequest hook, which fires just before a run would pause:

import { deliverdPermissionRequest } from "@deliverd/sdk/adapters";

const result = openrouter.callModel({
  model: "anthropic/claude-sonnet-4.5",
  input: "Customer on order 1042 was charged twice. Refund £250.",
  tools: [refund], // tool({ ..., requireApproval: true })
  hooks: { PermissionRequest: [deliverdPermissionRequest({ deliverd, approvers: ["finance"] })] },
});

The finance team gets the request with the tool and its input, field by field. The run waits for their answer and carries on by itself. If they say no, the model is told, with their reason, so it changes course instead of trying again.

Some decisions take longer than a process should wait. For those, let the run pause the way OpenRouter does and save its state, then call resolveOpenRouterApprovals. It asks about each waiting call and hands back the lists to resume with. Each call is keyed by its conversation and call id, so if your process restarts and asks again, it finds the same request rather than filing a second one.

If you already route tool calls through a decision model such as Jev, which OpenRouter's docs feature, the two fit together. Jev settles the routine calls. The ones it isn't sure about are the ones a person should see, and that's where Deliverd comes in.

A yes on the guardrails, too

OpenRouter's guardrails decide what a key may spend, which models and providers it may reach, whether providers may keep or train on what's sent, and which regions requests may route through. They're strong controls. Anyone with a management key can change them, though, and nothing records who agreed.

changeOpenRouterGuardrail reads a guardrail, shows a person each setting that would change, before and after, and applies the change only when they say yes. Anything that loosens a control, such as a higher spend limit, retention or training turned back on, or more providers, is asked as high risk. raiseOpenRouterKeyLimit does the same for one key's credit limit, and shows what the key has already spent. Both run with your management key in your own process. The key never reaches Deliverd.

Your AI use policy, as guardrail settings

Deliverd's AI use policy is a grid: which kinds of data may go into which kinds of AI tool. openRouterGuardrailForData reads it for the data a key will carry and says what OpenRouter needs to be set to:

  • Data your policy allows in consumer tools needs nothing extra.
  • Data that needs an enterprise tenant needs zero data retention, with training and publication off. That only counts under your own agreement with OpenRouter.
  • Data your policy keeps to a private deployment, or out of AI tools altogether, may not go through OpenRouter. The helper says so rather than finding a setting that looks close enough.

And the register

OpenRouter passes each request on to a model provider, so the models you reach through it belong in your AI register. registerOpenRouterModels reads the last month of OpenRouter activity and adds each model nobody has registered, as found in use, with OpenRouter as the supplier. A person then fills in who uses it and why.

What Deliverd doesn't do

Deliverd doesn't route model requests, meter them or set limits on them. OpenRouter does that, and does it well. Deliverd decides whether an agent's action happens and whether a control changes, and keeps the record of who agreed.

The setup guide has the details. Start free and try it on one tool first. We'd like to hear how your approvers get on.

Give your agent a way to ask.

Give any AI agent a way to ask a person — for approval, a decision, an answer or a review.