IronStratum Get an API key

The LLM API catalog: ten 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 ten open-weight chat models from seven publishers behind one OpenAI-compatible endpoint, all billed per token out of a prepaid wallet, each with a model page that carries the details that decide a purchase, from thinking control to the exact context window.

Last verified: 2026-09-11

Two things this page deliberately does not carry. It carries no prices: rates render on the pricing page from the platform registry, the same file 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, and returns a completion. The industry has largely settled on one request shape for this, the OpenAI chat-completions format, to the point where 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, and it is 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 (what you send), cached input tokens (prefixes the platform has seen before, billed below fresh input), and output tokens (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: ten models from seven 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, 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, while 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, which 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 and improved through reinforcement learning on its own attempts, on a lineage built from Qwen3.5 and Gemma 4. The 35B mixture and the 9B dense build are both MIT-licensed, and 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 that 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 and reroutes the pro name from September 14, while the public weights stay public. Gemma 4 31B is Google DeepMind's dense Apache 2.0 reasoning model with text and image input and a configurable thinking mode. All four landed as serving rows on September 11, 2026, and their pricing went live with them.

Availability, stated plainly. The registry is the platform's availability truth, and the catalog listing on this page renders each row's current state from it. Rows here range from models answering calls on the chat endpoint today to the two self-hosted Ornith lanes, wired and verified behind the fleet-start wave. No blanket claim covers the set; every model page states its own posture 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, and how you control that differs by family in ways that affect both quality and cost.

  1. A per-request knob. Several lanes take a reasoning_effort parameter with graded values, from a setting that skips the reasoning pass to settings that lean into it. Send the knob, the platform translates it to whatever the upstream model actually reads, and sending the model's native spelling yourself returns a named parameter error.
  2. A phrase in the system prompt. Muse Glimmer's card defines its official control as a line in the system prompt, 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.
  3. 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, which 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 registry rates, and returns the charge in the response, so 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 operating habits that keep a metered workload predictable.

Running the weights yourself

Every model here is open-weight, so the honest page has to include the local option. The licenses mostly encourage it: nine of the ten models ship under Apache 2.0 or MIT, and 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, and 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, traffic is steady enough to justify the hardware, the data cannot leave machines you govern, or fine-tuning is the goal. Use the hosted lane when calls arrive in bursts or only now and then, 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

  1. 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.
  2. Create an API key. A key is its own revocation boundary, so splitting projects across keys keeps a leak contained to one of them.
  3. 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, and parsing lanes beyond this page.

The catalog table

Chat and reasoning models — context window, price per million tokens in and out and cached, capabilities
ModelContext$/1M in$/1M out$/1M cached inCapabilities
qwen3.8-27b262,1440.352.550.105thinking · streaming
qwen3.6-35b131,0720.110.800.044thinking · streaming
minimax-m2.7196,6080.240.950.072streaming
muse-glimmer-30b131,0720.281.200.084streaming
glm-5.3-flash1,048,5760.110.350.033streaming
deepseek-v4-flash-07311,310,7200.150.420.045streaming
gemma-4-31b-it262,1440.220.490.066streaming
deepseek-v4-pro1,000,0001.132.210.339streaming

Token prices per 1M unless the unit says otherwise; a dash means the value isn't set yet — confirmed when the model goes live. 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, because 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, and current rates for all ten models 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, which carry rate limits and sometimes data-use terms; temporary trial credits, which suit evaluation rather than production; and local inference, which 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, because models differ most on the things that decide fit, long-context handling, instruction following, and tool calling. Commenters also treat the OpenAI-compatible request shape as the practical standard, which keeps switching costs low. That is how this catalog is meant to be used: one OpenAI-compatible endpoint, ten 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, while the MiniMax M2.7 weights are free for non-commercial use but need written authorization from MiniMax for commercial use, and 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?
No, and the page does not pretend otherwise. The catalog mixes models that answer calls on the platform's chat endpoint with the two self-hosted Ornith lanes, which are wired and verified behind the fleet-start wave. The catalog listing on this page renders each model's current state from the platform registry, and every model page states its own posture exactly: what serves now, what is waiting on hardware, and what that state means for a buyer. In the current invite-only beta, an account in place is ready the day a new row goes live; access comes through the console's invite flow.