The LLM API catalog: fifteen open-weight chat models on one OpenAI-compatible endpoint

An LLM API is a metered HTTP service that serves a large language model. Your application sends messages, the model returns generated text, and the host bills by the token. This page is that product's catalog on this platform. It covers fifteen open-weight chat models from ten publishers behind one OpenAI-compatible endpoint. All are billed per token out of a prepaid wallet. Each has a model page that carries the details that decide a purchase, from thinking control to the exact context window.

Last verified: 2026-09-25

Two things this page deliberately does not carry. It carries no prices. Rates render on the pricing page from the platform's own model data, the same source the metering reads, so a number here could only drift. And it carries no per-model spec tables: the catalog listing and the model pages own those. What follows is the map.

What an LLM API is

Concretely, a chat model API receives a request with a model id and a messages array. It returns a completion. The industry has largely settled on one request shape for this, the OpenAI chat-completions format. Most vendors and the major local runtimes expose servers compatible with it. That convergence is why an integration written against one host usually moves to another by changing a base URL and a model id. It is also the shape this platform's chat endpoint speaks: the standard fields, standard tool-calling shapes, streaming and non-streaming, and a Bearer key for auth.

Metering is the other half of the product. A call bills three kinds of tokens at their own rates. Input tokens are what you send. Cached input tokens are prefixes the platform has seen before, billed below fresh input. Output tokens are what the model writes. Every response reports the call's own charge in its usage object, so cost is visible per request rather than per invoice. The OpenAI-compatible API guide, named in the guides block below, walks the base-URL swap in detail.

The catalog: fifteen models from ten publishers

The families, in plain words.

Qwen, two lanes. The dense Qwen 3.8 27B is a vision-language model. Per its official card, it reads images and video, writes text, and ships with thinking on by default and controllable per request. The sparse Qwen3.6-35B-A3B is the throughput lane. It is a mixture-of-experts build tuned for agentic coding and repository-scale reasoning, also under Apache 2.0.

MiniMax M2.7. A large sparse mixture built for endurance: long coding sessions, long tool-calling chains, instruction stability over many turns. Its license stands apart in this catalog. Per the repository, the weights are free for non-commercial use under MIT-style terms. Commercial use needs MiniMax's prior written authorization.

Muse Glimmer 30B. Meta Superintelligence Lab's open agentic model. The card trains failure recovery directly into the model. When a tool call fails or returns something unexpected, it diagnoses and retries rather than halting. That is the behavior an always-on agent needs. It reads images alongside text.

Ornith 1.5, two scales. A self-improvement family. Per the release post, the model generated its own training tasks and scaffolds. It improved through reinforcement learning on its own attempts. The lineage is built from Qwen3.5 and Gemma 4. The 35B mixture and the 9B dense build are both MIT-licensed. The 9B is small enough for a single consumer card.

The September four. GLM 5.3 Flash from Z.ai is a 320 billion parameter mixture with 18 billion active per token. It takes text, images, and video into the same context. Z.ai's documentation is explicit that its thinking is forced and cannot be disabled. DeepSeek V4 Flash 0731 and DeepSeek V4 Pro are the open-weight general-availability snapshots of DeepSeek's flash and pro tiers. Per the official change log, the publisher retired the V4 Flash generation from its first-party API on September 10, 2026. It reroutes the pro name from September 14. The public weights stay public. Gemma 4 31B is Google DeepMind's dense Apache 2.0 reasoning model. It takes text and image input and has a configurable thinking mode. All four landed as serving rows on September 11, 2026, and their pricing went live with them.

Two flagships joined the list on September 25, 2026. GLM 5.3 is Z.ai's flagship itself, the big sibling of the Flash build above; DeepSeek V4.1 Flash is the successor snapshot to the 0731 lane. Both are live and both render on the public list.

The Jev decision trio. Jev fast, Jev causal, and Jev batch are decision models: choices in, scores out, on the same chat completions route as the rest of this catalog. They are live as of September 25, 2026. The classification page carries what the family is for.

Availability, stated plainly. The catalog listing on this page renders each row's current state from the platform's own model data. Every row here is live. The shared endpoint carries fifteen rows, including the two robot reasoning entries that listed on October 6. The two self-hosted Ornith lanes complete the set. Every model page states its own state exactly, and that page is the place to check before committing a workload.

Choosing by job

Deep agentic coding and terminal work. The dense Qwen 3.8 27B and MiniMax M2.7 are the built-for-it pair in the serving set, and the DeepSeek lanes, which landed as serving rows on September 11, 2026, target the same work.
Fast, low-cost generation at volume. The sparse routes: Qwen3.6-35B-A3B with the flash tier, GLM 5.3 Flash and DeepSeek V4 Flash 0731, all serving today.
Agents that must survive their own mistakes. Muse Glimmer 30B, for the failure-recovery training above.
Long-context reading. Windows in this catalog run from 100,000 tokens to the million-token class; each model page carries the exact number that governs its lane and who measured it.
Small, contained work on small budgets. Ornith 1.5 9B: quick answers to bounded problems, cheap to meter, and the same weights run on a home machine.
Image input. Qwen 3.8 27B, Muse Glimmer 30B, Gemma 4 31B, and GLM 5.3 Flash carry it in the serving set.

Thinking control: three patterns in one catalog

Most models in this catalog reason before they answer. How you control that differs by family in ways that affect both quality and cost.

A per-request knob. Several lanes take a reasoning_effort parameter with graded values. The values run from a setting that skips the reasoning pass to settings that lean into it. Send the knob and the platform translates it to whatever the model actually reads. Sending the model's native spelling yourself returns a named parameter error.
A phrase in the system prompt. Muse Glimmer's card defines its official control as a line in the system prompt. It is Reasoning strength: with a level, not a request field. Because it is ordinary prompt text, every host that hands system messages to the model honors it.
Always on. MiniMax M2.7 takes no thinking switch on this platform's contract, and GLM 5.3 Flash's forced thinking is documented above.

The cost connection: reasoning tokens are output tokens. A model that thinks at maximum depth by default spends output budget before the answer starts. That is why the knob, when a lane has one, is also a cost control. Each model page documents its own control exactly.

What a call costs here

No numbers on this page; the mechanism is the content. Every call meters input, cached input, and output tokens at the platform's rates and returns the charge in the response. A workload's cost is observable as it runs. The spend limit is structural. Calls draw from a prepaid wallet, and a call that arrives after the balance is gone is refused instead of going into debt. There are no trial credits to expire. A refill is what restarts the meter. Keys are revocation boundaries: an exposed key is disabled on its own, without touching the rest. Current rates for every serving row sit on the pricing page. How to avoid API bill shock, one of the guides named below, covers the habits that keep a metered workload predictable.

Running the weights yourself

Every model here is open-weight. The honest page has to include the local option. The licenses mostly encourage it. Most of these families ship under Apache 2.0 or MIT. The MiniMax license terms above are the one commercial-use checkpoint. The real constraints are hardware and time. A 9B dense model runs on a single consumer card. A 30B dense model wants the high-memory class. The large mixtures want either serious VRAM or aggressive quantization, at real quality cost on some families.

Run the weights locally when the machine exists and traffic is steady enough to justify the hardware. Run them locally when the data cannot leave machines you govern, or fine-tuning is the goal. Use a hosted lane when calls arrive in bursts or only now and then. Use it when the thought of owning runtime pins and quant picks is worse than a meter, or when the metering, the wallet stop, and key revocation are the point. The guide Ornith 1.5 locally (Ollama/GGUF) vs the hosted API, linked in the guides block, works one family's math end to end.

Getting started

Get access through the invite flow on the console. The platform is in invite-only beta; once the invite lands, the wallet and API keys are managed on the console.
Create an API key. A key is its own revocation boundary, so splitting projects across keys keeps a leak contained to one of them.
Pick a lane and make the first call. Open the model page for the job you have in mind and copy its curl tab; the examples run as written with your key exported. The models index maps the whole platform, including the speech, embedding, rerank, parsing, and image generation lanes beyond this page.

The catalog table

Chat and reasoning models — context window, price per million tokens in and out and cached, capabilities
Model	Context	$/1M in	$/1M out	$/1M cached in	Capabilities
qwen3.8-27b	262,144	0.35	2.55	0.105	thinking · streaming
qwen3.6-35b	131,072	0.11	0.80	0.044	thinking · streaming
minimax-m2.7	196,608	0.24	0.95	0.072	streaming
muse-glimmer-30b	131,072	0.28	1.20	0.084	streaming
glm-5.3-flash	1,048,576	0.11	0.35	0.033	streaming
deepseek-v4-flash-0731	1,310,720	0.15	0.42	0.045	streaming
gemma-4-31b-it	262,144	0.22	0.49	0.066	streaming
deepseek-v4-pro	1,000,000	1.13	2.21	0.339	streaming
deepseek-v4.1-flash	1,000,000	0.19	0.71	0.06	streaming
glm-5.3	1,000,000	1.32	4.25	0.40	streaming
jev-fast	512	0.03	0.00	—	streaming
jev-causal	512	0.03	0.00	—	streaming
jev-batch	512	0.03	0.00	—	streaming
deepseek-v4.1-flash-1017	1,048,576	0.16	0.65	0.003	streaming
molmo2-er	8,192	1.00	5.00	0.50	streaming
cosmos-reason2-2b	4,096	0.10	0.40	0.05	streaming

Token prices per 1M unless the unit says otherwise; a dash means the value isn't set. Everything here is served by the same API that bills you: GET /v1/models. The full list with model details lives on the model index.

Guides

Questions

How do I pick the most cost-effective LLM API?

There is no single answer. The model that costs least for one workload is rarely the one that costs least for another. Per-token rates decide cost at high volume. At low volume, a model that solves the task in one pass usually beats a cheaper one that needs retries. Every chat model on this platform meters per token from a prepaid wallet and returns the charge on each response. Current rates for every listed model sit on the pricing page. If cost is the deciding factor, start with the flash and small-active models listed there and run your own workload before standardizing.

Which LLM API costs least for coding?

For coding, the per-token rate is only half the bill. Coding agents retry: a model that fails a patch and forces a re-run can cost more than a stronger model that lands the fix the first time. The pattern that works, and the one developers converge on in practice, is to prototype on a strong reasoning model. Then test whether a cheaper one matches it on real tasks. This catalog holds both ends, from deep agentic coders to fast low-cost models, each with its own page, and the pricing page puts their rates side by side.

Are there any free LLM API options?

Free access exists elsewhere, mostly in three shapes. Permanent free tiers at some providers carry rate limits and sometimes data-use terms. Temporary trial credits suit evaluation rather than production. Local inference costs nothing per call after the hardware. This platform offers none of those. It runs an invite-only beta, and every call draws down a prepaid wallet. A call that arrives after the balance is gone is refused with a named error instead of quietly going into debt. If free is the requirement, the open weights on this page can be downloaded and run locally under each publisher's license.

What do developers on Reddit recommend when choosing an LLM API?

The advice repeats across provider-shopping threads: test two or three candidates on your own tasks instead of trusting rankings. Models differ most on the things that decide fit, which are long-context handling, instruction following, and tool calling. Commenters also treat the OpenAI-compatible request shape as the practical standard. That keeps switching costs low. That is how this catalog is meant to be used. One OpenAI-compatible endpoint, fifteen models, a metered route, and nothing that locks an integration to a single model id.

Should I run these models locally or use a hosted API?

Every model in this catalog ships open weights, so the local road is real. Licenses differ. Most of these families are Apache 2.0 or MIT. The MiniMax M2.7 weights are free for non-commercial use but need written authorization from MiniMax for commercial use. A hosted route makes you a customer of the host instead of a licensee of raw weights. The practical rule: run locally when you have the hardware, steady traffic, or a data boundary to hold. Use a hosted lane when calls come in bursts, when you want metering and revocable keys around the model, or when owning a serving stack is not the job.

Is every model on this page callable today?

Yes. Every row on this page is live as of October 6, 2026. The fifteen on the shared completions route include the two flagships from September 25 and the three Jev decision lanes. The two robot reasoning entries listed on October 6. The two self-hosted Ornith models stand apart. The catalog listing on this page renders each model's current state, and every model page states its own state exactly. In the current invite-only beta, access comes through the console's invite flow and a wallet top-up.