Theseus · The Secure AI Router

Not every prompt needs a frontier model.
Route each one to the right one.

Theseus sits where your AI agents already talk. Work stays on your own models at your own prices — tool-driven agent turns included, on any inference server, no redeploy — and never reaches a third-party model provider. The frontier gets only what your levers send it. Every request is verified in the request path and every decision is recorded with its reason.

FREE COMMUNITY TIER · 2,500 ROUTED REQUESTS/MO · NO CREDIT CARD — OPENAI & ANTHROPIC PROTOCOLS · CURSOR & CLAUDE CODE READY
Routers pick the cheapest model. Theseus is the first router that verifies. Every request is inspected by the same verification engine behind Orpheus and Perseus before it leaves — a prompt carrying secrets never reaches a third-party API, whichever model was cheapest.
Why Theseus

A thread through the labyrinth.

AI spend today is a maze: every prompt goes to whichever frontier model someone configured, at frontier prices, carrying whatever data it carries — and nobody can retrace a single hop. Theseus leaves a thread. Every request is routed deliberately, verified on the way, and recorded with the reason it went where it went.

"Which model answered this — and why?"
"How much of our traffic actually needed GPT-5?"
"Did customer data leave the network last night?"
"Who approved this agent using that provider?"
theseus · decisions
cursor · theseus-auto→ LOCAL
llama-3.3-70b · "no tools, short context — light work stays home"
claude-code · theseus-auto→ FRONTIER
claude-sonnet · "14 tools attached — agentic work needs the frontier"
sdk · theseus-auto✕ BLOCKED
secrets verifier · private key in prompt — never left the network

Every routed request carries the pool, the resolved model, and the reason — audit-ready, per team.

01Every prompt pays frontier prices. Most don't need to.The problem

Spend is unbounded

Agents hard-code one frontier model and send it everything — the two-line commit message and the ten-file refactor cost the same premium tokens.

Data leaves on every call

Prompts carry code, credentials and customer context to third-party APIs by default — even the traffic your own hardware could have served.

Nobody can say why

Model choice lives in scattered configs and env vars. When finance or security asks which model handled what, there is no record to point at.

And the routers on the market solve only the price column: they pick a cheap model and forward your prompt as-is. A router that doesn't verify is just a cheaper way to leak.
02One base URL. One model name.Cursor · Claude Code · Any SDK

Your agents keep speaking the protocols they already speak — OpenAI or Anthropic. Point them at Theseus, set the model to theseus-auto, and routing starts. No SDK, no rewrite, no sidecar.

theseus-auto: the router decides, by your levers — from light work inside, up to everything your own model can take, tool calls included.
theseus-local / theseus-frontier: pin a request to a pool when you already know where it belongs.
Works where your team works: Cursor's base-URL override, Claude Code's env vars, or any OpenAI / Anthropic SDK.
NO REWRITE TWO PROTOCOLS ANY AGENT
~/.claude/settings.json
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://theseus.ciphero.ai/api/proxy",
    "ANTHROPIC_AUTH_TOKEN": "your-router-key",
    "ANTHROPIC_MODEL": "theseus-auto",
    "ANTHROPIC_SMALL_FAST_MODEL": "theseus-local"
  }
}
# Claude Code's background traffic now stays on your own models.

The whole integration is configuration. Cursor is one base-URL override; an OpenAI SDK is one base_url argument.

03Two pools. Your models on one side.Local · Frontier

You define two destination pools: local — self-hosted, OpenAI- or Anthropic-compatible endpoints like a vLLM fleet, on infrastructure you control — and frontier — the third-party providers you already pay for. The router reads each request's shape and sends it to the cheapest pool that can actually do the job. Requests pass through Ciphero's router to get there; it keeps the decision and a digest of the prompt, never the prompt itself.

Light work stays home: short prompts, no tools — served by your own models at your own prices.
Agent work can stay home too: Theseus does the tool calling for inside models that lack it. Claude Code and Cursor get native tool calls from a stock vLLM, Ollama or llama.cpp server — no server flags, no redeploy. On Enterprise, every call is reviewed before the agent runs it.
Past the escalation point, the frontier: large context and the hardest reasoning go where they'll succeed, and the decision says why.
Degraded pools fail over: if a destination fails, new conversations go to the other pool for the next five minutes and the decision says so. Running conversations keep their model, and flagged content never leaves to fail over.
theseus · destinations
theseus-local-vllm llama-3.3-70b LOCAL
theseus-frontier-anthropic claude-sonnet FRONTIER
theseus-frontier-openai gpt-5 FRONTIER

Destinations are plain provider endpoints with a key and a default model — added in the dashboard in a minute.

04Verified before it leavesThe Secure half

Every routed request passes through the Ciphero verification engine — the same layer that protects Orpheus's coding agents and Perseus's production apps. Secrets, PII and high-confidence prompt injection are caught in the request path, before the prompt reaches any provider — including the cheap one. Enterprise adds context-aware PII, your own thresholds, and review of what the model asks the agent to run.

Blocked in-protocol

A blocked request comes back as a well-formed model response your agent already knows how to display — streaming included. No broken sessions, no mystery 500s.

Recorded with its reason

Pool, resolved model, routing reason, verification verdict — one record per request, per team. When someone asks "why did this go there," the answer is a filter, not an investigation.

Your agent asks for theseus-auto
Cursor · Claude Code · any OpenAI / Anthropic SDK
verified & routed in the request path
Theseus verifies, then decides
request shape → local pool or frontier pool, with the reason recorded
Routed → local or frontier
Unsafe → blocked before it leaves
05Every decision, on the recordLive

The Overview shows what routed where and why — how much traffic stayed local, what it would have cost at frontier prices, and every individual decision in a feed you can read.

Decisions: every routed request across your team's agents — pool, model, and reason, the moment it happens.

In active development

What lands next.

Being straight about what isn't built yet is part of being a vendor worth trusting. These are in build now, not shipping today.

Learned routing

Ciphero's own routing model grades each request's difficulty and category against your pools' measured capabilities — routing by evidence, not just request shape.

Cost policies in plain English

"If this team's monthly spend passes $1,000, prefer the local pool." Policies compile into routing rules the same way Orpheus compiles verifiers from documents.

Enforced budgets

Daily and monthly token limits per destination that actually stop spend, with an alert before they do — not just a report after the fact.

More agents

OpenCode, Codex CLI and friends — anything that speaks the OpenAI or Anthropic protocol already works today; first-class setup guides are on the way.

Community · Enterprise

Detection is the product, not the paywall.

Both tiers verify every request before it is routed. Community detects and routes. Enterprise governs — deeper detection, review of what comes back, and no ceiling.

Community

Free
2,500 routed requests a month, shared by the team.
All four levers — sovereignty, data control, security, escalation.
Egress verification: secrets, and PII in pattern mode — structured identifiers, deterministic, about a millisecond.
Prompt injection by a purpose-built classifier, acting only above 85% confidence. No LLM in the path; the whole check fits in a second.
Every decision recorded with its reason; Live Ops; per-developer attribution and join links.
Claude Code configured by one command; Cursor in two settings.
Start free

Enterprise

Talk to us
No monthly ceiling.
Context-aware PII — personal data written in prose, judged by a model, with suppression rules for what your team has accepted.
Prompt injection, tuned — set the confidence threshold and risk levels yourself.
Tool-call review — what the model asks the agent to run is checked before it reaches the agent.
Orpheus alongside: the same key governs what the agent does — shell, file edits, MCP — not only what it sends.
Talk to us

Put Theseus between your agents and the frontier.

Start on the free Community tier — 2,500 routed requests a month, no credit card — or book a 30-minute walkthrough and watch your own traffic route.