How do I get an API key?

Keys are issued during early access; there is no self-serve signup yet. Ask at hello@alpheai.com or through the form at https://alpheai.com/contact/, and you get a key and a shadow configuration back.

Docs | Alphe AI

Quickstart

Change the base URL. Send auto. That is the integration.

TypeScript, with the OpenAI SDK

The client you already have, pointed somewhere else. Everything the SDK sends — messages, temperature, tools, response format, images — is forwarded to whichever model Alphe picks, and the response comes back in the shape your code already parses.

baseURL is the only line that changes
model: "auto" hands the choice to the router
Streaming, tool calls, structured output and vision pass through
Set ALPHE_KEY from your environment, never in source

route.ts

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.alpheai.com/v1", // the only change
  apiKey: process.env.ALPHE_KEY,
});

const res = await client.chat.completions.create({
  model: "auto",
  messages: [{ role: "user", content: input }],
});

Python, and anything that speaks HTTP

The Python SDK takes the same base URL. So does curl, so does the Anthropic SDK, and so does every framework that lets you name your own endpoint. There is no Alphe package on npm or PyPI to keep in sync with your dependency tree, because there does not need to be one.

Same endpoint, same auth header, same JSON body
No wrapper package, no adapter, no fork of your client
Works from a Lambda, a worker, a notebook or a shell script

quickstart.sh

# python
client = OpenAI(
    base_url="https://api.alpheai.com/v1",
    api_key=os.environ["ALPHE_KEY"],
)

# curl
curl https://api.alpheai.com/v1/chat/completions \
  -H "Authorization: Bearer $ALPHE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"auto","messages":[{"role":"user","content":"hi"}]}'

The request

What auto means, and when not to use it.

model: auto

Let the router decide

The default for anything where the right model differs per request. Alphe classifies the call and sends it to the cheapest model that still clears the quality bar set for that endpoint.

model: a name

Pin it, per endpoint

Name a model instead and Alphe sends the call there. Some paths need reproducibility more than they need savings. Pinned endpoints still get caching, failover, attribution and PII redaction.

Endpoints

One policy each

Policy is set per endpoint, not per account: a support summariser and a contract analyser should not share a quality threshold, a latency budget or a fallback list, and here they do not.

Passthrough

Your parameters survive

Temperature, max tokens, stop sequences, tool definitions, JSON schemas and images are forwarded to the chosen model. Alphe decides where the request goes, not what is in it.

Streaming

Tokens arrive as usual

A streamed response streams. The routing decision is made before the first token, so nothing buffers waiting for the router to make up its mind.

Tenancy

Attribution is a request property

Tag a call with the team, feature and customer it belongs to and the cost follows it into the trace, the budget and the invoice. Unit economics exist without anyone instrumenting them later.

Request lifecycle

Five things happen between your call and your answer.

The same five stages the platform page describes, written here as what an integrator sees rather than as what the system is.

01 · Ingest

The call arrives unchanged

Your request lands on the proxy in the region you deploy it in. Nothing is rewritten; the body you sent is the body the model receives, minus any field you asked Alphe to redact.

02 · Classify

Scored before it is spent

A small resident classifier reads task type, required reasoning depth, context length, tool surface and output contract. It adds about 4 ms, on the same hop as the proxy, and every downstream decision is cheap because of it.

03 · Route

Cheapest that clears the bar

Not the cheapest model — the cheapest one that still passes, priced against live per-provider token rates and measured quality per task class, with a degrading endpoint losing traffic before it starts timing out.

04 · Verify

Checked, not assumed

The output is scored against your rubric. A miss escalates to a stronger model automatically and the escalation is logged, so a router optimising for cost cannot quietly ship a wrong answer to save four cents.

05 · Return

Answer plus a decision record

You get the response in the shape your SDK expects, and the trace gets the reasoning: what was chosen, what was rejected, why, and what it saved against your previous pin.

Budget

Under ten milliseconds, total

Classification and routing together stay under 8 ms of gateway overhead. Provider latency dominates every call; the decision does not move the number your users feel.

Quality bars

You set the threshold; the router lives inside it

A quality bar is a number per endpoint between 0 and 1. It is the floor a model has to clear on that class of request before it is allowed to answer it. Raise it and routing gets more conservative and more expensive; lower it and more traffic lands on small models. The bar is the only knob most teams ever touch.

Rubrics are written per endpoint, in plain language or as a schema
Escalation on a miss is automatic and logged, not a manual retry in your code
The routing table learns, so a class of request does not miss twice
A quality regression raises an alert before it reaches a customer
Latency and region are part of the same policy, not a separate config

policy.yaml

endpoint: support-summary
quality_bar: 0.88
max_latency_ms: 1800
region: eu-west
fallback:
  - claude-haiku-4.5
  - gpt-4o-mini
cache:
  semantic: true
  threshold: 0.94

Decisions

Every route is explainable after the fact

The decision record is the part of Alphe you will read most often. It says what the classifier thought the request was, which bar applied, which model won, which models lost, the one-line reason, and the money the choice saved against the model you used to pin. It is attached to the trace, so an argument about a bad answer is a lookup rather than a reconstruction.

Per-request cost, latency, model, decision and escalation in one trace
Budgets and alerts at team level, enforced at the gateway
OpenTelemetry export into whatever you already run

decision.json

{
  "task": "extraction",
  "reasoning_depth": 0.18,
  "context_tokens": 2841,
  "quality_bar": 0.92,
  "chosen": "llama-3.3-70b",
  "rejected": ["gpt-4o", "claude-sonnet-4"],
  "reason": "clears bar at 1/19th cost",
  "saved_usd": 0.0412
}

Operations

Caching, failover and the things that happen without you.

Semantic cache

Stop paying twice for one question

Exact-match caching catches almost nothing in production, because real users never phrase it identically. Semantic caching matches on meaning above a threshold you control and removes 30–50% of billable calls on repetitive workloads. A cache hit is not billed.

Isolation

Tenant-scoped by default

One customer's cached answer never serves another's. Precision-critical endpoints can set their own similarity threshold or opt out of the cache entirely.

Compression

Context that never mattered

Prompt compression trims the parts of a context window that did not influence the answer, for 20–40% fewer input tokens on long-context workloads.

Failover

A provider outage stops being yours

When a provider degrades, traffic moves to the next candidate that clears the bar, inside the request rather than after a timeout. Your error rate does not move with theirs.

Fallback

Alphe is not a single point of failure

The SDK falls back to your provider directly on a configurable timeout. Self-hosted deployments serve traffic without reaching our control plane at all.

Budgets

Enforced at the gateway

A team budget is a limit at the proxy, not a line on a dashboard read after the money is gone. Alerts fire against the same numbers the invoice is built from.

Deployment

Three ways to run it, one of which changes nothing.

Shadow mode

Measure before you move

Mirror a slice of production traffic to Alphe while your real requests keep going where they go today. After a week you have a baseline and a delta: what routing would have cost against what it did cost, and where routing was wrong. Start there.

Hosted gateway

The base URL swap

Requests go to api.alpheai.com and Alphe holds the provider keys, or forwards through yours. Nothing to deploy, nothing to operate, one invoice or none.

Self-hosted

Your VPC, your network

The proxy is a single binary. Run it inside your own network when prompts cannot leave it, and keep the control plane hosted. Regional pinning and data-residency guarantees are part of the custom plan.

Limits and coverage

The numbers, and what kind of numbers they are.

Alphe is pre-launch. These are measured figures for the current build, not a published SLA, and the ones drawn from third parties say so.

Classification

~4 ms

Added on-path, in-region, below the noise floor of any provider call. The only place Alphe adds meaningful latency.

Gateway overhead

Under 8 ms

Classification, routing and verification bookkeeping together, before the provider call your users are actually waiting on.

Model catalogue

4,500+ models

One routing table across the frontier labs, the open-weight hosts and the specialist endpoints. No tier gating: the catalogue is the same on both plans.

Tools

7,000+ integrations

Routing applies to tools, agents and workflows, not only to chat completions. The decision layer picks the tool as well as the model.

Savings

Up to 70%

From three levers, measured separately: routing down on traffic that does not need a frontier model (75–85%), semantic cache hits (30–50%), prompt compression (20–40% fewer input tokens).

Leaderboard data

Dated, and someone else's

The model board on the home page is a snapshot of the public Artificial Analysis leaderboard captured 6 August 2026 — their measurement, not ours. The accuracy-per-dollar boards are ours and are labelled as such.

Security

What happens to the prompt

Alphe sits on the path between your application and a provider, which makes it the one place worth being specific about. Prompts are used to classify, route, verify and — if you turn it on — cache the request they belong to. They are not training data for anyone, and a self-hosted deployment means they never leave your network at all.

PII redaction applies before a request is forwarded, pinned endpoints included
Semantic cache entries are tenant-scoped; one customer's answer never serves another's
Regional pinning and data-residency guarantees on the custom plan
SSO, SCIM and audit logging on the custom plan
Self-hosted proxy for networks where prompts cannot leave
SOC 2 Type II is on the roadmap and not yet complete — ask for the current status rather than assuming it

spend.by-feature

# attribution follows the request, not the invoice
onboarding-agent  $4,120
support-summary   $2,884
search-rerank     $1,902
doc-extraction      $744
internal-evals      $318

Billing mechanics

What counts as a request, and what does not.

Rate

$0.20 per 1,000 routed queries

Metered, no seats, no minimum. Volume rates below that are part of a custom plan. The pricing page has both in full.

Billable

One inbound call, classified and routed

A cache hit is not billed. An automatic escalation to a stronger model counts as one request, not two — you should not pay us more for our own miss.

Provider costs

Passed through at cost

On both plans. Bring your own provider keys and you are billed by the provider exactly as you are today, so committed-spend discounts keep applying and Alphe never touches that invoice.

Status

What is not here yet.

Alphe is in private early access as of August 2026. There is no self-serve signup, so an API key comes from a conversation rather than a dashboard. There is no endpoint-by-endpoint API reference either: the wire format is OpenAI's, so your SDK already documents the request and response shapes, and a full reference lands at general availability. SOC 2 Type II and the packaged self-hosted data plane are roadmap, not shipped. Everything else on this page describes the build that runs today. If a number here matters to a decision you are making, write to hello@alpheai.com and ask what it is this week.

Questions

The eight an integrator asks first.

The base URL and the API key. Point your OpenAI or Anthropic client at https://api.alpheai.com/v1, send model: "auto", and leave the rest of the call exactly as it is. Streaming, tool calls, structured output and vision pass through unchanged.

Keys are issued during early access; there is no self-serve signup yet. Ask at hello@alpheai.com or through the contact form, and you get a key and a shadow configuration back.

Yes. Every call carries a decision record — task class, reasoning depth, context length, the quality bar it had to clear, the model chosen, the models rejected, the reason, and the dollars saved against your previous pin. It is attached to the trace, so a bad route is explainable after the fact rather than only at the time.

The output is scored against the endpoint's rubric before it is returned. A miss escalates to a stronger model automatically, under the same request id, and the escalation is logged. The routing table learns from it, so the same class of request does not miss twice. An escalation counts as one billable request, not two.

About 4 ms to classify and under 8 ms of gateway overhead in total, measured on-path and in-region. These are indicative figures for a pre-launch product, not a published SLA.

Yes. The proxy is a single binary and runs self-hosted or in your own VPC, with the control plane hosted. Regional pinning and data-residency guarantees are part of the custom plan.

The SDK falls back to your provider directly on a configurable timeout, so the gateway cannot become a single point of failure for your product. Self-hosted deployments serve traffic without depending on our control plane.

Not yet. Alphe is OpenAI wire-compatible, so the request and response shapes are the ones your SDK already implements. A complete endpoint-by-endpoint reference lands at general availability; until then this page, /agents.md and hello@alpheai.com are the documentation.

For agents

This site is readable as Markdown.

Every page here answers Accept: text/markdown with Markdown at the same URL, sets Vary: Accept, honours q-values and returns 406 for an Accept it cannot satisfy. Append index.md to any path to get the same file directly. /agents.md is the instruction file: when to use Alphe, when not to, and how to call it. /llms.txt indexes the site, /llms-full.txt is every page's text in one file, and /sitemap.xml lists every indexable URL.

Get a key and a shadow endpoint.

Ten minutes of work on your side, and nothing about your production request path changes.

One base URL, and the rest is your code.