Uncensored Kimi K3 API

Most model-selection guides are written as if capability were free. It is not. The interesting question about a top-tier model is never "is it better" — it usually is — but "is it enough better, on this task, to justify a bill five times larger than the model one rung down." This guide answers that with real arithmetic, and says plainly where the cheaper options win.

01What Kimi K3 actually is

Kimi K3 is Moonshot AI's open-weights flagship, released July 2026 under the Kimi K3 License — the third generation of a lineage that began with Kimi K2, and a genuinely new architecture rather than a fine-tune.

The published layout is 93 layers — 69 using Kimi Delta Attention, 24 using gated multi-head latent attention, one dense — with a Stable LatentMoE router selecting 16 of 896 experts per token plus 2 shared. Moonshot reports roughly a 2.5x improvement in scaling efficiency over Kimi K2 from that combination. Vision is native rather than bolted on: a 401M-parameter MoonViT-V2 encoder feeds the same trunk that handles text.

The sparsity number is worth internalizing: K3 activates 104 billion parameters per token, against the 30-to-40-billion range for most of our catalog. That is roughly three times the arithmetic per token generated, and it is the entire reason this model tops the price list. You are not paying for a brand tier — you are paying for GPU-seconds.

The lineage, briefly

• Kimi K2 — 1 trillion parameters, 32 billion active, 384 experts with 8 routed per token, pre-trained on 15.5 trillion tokens using the MuonClip optimizer, built to stop the attention blow-ups that wreck MoE training at that scale.
• Kimi K2 Thinking — the same foundation taught to interleave reasoning with tool use, reported sustaining 200 to 300 sequential tool calls in one run, with 44.9% on Humanity's Last Exam with tools and 60.2% on BrowseComp.
• Kimi K3 — rebuilt with native multimodality and a 1M-token window upstream, with quantization-aware training from the supervised fine-tuning stage onward (MXFP4 weights, MXFP8 activations). That is why K3 tolerates aggressive compression better than models never trained with it in mind.

The through-line is long-horizon agency: every generation was optimized for staying coherent across hundreds of steps rather than for winning short-answer benchmarks. That is the capability you are buying.

02What "3BIT-REAP" means, and why a 2.8T model needs it

The suffix on the model id is not decoration — it says what was done to the weights before they were loaded onto our own GPU cluster, and it is the honest caveat attached to every claim here. Start with the arithmetic. A 2.8-trillion-parameter model at 16-bit precision is about 5.6 terabytes of weights. At 3 bits per weight it is closer to 1.05 terabytes — still large, but a tractable deployment with room left for a 262K-token KV cache. REAP is the second half: an expert-pruning method that profiles which experts the router actually reaches for and drops the rarely-selected ones before quantizing rather than after. On a model routing only 16 of 896 experts per token that is a natural fit — a distribution that sparse has a long tail contributing very little to real traffic — and pruning first means the remaining bit budget is spent on experts that matter.

Our catalog uses three suffixes as a deliberate ladder. 3BIT-REAP goes on the largest foundations, where nothing else fits. W4A16-AUTOROUND-REAP is 4-bit weights with 16-bit activations quantized using AutoRound — learned rounding that recovers real accuracy over naive round-to-nearest — plus the same pruning. W8A16 is the highest-fidelity tier, for foundations small enough not to need aggressive compression. In short: the suffix tells you how much of the original survived; the price tells you what it costs to run.

03Vision: what image understanding buys you

Kimi-K3 is one of five models in our twelve-model catalog with vision, and the most capable of the five. Most commercial vision APIs run a classifier over uploaded images and refuse a broad category of inputs before the model ever sees them — a reasonable consumer default and a serious obstacle to legitimate work. Security researchers screenshotting exploit output, moderation teams building their own classifiers, forensic and dataset-audit work, and red-team evaluation all hit that wall. Kimi-K3 has no refusal layer and no filtering on output.

Where K3's vision earns its price over cheaper vision models

• Dense diagrams and schematics — architecture diagrams, network topologies, circuits: anything where the answer depends on following lines and labels rather than naming objects.
• Small text in screenshots — stack traces, terminal output, spreadsheet cells. The gap between vision tiers is widest on legibility at small scale.
• Image inside long text — a screenshot dropped into a 200K-token context, where the model must relate what it sees to what it read fifty thousand tokens earlier.
• Multi-image comparison — two versions of a UI, or a chart against the table that generated it.

Where it does not earn its price: captioning, alt text, OCR of clean documents, and tagging pipelines. Those are solved at $0.50 per million input tokens — if your image workload is high-volume and each item individually simple, Kimi-K2.6 or MiniMax-M3 produce answers you will not distinguish from K3's.

Images consume tokens from the same 262,144-token budget as text and bill at the input rate. A handful of high-resolution screenshots is not free.

04Long-horizon agentic work — what this tier is for

If one workload justifies the top tier, this is it. Short tasks fail forgivingly: the model gets it wrong, you notice, you retry, you have lost four seconds. A forty-turn agent that takes a wrong branch at turn six spends the next thirty-four turns building elaborately on a mistake, and you find out at the end having paid for every token in between. That asymmetry is why per-token price is close to the wrong metric here. What matters is cost per successful completion, dominated by how often a run gets thrown away. Moonshot's published figures for the K3 foundation on agentic benchmarks:

All figures are Moonshot-reported for the unquantized Kimi K3 foundation, July 2026. They are not measurements of our 3BIT-REAP build and we do not present them as such.

The shape matches what the architecture was built for: BrowseComp and Terminal-Bench are tool-loop benchmarks — repeated cycles of act, observe, revise. SWE Marathon at 42.0 is the counterweight: the hardest long-horizon coding evaluation in the set, where even a frontier model fails most tasks. "Agentic" is not a solved category; design for failure whichever model you pick.

Practical settings for long runs

K3 exposes reasoning_effort, and here it is a real cost lever: reasoning tokens bill as output tokens, at $19.12 per million.

• Low — tool-call routing and structured extraction, where the model chooses between a handful of known options.
• High — the default for real agentic work: planning a multi-step change, debugging from a stack trace, reconciling contradictory sources.
• Max — reserve it for the hardest single call in a pipeline: the plan at the top of a run, or the final review. A run spending 30K reasoning tokens at high and 90K at max pays an extra $1.15 for that one flag.

Budget context deliberately too: our window is 262,144 tokens with a 16,384-token maximum output, and at $3.83 per million input an unpruned history compounds — every turn re-bills the entire prefix.

05What "uncensored" means on this endpoint

Every model on the Shannon AI Gateway is served with no refusal layer and no content filtering on output. It matters more on the top tier, because the tasks people bring to a top-tier model are the likeliest to trip a filter: adversarial security research, offensive-tooling analysis, moderation-classifier development, threat intelligence, difficult fiction, and any evaluation requiring the model to produce the thing you are trying to detect.

• No output classifier. Responses are not scanned and rewritten or blocked after generation.
• No input gate. Prompts and images are not screened before they reach the model.
• Not a different model. This is the Kimi K3 foundation served without the layer that usually sits in front of it.
• Not a liability transfer. Removing a refusal layer moves the judgment call to you — see our responsible use policy.

There is a quieter benefit for anyone building evaluation systems: an unfiltered model is a stable baseline. A model that refuses unpredictably makes measurements noisy, because you cannot separate a capability limit from a policy limit. Here a failure is a capability failure — the only kind you can debug.

06The price: $3.83 in, $19.12 out — and when it earns it

This is the most expensive model on our list by a wide margin: output costs 9.6x our $2.00 floor and 5.2x what Kimi-K2.6 costs. Here is the arithmetic in the open.

Model	In / 1M	Out / 1M	Vision	JSON schema
Kimi-K3 · 3BIT-REAP	$3.83	$19.12	Yes	Yes
DeepSeek-V4-Pro-0813 · 3BIT-REAP	$1.95	$3.90	No	Yes
inkling · W4A16-AUTOROUND-REAP	$1.42	$6.07	Yes	No
Kimi-K2.6 · W4A16-AUTOROUND-REAP	$0.78	$3.67	Yes	Yes
GLM-5.2 · 3BIT-REAP	$0.73	$2.34	No	Yes
MiniMax-M3 · 3BIT-REAP	$0.50	$2.00	Yes	Yes
MiMo-V2.5 · W8A16	$0.50	$2.00	Yes	Yes

Selected rows, ordered by input price. All twelve models share the same 262,144-token context, 16,384-token maximum output, streaming, tool calling and reasoning_effort. Live capability flags are on the API documentation page.

Two worked examples

First, a 120,000-token input — a codebase dump, a regulatory filing — producing a 3,000-token analysis. Second, a forty-turn agent run: roughly 1.2M cumulative input tokens as context accumulates, 90,000 output tokens including reasoning.

Scenario	Kimi-K3	Kimi-K2.6	MiniMax-M3
120K in / 3K out	$0.517	$0.105	$0.066
40-turn agent run	$6.32	$1.27	$0.78

K3 costs about 4.9x Kimi-K2.6 on the document call. Fifty cents is nothing once; it is $517 a day at a thousand calls, against $105. On the agent run the delta is about $5. Now apply the only test that matters: if the task is worth an hour of an engineer's time at $100, K3 pays for itself the moment it raises first-pass success by five percentage points — and on genuinely hard long-horizon work the gap between tiers is usually larger. If the task is worth thirty seconds of anyone's time, the same $5 is indefensible.

07Kimi-K3 or a cheaper sibling?

The two Kimi models in our catalog are two rungs of one ladder rather than competitors. Kimi-K2.6 is quantized less aggressively — W4A16-AUTOROUND-REAP, 4-bit weights with learned rounding, against K3's 3-bit — on a smaller foundation. It has vision, JSON-schema output, the same context window, and costs about a fifth as much.

Task	Use	Why
Forty-turn autonomous agent	Kimi-K3	Failure compounds; plan quality at turn one decides the run
Repository-scale refactor	Kimi-K3	Needs the full context held coherently, not merely retrieved from
Dense diagrams, small screenshot text	Kimi-K3	Widest vision gap between tiers is legibility and spatial reasoning
Single-file edits, well specified	Kimi-K2.6	Bounded task, cheap retry, no measurable ceiling difference
Image captioning at volume	MiniMax-M3 / MiMo-V2.5	Solved at $0.50 in; K3 output is 9.6x for the same caption
Reasoning-heavy but text-only	DeepSeek-V4-Pro	$3.90 output against $19.12 — drop K3 if you do not need images

That last row is the most commonly missed saving. If your task does not involve images, check DeepSeek-V4-Pro first. It is also a 3BIT-REAP build on a large foundation, strong on hard reasoning, and its output costs $3.90 against K3's $19.12. Much of the traffic that reaches for the top tier is text-only reasoning served just as well one row down.

08Calling the uncensored Kimi K3 API

The model is exposed as Kimi-K3-3BIT-REAP on all three dialects, with streaming on each and no capability difference between them — only wire format: /v1/chat/completions (OpenAI-compatible), /v1/messages (Anthropic-compatible), and /v1/responses. A vision request with reasoning effort raised for a hard visual task:

curl https://shannon-ai.com/v1/chat/completions \
  -H "Authorization: Bearer $SHANNON_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Kimi-K3-3BIT-REAP",
    "reasoning_effort": "high",
    "max_tokens": 4096,
    "stream": true,
    "messages": [{
      "role": "user",
      "content": [
        { "type": "text",
          "text": "Trace the data path in this diagram and list every point where an untrusted input crosses a trust boundary." },
        { "type": "image_url",
          "image_url": { "url": "data:image/png;base64,..." } }
      ]
    }]
  }'

K3 supports both response_format and full json_schema, so you can constrain an agent's tool arguments or force a report into a fixed shape without post-hoc parsing. Tool calling is native and is the intended way to drive long runs. Parameters, authentication, rate limits and a live playground are on the API documentation page.

Three things that save money on day one

• Prune the prefix. Every turn re-bills the whole conversation at $3.83 per million; summarizing a 40-turn history into a 4K-token state object once saves more than most model swaps.
• Downscale images. Image tokens are input tokens; a 4K screenshot resized to something still legible gives the same answer for less.
• Route by difficulty. A cheap model on the routine turns, with K3 on the plan, the hard branch and the final review, is often 80% of the capability at 25% of the bill.

09Frequently asked questions

---

Foundation facts and benchmarks are Moonshot AI's published numbers for Kimi K3 and Kimi K2 and describe the unquantized upstream models; our build is a 3-bit REAP quantization and will differ. Prices, context and capability flags are Shannon AI's own, current as of September 5, 2026 — live values are always those returned by /v1/models. Sources: Kimi K3 model card · Kimi K3 repository · Kimi K2 Thinking.