Every LLM call, governed
before the request leaves your network.
Router is a Guard-aware LLM proxy. Point any SDK at it — Anthropic, OpenAI, Perplexity — and every call runs through policy before it hits the upstream provider.
Per-agent tokens, provider fallback, retry on upstream error, spend metering, hash-chained audit. One drop-in URL swap for your existing code.
Four primitives, one proxy
Every Router feature exists because a real agent broke on it in production.
Per-agent tokens
Every agent gets its own cond_agt_* bearer minted at run start. Rotate on demand, scope to a workflow, revoke without touching upstream keys.
Provider fallback
Configure a primary and one or more fallbacks. If Anthropic rate-limits or 500s, Router retries against OpenAI or Perplexity within the same request, transparent to the caller.
Retry on upstream error
Structured LLMUpstreamError classification with exponential backoff. Retries survive transient 429/500/network errors so a flaky provider doesn't fail your agent.
Hash-chained audit
Every request/response pair is logged with the active policy hash, agent identity, spend, and provider. Chain is append-only and verifiable — proof of governance for auditors.
Two ways to route through Conduct
Same policy engine, two integration points. Pick based on what your stack already runs.
Conduct Router
Point any provider SDK at api.conductai.ai/proxy/<provider>. No new infrastructure — Router speaks each provider's native API, per-agent tokens, retries, and audit chain out of the box.
export ANTHROPIC_BASE_URL=\ https://api.conductai.ai/proxy/anthropic export ANTHROPIC_API_KEY=cond_agt_...
- Provider fallback + retries baked in
- Spend metering per agent token
- One URL swap in your app
LiteLLM + Guard plugin
Keep your LiteLLM proxy. Install conduct-litellm-guard — every call through LiteLLM policy-checks against your active Conduct packs before the upstream request goes out.
Explicit form — any LiteLLM version
# config.yaml
guardrails:
- guardrail_name: conduct-guard
litellm_params:
guardrail: conduct_litellm_guard.ConductGuard
agent_token: os.environ/CONDUCT_AGENT_TOKENNative form — once BerriAI PR #38143 merges
guardrails:
- guardrail_name: conduct-guard
litellm_params:
guardrail: conduct
api_key: os.environ/CONDUCT_AGENT_TOKENpip install conduct-litellm-guard(both forms)- No infrastructure change to your LiteLLM setup
- View plugin source
Both paths hit the same policy engine, the same signed configuration, and the same hash-chained audit log. Same enforcement, same evidence — different entry points.
Swap one URL. Nothing else changes.
Router speaks each provider's native API. Your existing SDKs work unchanged — you point them at Router instead of the upstream host.
curl https://api.conductai.ai/proxy/anthropic/v1/messages \
-H "Authorization: Bearer cond_agt_..." \
-H "Content-Type: application/json" \
-d '{
"model": "claude-sonnet-4-6",
"max_tokens": 1024,
"messages": [{"role": "user", "content": "Hello"}]
}'Endpoints: /proxy/anthropic/v1/messages, /proxy/openai/v1/chat/completions, /proxy/perplexity/chat/completions
Two minutes to running
Self-host with the same repo as Guard, or use the hosted endpoint.
git clone https://github.com/sseshachala/conductai cd conductai docker compose up
Router listens on port 8000 under /proxy/*. Point your provider SDKs at http://localhost:8000/proxy/<provider>.
export ANTHROPIC_BASE_URL=\ https://api.conductai.ai/proxy/anthropic export ANTHROPIC_API_KEY=cond_agt_...
Mint an agent token in the console. The token owns which Guard packs, spend cap, and provider list apply.
How Router relates to Guard
Router is where Guard enforces.
Guard is the policy engine — packs, personas, and hash chain. Router is the point where those policies run. Every LLM call that arrives at Router is checked against the active packs before the upstream request goes out.
If a policy blocks, the caller gets a structured 403 with the rule name and remediation hint — no upstream token spent. If a policy warns, the call proceeds and the audit chain records it. If it's allowed, Router forwards with a full audit entry: agent identity, active pack hash, latency, tokens, spend.
You can run Router without Guard (drop the packs, it becomes a plain observable proxy). You can run Guard without Router (Guard also enforces on the CLI hook and MCP layers). But together they cover every path an agent uses to reach a model.
Route your agents through Conduct.
Same repo as Guard. Same license. One docker compose up.