The model index: every lane on one metered API
This page is the index of the platform's whole offering: twenty-one model entries across six lanes, chat, text to speech, speech to text, embeddings, rerank, as well as document parsing, all behind one OpenAI-compatible gateway, one console, and one prepaid wallet. Every entry links to its own page with the measured numbers and the copy-paste request. What this index adds over a plain list is the state of each row: what answers traffic, what is wired but waiting on hardware, what is staged, what is announced, what was dropped, and what is only an evaluation.
Last verified: 2026-09-11
This page leaves two things out on purpose. Rates: each one renders on the pricing page, out of the model registry, which is the same file the gateway meters against, so a figure typed into prose here could only go stale. Per-model spec tables: the listing is built by the machine layer, and each model page owns its own working contract. The map starts with the product itself.
What an AI model API is
Concretely: an HTTP service that takes a request naming a model, runs it, and returns the output plus a usage record. For chat, the settled request shape is the one in OpenAI's chat completions reference: name a model, send a messages array, receive a completion with a usage object. That shape has become the practical standard across hosted providers and local runtimes alike, which is why an integration usually moves between hosts by changing two strings, the endpoint base URL and the model name.
The part every index owes you and most skip: what a call is metered in, and whether the row actually answers calls. Token prices tell you nothing about a speech lane billed by the character or a transcription lane billed by the minute of audio. And an index that lists everything as online, when several of its rows answer nothing today, is not a map. This one names the unit for each lane below and states each row's state in a fixed vocabulary, because those two facts decide budget and build order more than any leaderboard row.
The catalog: six lanes
Chat
The chat lane holds ten open-weight models from seven publishers on one chat completions route. Eight of them are serving now. Qwen 3.8 27B, the dense one, takes images and video alongside text and ships with per-request thinking control, according to the official card. Sparse Qwen3.6-35B-A3B carries the throughput load for agentic coding. Muse Glimmer 30B builds failure recovery into the model itself, exactly what an unattended agent wants. MiniMax M2.7 is built for long tool-calling chains. And the Ornith 1.5 35B and 9B pair, from a family that generates its own training tasks, runs on GPU seats this platform operates itself; the pair is wired and verified, stopped pending the fleet-start wave.
Four more joined them as serving rows on September 11, 2026: GLM 5.3 Flash, a sparse multimodal build from Z.ai; the general-availability snapshots DeepSeek V4 Flash 0731 and DeepSeek V4 Pro; and Gemma 4 31B, Google's dense reasoning model. Their pricing went live with their rows; the announced class stays in the vocabulary below for names published ahead of a landing.
Text to speech
The speech lane is four open-weight models on one speech route, all billed by the character. Kokoro handles steady narration at volume. Chatterbox covers character voices and short-form expressive work. Pocket TTS is a compact build that runs on laptop CPUs, which also makes it the portable one. Audio8 TTS rounds out the set with multilingual reach. All four are wired into the gateway and measured on their lanes; the card that serves them is stopped pending the fleet-start wave, so their pages describe capability and measured limits rather than traffic.
Speech to text
The transcription lane currently holds one wired entry and one dropped row. Hayamimi STT is the batch transcription model: recorded audio in, text out, billed by audio time. It sits on the same stopped card as the speech lane. VASR streaming is the live-streaming entry, built around voice activity and speaker labeling; its catalog row is dropped right now, for reasons and restore conditions stated in the state section below.
Embeddings
The embeddings lane turns text into vectors for semantic search, retrieval, and classification. Its engine is BGE M3, an open multilingual embedding model, metered by the token. The lane is wired and verified with the rest of the specialty card, stopped pending the same fleet-start wave.
Rerank
The rerank lane scores a retrieved shortlist against a query with a cross-encoder and returns it reordered by relevance. Its engine is BGE Reranker v2 M3, metered one search per request. It is wired and verified, on the same stopped card.
Document parsing
The parsing lane turns page images, scans, and PDFs into text a program can use, and it is the youngest lane. PP-OCR print is the volume text-out route for machine-printed pages. Archival OCR is the fidelity route for old print, with a flag that keeps original spelling and typography. GLM-OCR parse mode is the structured route, parsing documents to Markdown; its registry row sits staged under the machine alias glm-ocr, priced on the token axis, and flips on with its wiring wave. All three parsing rows sit staged in the registry; none answers traffic today.
The state vocabulary
One word per row class, and the registry decides which word applies. The listing table on this page renders from the registry, so the words below describe classes, not a frozen snapshot.
| State | What it means | Where it applies |
|---|---|---|
| Serving | The row answers calls on its route today | Eight chat rows: the two Qwen routes, MiniMax M2.7, Muse Glimmer 30B, GLM 5.3 Flash, DeepSeek V4 Flash 0731, Gemma 4 31B, DeepSeek V4 Pro |
| Wired, card stopped | Built and wired through the gateway, verified there; the serving card is stopped pending the fleet-start wave | Nine rows: the two self-hosted Ornith chat lanes plus the seven specialty rows across speech, batch transcription, embeddings, and rerank |
| Staged | The row sits in the catalog staged; its wiring wave flips it on | Three rows: the two OCR parsing rows and the GLM-OCR parse-mode row (machine alias glm-ocr) |
| Announced | The name is published; the row lands through a wiring pass, and its pricing arrives with it | No rows today; the class is held for names published ahead of a landing |
| Dropped | The row was removed and returns only under named conditions | The VASR streaming entry |
| Evaluated, no row | A written evaluation exists; nothing is callable and no rate exists | No rows today; the class is held for evaluations with nothing callable |
Three of those classes deserve their honest detail. The self-hosted cards that run nine of these rows, two Ornith chat cards and the specialty card, are stopped while the platform's fleet rolls out; the lanes are built, wired, and measured, and their pages say what each one does and what its measured limits are, without claiming traffic. The September four, GLM 5.3 Flash, DeepSeek V4 Flash 0731, Gemma 4 31B, and DeepSeek V4 Pro, landed as serving rows on September 11, 2026, pricing included; the announced class is empty today and keeps its law for the names that use it next: no dates, anywhere, because a date nobody can keep is worse than silence, and pricing publishes the day a row lands. And the VASR streaming row is dropped for cause: the current checkpoint emits no per-speaker output fields, misattributes in-text speaker markers, and the streaming edge caps connections at roughly 220 seconds. It returns only when all three are fixed: a checkpoint with real per-speaker output, a passing three-speaker end-to-end case with correct attribution, and that edge cap resolved or chunked sessions built. The streaming route itself exists on the gateway; no row answers it.
Why publish a vocabulary at all? Because the failure mode of model indexes is silence: rows vanish, deprecation arrives as a surprise, and every entry lists as online regardless of truth. Buyers notice. This platform states what a row is so you can plan around it, which is also why every model page repeats its own state in the same words.
One key, one wallet, every route
The routes, at the level an index needs:
| Lane | Route | Metered in |
|---|---|---|
| Chat | POST /v1/chat/completions | Tokens: input, cached input, output |
| Text to speech | POST /v1/audio/speech | Characters of input |
| Speech to text | POST /v1/audio/transcriptions | Audio time processed |
| Embeddings | POST /v1/embeddings | Tokens |
| Rerank | POST /v1/rerank | Searches, one per request |
| Parsing | POST /v1/ocr | Pages |
One Bearer key from the console reaches all of them, and a read of the voice catalog costs nothing. Every completed call reports its own charge, so a workload's cost shows up request by request instead of on an invoice. The wallet runs on prepaid credit, and the balance acts as the ceiling: once it reads zero, the next call is turned away with a named error, and nothing is billed for it; anything the gateway rejects ahead of relay never touches the wallet either. The stop reads the balance when a call arrives, not the cost of the call, so the last request that lands on a nearly empty wallet can finish slightly overdrawn, an edge the pricing page publishes.
Keys are revocation boundaries. Splitting projects across keys contains any leak to a single key, and one key's revocation leaves the others and the wallet untouched. Per-key spending caps are on the roadmap and are not a shipped feature; the loaded balance is today's ceiling. The bill-shock guide named in the block below collects the habits that keep metered budgets predictable across all six lanes.
How to use this index
- Name the job, then follow the lane. Each lane paragraph above links its category page, which carries the deeper map for that family, and every model page ships its three code tabs, curl, Python, and OpenAI SDK, ready for your key.
- Check the state before you commit a build. The vocabulary above is the same on every page in this catalog. If the row you need is serving, the model page's tabs work today. If it is anything else, the state word tells you exactly what exists: a wired lane, a staged row, a published name, or an evaluation.
- Read rates once, on the pricing page. Rates render there from the registry for every row that has one, and a change appears there first. Counts here are dated facts: twenty-one entries is the last-verified figure, and the registry, not this page, adds rows.
- Moving an existing integration. The chat lane speaks the OpenAI-compatible shape, so the port is two edited strings and a test run. The OpenAI-compatible API guide, one of the two named below, walks that port from the first tab to the last.
Getting started
- Use the console's invite flow to get in. That gate holds while the beta runs; the console holds the wallet, issues keys, and keeps the spend history, and an account created today stands ready for every wave that lands.
- Create a key. One key per project keeps revocation surgical.
- Make the first call from a model page. Pick your lane above, open the model page that matches the job, and run its curl tab. For lanes on the stopped card, the account and key are what you set up now; the wave that starts the card is what turns them on.
The registry is the machine truth under all of it: it drives the listing table on this page, the rates the pricing page renders, plus the units the gateway meters. The words on this page are the human layer over that machine layer, written to stay true to it.