LLM gateway control plane

Govern, route, and trace production LLM traffic from one console

Agumbe gives platform teams an AI gateway with app-level credentials, BYOK provider routing, guardrails, budgets, usage logs, and trace-ready observability... and more

Provider-compatible
OpenTelemetry-ready
App-level guardrails
BYOK governance
Agumbe observability console showing traces, metrics, request timelines, and gateway request details
Route
Send AI traffic to the right model or provider.
Guard
Apply policies before requests leave your system.
Observe
Track requests, tokens, costs, errors, and traces.
Optimize
Control spend, latency, fallbacks, and provider usage.
How it works

Connect. Configure. Observe.

Start with a gateway key, define how AI traffic should behave, then watch every request as it moves through your production path.

01

Connect

Bring provider keys, create app credentials, and point your applications to the Agumbe gateway.

02

Configure

Set model routing, guardrails, budgets, environments, and app-level access policies from the console.

03

Observe

Follow every request with usage logs, token counts, cost, latency, errors, and trace-ready telemetry.

Built for production AI traffic

More than model access. A safer request path for every app.

Production traffic needs app keys, policies, budgets, request history, and debugging signals in one place.

App-level access

Issue credentials per application, team, or environment instead of scattering provider keys across services.

Provider-neutral routing

Move between external providers, private models, and fallback routes without hardcoding provider logic everywhere.

Guardrails before egress

Check denied topics, sensitive data, and request policy before prompts reach any external model provider.

Budgets and limits

Attach caps to apps, teams, and environments so AI usage stays visible before spend surprises the team.

Request visibility

See who called what, when, from where, which model was used, and how much each request cost.

Trace-ready telemetry

Emit request-level signals into the observability stack your platform team already understands.

Provider neutral

Keep the developer API stable while models change underneath.

Let application teams integrate once. Then introduce new providers, local models, fallback policies, app allowlists, and customer-owned keys without rewriting every service.

Provider-compatible clients

Use familiar SDKs by changing the base URL and gateway key.

Multiple model providers

Route to hosted providers, private models, or local checks through aliases.

Bring your own keys

Keep provider accounts behind app-scoped gateway credentials.

Environment-aware routing

Use different policies for development, staging, production, or customer traffic.

Observe every request

Debug the request, and the model response.

See app identity, policy decisions, provider routing, model latency, token usage, cost, and trace correlation together. When a request fails or gets blocked, the explanation is visible.

Separate provider latency from gateway overhead.

Open guardrail decisions next to the request that triggered them.

Follow aggregate error rates down to one trace and one app key.

Trace waterfall
policy passed
fallback ready
SpanTimelineDuration

gateway.request

8.52 s

auth.app_key

42 ms

guardrails.check

210 ms

provider.chat

7.82 s

usage.emit

120 ms
Agumbe console observability dashboard with requests, errors, costs, and traces
Developer experience

Adopt the gateway with a one-line change.

Point your application, internal tool, agent, or developer workflow to Agumbe. Keep provider choice, guardrails, budgets, and visibility outside application code.

Chat completions
Embeddings
Streaming
Model aliases
Gateway keys
gateway-client.ts
base URL swap
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.agumbe.ai/v1",
  apiKey: process.env.AGUMBE_GATEWAY_KEY
});

const response = await client.chat.completions.create({
  model: "agumbe/smart-router",
  messages: [{ role: "user", content: prompt }],
  metadata: {
    app: "support-copilot",
    environment: "production"
  }
});
Codex integration

OpenAI Codex and Agumbe AI Gateway

Route Codex requests through Agumbe AI Gateway to unlock guardrails, smart routing, observability, and more.

~/.codex/config.toml
gateway provider
model_provider = "agumbe"

[model_providers.agumbe]
name = "Agumbe Gateway"
base_url = "https://api.agumbe.ai/api/v1/llm"
env_key = "AGUMBE_API_KEY"
Claude Code integration

Anthropic Claude Code and Agumbe AI Gateway

Connect Claude Code to Agumbe with your Agumbe API key. Requests are routed through the gateway with your guardrails, budgets, and observability applied.

~/.claude/settings.json
Anthropic Messages API
{
  "env": {
    "ANTHROPIC_BASE_URL":
      "https://api.agumbe.ai/api/v1/anthropic",
    "ANTHROPIC_AUTH_TOKEN": "YOUR_AGUMBE_API_KEY",
    "CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY": "1"
  },
  "model": "claude-sonnet-4-6"
}
Agumbe LLM Console

Start routing AI traffic through a governed gateway.

Connect your apps, configure routing and guardrails, then observe every request as teams move toward production AI usage.