Uncensored Inkling Model API

Most of the twelve models on our gateway are text-only. Four are not, and among those four Inkling holds a specific position: the vision model you reach for when the picture is the hard part of the problem but the budget does not stretch to a flagship. This card covers where the foundation comes from, what the W4A16-AUTOROUND-REAP suffix did to it, what it will and will not do at the API surface, and — honestly — when a cheaper model in the same catalog is the better call.

01What is Inkling, and who built it?

Inkling is the first open-weights model from Thinking Machines Lab, published July 15, 2026. Unlike most releases positioned as "open," it shipped with full downloadable weights on Hugging Face and day-zero support in transformers, SGLang, vLLM, and llama.cpp — which is how it became runnable on infrastructure like ours at all. The headline numbers, from Thinking Machines' own release materials:

That is a sparse Mixture-of-Experts layout: 66 decoder layers at 6,144 hidden size, the first two dense, the remaining 64 carrying 256 routed experts plus 2 shared experts, with 6 routed experts active per token. Roughly 4% of the parameters fire on any given token — which is what makes a near-trillion-parameter model tractable to serve at all.

Two architectural choices are unusual enough to name. Attention is interleaved — 55 layers of sliding-window attention over a 512-token window against 11 global layers, in a 5:1 repeating pattern. And Inkling does not use RoPE: it uses a learned, input-dependent relative-position bias, alongside short causal convolutions on the key/value projections and the residual branches. Sebastian Raschka's architecture notes flag both as real departures from the standard 2026 recipe. Training used Muon for the large matrix parameters and Adam for the rest, then over 30 million asynchronous RL rollouts in post-training.

The point for an API consumer is not the trivia. It is that this is a frontier-scale, natively multimodal foundation trained on 45 trillion tokens spanning text, images, audio and video — not a text model with a vision adapter bolted on later. Images are encoded as 40×40 pixel patches through a four-layer hierarchical MLP patchifier and processed jointly with text in the same decoder. Visual understanding was in the pretraining objective.

02What does W4A16-AUTOROUND-REAP mean?

Three separate techniques are stacked in that suffix, and they do different jobs. Worth understanding, because the suffix is the single biggest difference between the model you call on our API and the checkpoint Thinking Machines published.

REAP — pruning the experts nobody routes to

REAP is Router-weighted Expert Activation Pruning, from Cerebras Research (arXiv 2510.13999, accepted to ICLR 2026). In an MoE with 256 experts per layer the router does not distribute work evenly: some experts are hit constantly, others fire rarely and contribute little when they do. REAP scores each expert on both the router's gate values and the expert's activation norms — an expert selected often but contributing small-magnitude updates matters less than its selection count implies — and drops the low-saliency ones in one shot, before quantization.

The reason we use pruning rather than the more fashionable expert merging is that the two diverge by task type. Merging looks competitive on discriminative benchmarks and falls apart on generative ones. REAP's authors report that pruning preserves quality better on exactly the workloads people buy an API for — code synthesis, tool calling, multi-turn reasoning — at compression ratios past 50%, across models from 20B to 1T parameters. Merging destroys the router's specialization; pruning leaves the surviving experts and the routing between them intact.

AutoRound — learning where to round

AutoRound is Intel's post-training quantization method (arXiv 2309.05516, published as SignRound). Naive quantization rounds each weight to the nearest representable 4-bit value — a reasonable default and a bad one at scale, because rounding errors are not independent and accumulate through a 66-layer stack. AutoRound treats the rounding decision as something to optimize: signed gradient descent jointly tunes rounding direction and weight clipping ranges over a couple hundred steps, borrowing the accuracy of quantization-aware training without retraining. Intel reports the largest gains at extreme low-bit settings and a competitive edge at INT4.

W4A16 — where the bits go

W4A16 is the numerical format: 4-bit weights, 16-bit activations. The weights — which dominate memory in a 975B model — shrink to roughly a quarter of a BF16 footprint, while the arithmetic stays at 16 bits. That split matters for a vision model specifically: activation-quantized schemes hurt exactly the fine-grained numerical work image understanding depends on — reading a small axis label, resolving a thin line in a diagram, separating two similar shades. Keeping activations at 16 bits costs bandwidth and buys back precision where a vision workload notices.

Stacked, the three give a model that fits and stays fast without the quality cliff of the aggressive 3BIT-REAP tier we use on the very largest foundations. That is the trade the price reflects.

03Vision: a no-refusal image analysis API

Inkling is one of four vision-capable models in our catalog, alongside Kimi-K3, Kimi-K2.6, and MiniMax-M3. The base model's published vision results, from Thinking Machines' release, are 73.3% on MMMU Pro (Standard 10) and 78.1% on CharXiv reasoning questions — rising to 82.0% when the model is allowed to run Python against the chart. Those are the lab's own figures for the unquantized checkpoint; treat them as the ceiling of the family, not a measurement of our build.

CharXiv is the one worth dwelling on, because it maps onto why people buy a vision API rather than an OCR service. It tests reasoning over scientific charts — reading a value off an axis, comparing two series, noticing a trend reverse. Not "what text is in this image" but "what does this figure claim, and does the claim hold." That is what justifies sending a picture to a 975B reasoning model instead of a small captioner.

Sending an image is ordinary OpenAI-compatible work — an image_url content part on /v1/chat/completions, an Anthropic-style image block on /v1/messages, or the equivalent on /v1/responses. All three dialects hit the same weights and all three stream; pick whichever your existing SDK already speaks. A worked example is in section 09.

The uncensored part matters more for vision than for text. A refusal layer on a vision endpoint is unusually blunt, because it typically classifies the image before the model has reasoned about the request. Legitimate work gets caught constantly: a wound photograph in a clinical-notes pipeline, a forensic screenshot in an incident write-up, a frame from a film being analyzed for a criticism piece, a medical scan, an image of a document that happens to contain a name. Inkling on our gateway has no such classifier in front of it. It looks at what you sent and answers the question you asked. That is the product.

04Structured output: response_format yes, json_schema no

This is the one place Inkling is less capable than most of the catalog, and it is better to plan for it than discover it in production.

Capability	inkling	Kimi-K2.6	MiMo-V2.5	Laguna-S-2.1
Vision (image input)	Yes	Yes	Yes	No
response_format	Yes	Yes	Yes	No
json_schema	No	Yes	Yes	No
Tool calling	Yes	Yes	Yes	Yes
Reasoning effort	Yes	Yes	Yes	Yes

response_format: {"type": "json_object"} works — you get syntactically valid JSON. What you do not get is grammar-constrained decoding against a schema you supply, where the sampler is physically prevented from emitting a token that violates your structure. Field names, enum membership, and required-key presence are the model's choice, not a guarantee.

Three ways to live with that, in ascending order of reliability:

1. Prompt the schema and validate. Put the schema in the system prompt as literal JSON, set response_format to json_object, and validate the response your side. Retry on validation failure with the validator's error message appended. Cheap, works, needs a retry budget.
2. Use a tool definition as the schema. Tool calling is supported, and a function's parameter definition is a JSON Schema. Declare a single tool named for the extraction you want, force it, and read the arguments. This is usually the strongest option on Inkling and it costs you nothing extra.
3. Split the job across two models. Have Inkling do the vision and reasoning in prose, then hand that prose to MiMo-V2.5-W8A16 at $0.50 / $2.00 with a real json_schema for the structuring pass. Two calls, but the second is cheap, deterministic in shape, and the model that needs to be smart is the one that saw the image.

Option 3 is the pattern we would recommend for any high-volume extraction pipeline. Pay the premium only for the step that needs it.

05What does the price premium buy?

At $1.42 in / $6.07 out per million tokens, Inkling sits deliberately in the middle of our catalog. Six of the twelve models are at the $0.50 / $2.00 floor. Kimi-K3 — the flagship, also vision-capable — is $3.83 / $19.12. Inkling is roughly three times the floor on output and roughly a third of the flagship.

Output price, USD per 1M tokens, Shannon AI Gateway list rates, September 2026. Bar width is proportional to price; longer is more expensive.

Here is the honest read on where that premium earns its keep — and where it does not.

Workload	Use Inkling?	Why
Chart / diagram reasoning	Yes	The published CharXiv and MMMU Pro figures are what this foundation is strongest at.
Screenshot-driven agents	Yes	Vision plus tool calling plus 262K of history in one model, no handoff.
Long documents with figures	Yes	Text and images share one decoder and one context window.
Plain text generation	No	Six models at $0.50 / $2.00 do this. You are paying for a vision path you never call.
Bulk schema extraction	No	No json_schema. MiMo-V2.5 is cheaper and constrained.
Absolute frontier ceiling	No	Kimi-K3 is the flagship. Pay the 3.1× if the ceiling is the constraint.
Cheapest possible vision	No	MiniMax-M3 has vision at $0.50 / $2.00. Start there, escalate if quality forces it.

Read that as a routing rule, not a ranking. Inkling is right for a narrower band of work than a marketing page would claim, and inside that band it is hard to beat on price. Outside it, we would rather sell you the cheaper model and keep you.

06The 262K context window, and what actually fits

All twelve models on the gateway are served with a 262,144-token input context and a 16,384-token maximum output per request. Uniform on purpose: context handling should never become a per-model branch in your code, and swapping inkling for MiniMax-M3 in a config file should not silently change what fits.

Note the gap against the published foundation: Thinking Machines documents Inkling at 1,048,576 tokens, and we serve a 262K slice of that. If you have a genuine million-token single-request workload, we are not the endpoint for it, and better you know before you build.

For scale at 262K: a 400-page technical PDF with its figures, a mid-sized codebase, several hours of transcript, or a long agentic session carrying dozens of tool results and a handful of screenshots — each fits in one request. On a vision model, remember images consume context too; a dense screenshot is not free, and a session that streams frames fills the window faster than a text-only one. The architecture suits this well: the 5:1 sliding-window-to-global pattern means most layers attend within a 512-token neighborhood, with global layers periodically pulling long-range structure back in.

07Reasoning effort: paying for thinking only when you need it

Inkling exposes controllable reasoning effort — one of the more useful knobs in the catalog. The upstream model accepts levels from none and minimal through low, medium, high, xhigh, up to max, surfaced on all three dialects through the standard reasoning_effort parameter.

{
  "model": "inkling-W4A16-AUTOROUND-REAP",
  "reasoning_effort": "low",
  "messages": [ ... ]
}

This is a cost lever with teeth, because reasoning tokens are billed as output tokens at $6.07 per million. Thinking Machines reports that on Terminal Bench 2.1 Inkling reaches scores comparable to Nemotron 3 Ultra at roughly a third of the tokens — token efficiency is a stated design goal of the effort system, not an accident.

In practice: run low or minimal for captioning, classification, and straightforward extraction, where the answer is in the image and no chain of inference is needed. Reserve high and above for chart reasoning, multi-step visual comparison, and agentic turns where a wrong intermediate step is expensive. Most teams never set the parameter at all, and leave a several-fold output-cost difference on the table.

08What "uncensored" means here — and what it does not

Concretely: we run this model with no refusal layer and no filtering on output. No classifier reads your prompt and decides whether the model may answer, and none reads the response before it streams. When the model is uncertain or lacks the knowledge, it says so — that is the model, not a policy. What you will not get is a reflexive decline on a topic a general-consumer product treats as off-limits.

For vision this is the whole value proposition. Image classifiers in front of vision APIs are imprecise, and the false-positive rate lands hardest on the professional work that most needs the capability: security research, clinical contexts, journalism and forensics, film and art criticism, moderation tooling that has to look at the thing it moderates. An endpoint that refuses on category cannot serve any of those reliably.

Two honest caveats. First, Thinking Machines publishes safety evaluations for their reference deployment — 78.0% on FORTRESS adversarial, 95.9% on FORTRESS benign, 98.6% on StrongREJECT. Those figures describe their stack with their guardrails in place. They do not describe ours, and we will not cite them as though they did. We removed the layer those numbers partly measure; that is the product, and the responsibility.

Second, "no refusal layer" is not "no rules." Shannon Lab LLC operates under a Responsible Use Policy and applicable US law. Removing a classifier shifts judgment to you, it does not delete it. If you are building on this, read the policy before you scale.

09Getting started

Same base URL, same key, three dialects. If your code already calls OpenAI, Anthropic, or the Responses API, changing the model string is usually the entire migration.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.shannon-ai.com/v1",
    api_key=SHANNON_API_KEY,
)

stream = client.chat.completions.create(
    model="inkling-W4A16-AUTOROUND-REAP",
    messages=[{"role": "user", "content": [
        {"type": "text", "text": "What does this figure actually show?"},
        {"type": "image_url", "image_url": {"url": image_data_url}},
    ]}],
    reasoning_effort="high",
    max_tokens=4000,
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="")

Full parameter reference, the /v1/messages and /v1/responses shapes, streaming event formats, and a live playground are in the API documentation. Model cards for the other eleven models are in Shannon Research.

Foundation figures are Thinking Machines Lab's published numbers for the unquantized Inkling checkpoint and describe the family ceiling, not our quantized build. Prices and capability flags are Shannon AI Gateway list values as of September 2026.

10Frequently asked questions

---

Sources: Thinking Machines Lab — Introducing Inkling · Hugging Face — Welcome Inkling · REAP the Experts (arXiv 2510.13999) · Optimize Weight Rounding via Signed Gradient Descent (arXiv 2309.05516) · Sebastian Raschka — Inkling architecture and benchmark notes. Foundation benchmarks are lab-reported for the unquantized checkpoint.