BRIDLE

One line of config.
Everything your agents do, on a leash.

Bridle is a gateway that sits between your agents and their model providers. You change a base URL. We meter, cap, log, and when needed, stop them.

The integration is a base URL swap

Your agent already calls OpenAI, Anthropic, or Gemini. Point that client at our gateway instead and add your Bridle key. Your provider key stays in its usual header. We pass it through and never store it.

# before
client = OpenAI()

# after
client = OpenAI(
  base_url="https://api.agentbridle.com/gateway/openai/v1",
  default_headers={
    "X-Bridle-Key": "bk_...",
    "X-Bridle-Run-Id": "nightly-invoices-042",
  },
)

# same for Anthropic and Gemini:
#   /gateway/anthropic
#   /gateway/gemini

What happens on every single call

Identify

The Bridle key maps the call to a named agent and a run. No more anonymous traffic from a shared service account.

Check

Is the agent active? Is the run under budget? If not, the call never leaves the building and your agent gets a clear error.

Forward

The request goes to the provider unchanged, streaming included. We add single digit milliseconds, not a rewrite of your stack.

Meter

Token counts come back with the response. We price them against the model's real rates and add the cost to the run, live.

Budgets that actually stop things

Every agent gets a dollar cap per run. When a run crosses it, the run is killed and every further call is refused with a 402. Your agent finds out immediately, in code, mid job. Not you, three weeks later, on an invoice.

A killed run is a log entry, a red badge in the dashboard, and a capped bill. That is the whole point.

HTTP/1.1 402 Payment Required
{
  "error": "run_terminated",
  "message": "run nightly-invoices-042 is killed;
              budget cap reached",
  "spent_usd": 5.00
}

A paper trail your security team will accept

Every call is logged against the agent that made it: model, tokens in and out, cost, latency, status. Runs group the calls into jobs. When the security review asks what your agents can do and what they did, you export the answer instead of writing a doc from memory.

For risky actions, your agent asks first: one API call raises an approval request, the run holds, and someone on your team approves or denies it from the dashboard, with a Slack ping so nobody waits long. Every decision and decider goes into the log.

Common questions

Does this add latency?

The gateway runs at the edge and forwards requests without buffering. Streaming responses pass straight through. Expect single digit milliseconds of overhead.

Do you see my provider API keys?

They transit the proxy in the request headers, are never written to disk or logs, and are never stored. Your Bridle key is stored only as a hash.

What if my agent does not group calls into runs?

Then each call becomes its own run with its own cap. Passing a run id is one header and gets you per job budgets, which is what most teams want.

Which providers and models?

OpenAI, Anthropic, and Gemini today, current model lineups included. Unknown models are billed at a conservative rate rather than slipping through free.

See it on your own agents.

We are onboarding a small group of teams for the beta. It takes about ten minutes to route your first agent through the harness.