Inside Kimi K3 Max's : The New Best AI in July 2026

Inside Kimi K3 Max’s New Architecture: The New Best AI in July 2026

Foreword
This is not a typical article about Kimi V3 Max. It was crafted with Kimi V3 Max, building on a previous article on July 16th 2026 about Claude's internal mechanisms, just before Kimi's free servers went oerloaded. In addition, it includes explanatory visuals designed to help you understand how to get the most out of this extraordinary new LLM.
I have been working in data science for almost 20 years, and I have noticed something crucial in today's job market: those who truly master the language of machines are the ones who consistently stand out.
There are many ways to learn how to use LLMs, but we are all limited by our own cognitive biases and understanding. It is often difficult to know whether our mental model is accurate, or whether it will remain valid as the technology evolves. Unfortunately, there is no magic formula. Many people with only a superficial understanding of AI can achieve remarkable success, while others with a much deeper understanding may receive far less recognition.
Nevertheless, relying purely on chance is not a strategy. Just as mathematics provides optimal methods for solving complex problems, developing a rigorous understanding of LLMs gives you a systematic advantage. In a world where success can sometimes appear random or unfair, improving your understanding of how these models work significantly increases your chances of making better decisions, adapting more quickly, and creating greater value.
This is precisely why experts such as Andrej Karpathy, Ilya Sutskever, and Noam Shazeer are so highly respected. Their reputation comes not only from their ability to communicate complex ideas, but also from their deep, accurate, and enduring understanding of LLMs. Following their approach, seeking first principles, questioning assumptions, and continually refining one's mental models, is one of the most reliable paths to long-term success in the age of AI.

What Is Kimi K3 Max’s New Architecture and Why Does It Matter?
For years, working with open-weight models followed a familiar pattern: wait roughly six months after a proprietary frontier release, download whatever the open community had caught up to by then, and accept the compromise. Even the best open models trailed the frontier by a margin large enough to matter on hard problems.
Kimi K3 suggests a meaningful shift away from that paradigm. Rather than simply training a bigger model, Moonshot AI introduced mechanisms that change how information flows across a million-token sequence, how long an agent can sustain coherent autonomous work, and how a model perceives the results of its own actions. The result is a 2.8-trillion-parameter system with a one-million-token context window, native image and video understanding, and an always-on reasoning mode, the first open model to reach the 3T class, with full model weights scheduled for release by July 27, 2026.
A note on naming: at launch, Kimi K3 runs at max thinking effort by default, with low- and high-effort modes arriving in later updates. Benchmark tables and leaderboards therefore list it as “Kimi K3 (max)”, or simply “K3 Max.”
Three developments stand out:
• Kimi Delta Attention (KDA) and Attention Residuals (AttnRes), which re-engineer how information moves across sequence length and model depth.
• Max Thinking and long-horizon agency, an always-on reasoning mode trained to sustain multi-hour and multi-day autonomous runs.
• Vision in the Loop, native multimodality that closes the cycle between writing code and seeing what that code actually does.
Individually, each is impressive. Combined, they fundamentally change what experienced users can build on an open model.
Kimi Delta Attention and Attention Residuals: Efficiency That Buys Intelligence
One persistent challenge in scaling language models has been the cost of attention itself. Standard attention grows expensive as sequences lengthen, and at a one-million-token context, naive architectures simply do not decode fast enough to be useful. A second, quieter challenge lives in the model’s depth: classic residual connections accumulate every layer’s output uniformly, so signal and noise pile up together across dozens of layers.
Kimi K3 attacks both problems directly.
Kimi Delta Attention is a hybrid linear attention mechanism designed to move information efficiently across very long sequences. According to Moonshot AI, it enables up to 6.3× faster decoding in million-token contexts, the difference between a long-context model that is theoretically impressive and one that is practically usable. Attention Residuals take the complementary axis: instead of adding every layer’s output into the residual stream uniformly, AttnRes acts as a drop-in replacement for residual connections that selectively retrieves representations across depth. Moonshot reports roughly 25% higher training efficiency at under 2% additional compute.
Around these two mechanisms sits a heavily sparsified Mixture-of-Experts body. The Stable LatentMoE framework effectively activates only 16 of 896 experts per token, at which point routing and optimization become first-order engineering problems. Moonshot’s supporting cast of techniques reads like a systems paper in miniature: Quantile Balancing derives expert allocation directly from router-score quantiles (eliminating a sensitive balancing hyperparameter), Per-Head Muon optimizes attention heads independently, and a Sigmoid Tanh Unit (SiTU) plus Gated MLA tighten activation control and attention selectivity. Together with revised training and data recipes, these structural changes yield an approximate 2.5× improvement in overall scaling efficiency compared to Kimi K2, the model converts compute into intelligence more effectively, rather than merely consuming more of it.
The engineering discipline extends to deployment. From the SFT stage onward, K3 was trained quantization-aware with MXFP4 weights and MXFP8 activations for broad hardware compatibility, and Moonshot contributed a prefix-caching implementation for KDA to the vLLM community, the mechanism that lets the official API serve cache-hit input at $0.30 per million tokens with a cache hit rate above 90% in coding workloads.
Benefits:
Faster decoding at extreme context lengths. Roughly 2.5× more intelligence per unit of compute than the previous generation. Meaningfully cheaper training at negligible overhead. Broad hardware compatibility through quantization-aware training. Serving economics that make million-token agent sessions affordable in practice, not just in demos.

Max Thinking and the Long-Horizon Agent: From Chat Turns to Multi-Day Runs
Perhaps the most consequential innovation is philosophical. Most models treat reasoning as something that happens in the gap between a user’s message and the model’s reply. Kimi K3 Max treats reasoning as the default state: thinking mode is always on, the effort dial is pinned at maximum, and the model was trained specifically on long-horizon, challenging tasks with minimal human oversight.
The clearest evidence is the company Moonshot keeps in its case studies, autonomy runs measured in hours and days, not seconds:
• GPU kernel optimization (15 hours, nonstop). Given a production Triton implementation of AttnRes, K3 designed a novel two-phase kernel algorithm, fused kernels while preserving numerics, and cut forward+backward time from 283.6 ms to 114.4 ms. On related arenas it cut a DSA training kernel’s end-to-end time by 55.1%, wrote an MLA-512 kernel from scratch that reached 517.8 TFLOPS, over half of an NVIDIA H200’s theoretical BF16 peak, and cut a KDA kernel’s time by 73.6% on an alternative-vendor GPGPU where CUDA tuning experience does not transfer.
• A compiler from scratch. K3 developed MiniTriton, a compact Triton-like GPU compiler with its own tile-level IR over MLIR, optimization passes, and a PTX code-generation pipeline, matching or beating Triton on certain roofline benchmarks and sustaining end-to-end nanoGPT training with stable convergence.
• Chip design (48 hours, autonomous). Using open-source EDA tools on the Nangate 45nm library, K3 built, optimized, and verified a chip for a nano model based on its own architecture: within 4 mm², it closes timing at 100 MHz and sustains over 8,700 tokens/second of INT4 decode throughput in simulation. A chip built by a model, for a model.
• Computational research (about 2 hours). To reproduce the I–Love–Q universal relations in astrophysics, K3 reviewed and cross-validated 20+ papers, implemented the full numerical pipeline, evaluated 300+ equations of state, flagged inconsistencies in published formulas, and generated 3,000+ lines of Python plus an interactive dashboard, work that typically occupies an experienced researcher for one to two weeks.
There is also a strategic bet embedded here. Where much of the industry has responded to hard agentic problems with multi-agent orchestration and aggressive context compression, Moonshot pairs one agent with a one-million-token window and strong retrieval. On BrowseComp, a benchmark for long-horizon, high-difficulty information seeking, K3 scores a state-of-the-art 91.2, and 90.4 even when using the full window with no context management at all. Raw context, it turns out, is a serious alternative to elaborate context plumbing.
Common patterns:
Long-horizon coding sessions across massive repositories. Autonomous performance engineering (profile, rewrite, benchmark, repeat). From-scratch systems construction, compilers, emulators, hardware designs. Literature-to-code research reproduction. Single-agent deep research over hundreds of sources, with subagents reserved for fan-out tasks like the 20+-subagent gravitational-wave analysis of 391 GWTC-5 events. Goal Mode in Kimi Work, which lets the desktop agent run until the task is done.
One honest caveat accompanies all this autonomy: Moonshot explicitly warns that K3’s training emphasis on hard, long tasks makes it excessively proactive, it may make unexpected decisions on the user’s behalf when intent is ambiguous, and that the model is sensitive to its thinking history, so agent harnesses must pass prior thinking content back faithfully. Autonomy this strong needs boundaries; more on that in the practices below.

Vision in the Loop: A Native Eye on Its Own Work
Most “multimodal” pipelines behave like a text model with a vision accessory bolted on. Kimi K3 processes text, images, and video within the same model natively, and the practical consequence is not just better image captioning, but a closed feedback loop between action and perception.
Moonshot calls it vision in the loop: the model writes code, captures a live screenshot of the result, compares it against the intent, and refines, seeing and correcting its own work in real time. The flagship demo is a fully procedural, browser-based 3D open-world game built with Three.js, WebGPU, and GPU compute, complete with forests, a log-cabin village, snowy mountains, and dynamic weather. The same loop powers frontend work (K3 took the #1 spot on the Frontend Code Arena with 1,679 points, a 17-place jump from K2.6), CAD, and motion design, including a 3Blue1Brown-style animated explainer of its own architecture.

“Kimi K3 achieves true ‘vision in the loop’ by seamlessly iterating between code and live screenshots, instantly seeing and refining outputs.”
Moonshot AI, Kimi K3 Tech Blog, 2026

Several observations from the release are particularly noteworthy: the multimodality is genuinely native, so video understanding runs in the same model that writes the code; the loop extends from understanding to creation, K3 edited its own teaser video from 56 source clips, handling clip selection, motion-matched cuts, beat synchronization, and audio, work that typically takes an experienced editor one to two working days; and the vision benchmarks back the demos up, with K3 scoring 94.3 on MathVision and 91.1 on OmniDocBench. Vision here is not a side feature. It is the feedback mechanism that makes long autonomous runs self-correcting.
Better Collaboration Requires Better Workflows
These architectural improvements also change how humans should work with Kimi K3 Max. Experienced users are discovering that success depends less on writing the perfect prompt and more on designing the run: goals, context, boundaries, feedback, verification.
Instead of asking K3 Max to immediately produce output, a more effective process often looks like this:
1. Define the goal, and the boundaries.
2. Load the full context (the window can take it).
3. Plan before executing.
4. Execute with vision in the loop.
5. Verify independently.
6. Preserve the session.
This resembles professional engineering because it is professional engineering. The AI becomes a tireless contributor inside a structured process, one that can hold the whole problem in context and see its own output, rather than a black box expected to produce perfect work on the first attempt.

Practical Tips

1. Use the Full Context Window Instead of Chunking K3 Max’s million-token window and automatic prefix caching change the economics of context. Instead of building a RAG pipeline that retrieves fragments, paste the whole repository, the full specification, and the relevant logs, and let the model reason over everything. Repeated calls against the same long prefix hit the cache automatically (no cache IDs or TTLs to manage), which is how coding workloads see cache hit rates above 90% on the official API.

Example Prompt:
“Here is our entire monorepo (services, shared libraries, CI configs) plus the full text of our API specification v4.2, roughly 600K tokens in total. Do not summarize yet. First:
• Build a dependency map of the services that touch the billing domain
• Cross-check every endpoint in the spec against its actual implementation, listing any drift
• Identify every place a breaking change in the spec would propagate
• Produce a migration plan ordered by blast radius, smallest first
Only after the plan is complete, propose the first three concrete code changes. I will validate the plan before you touch any code.”

1. Put Vision in the Loop K3 Max can see what it builds. Give it screenshots, mockups, or recordings, and explicitly require it to look at its own output and iterate until the visual result matches, don’t accept “code-only” answers for visual work. Example Prompt: “Attached is a Figma export of our new dashboard (target.png). Build it as a responsive React + Tailwind page. Work in this loop:
   1. Implement your best first version.
   2. Render it and take a screenshot.
   3. Compare the screenshot against target.png region by region, layout, spacing, typography, color.
   4. List every visible discrepancy, fix them, and re-render.
   5. Repeat until no discrepancies remain, then do one final pass at mobile width. Show me the final screenshot alongside the target, plus a short changelog of what each iteration fixed.”
2. Match the Model Tier to the Task Moonshot’s lineup is explicitly tiered: K3 as the flagship ($3/$15 per million tokens, input/output), K2.7 Code as a specialized coding model ($0.95/$4), K2.6 as a general-purpose option ($0.95/$4), and a K2.7 Code HighSpeed variant pushing roughly 180 tokens/second. Route routine implementation down the tiers; reserve K3 Max for work where the reasoning depth pays for itself.

Example Prompt (routing logic for a gateway or orchestrator):
“You are a model router for our dev team. Classify each incoming task and assign a tier:
• Tier 1 (K2.6 / K2.7 Code): single-file edits, unit tests, refactors with clear specs, summarization, classification.
• Tier 2 (K3 Max): multi-service changes, ambiguous requirements, performance optimization, anything spanning more than ~3 files or requiring architectural judgment, any task where a wrong decision costs more than an hour of human time.
Output for each task: the tier, a one-line justification, and, for Tier 2, the boundaries the agent must stay within.”

1. Constrain the Agent’s Initiative K3 Max is deliberately trained to be proactive on hard problems, which means it will happily make judgment calls you didn’t ask for. If your application requires the agent to operate within well-defined limits, say so explicitly in the system prompt or AGENTS.md. Example Prompt (guardrails for an autonomous run): “You are running autonomously on the ‘payments-retry’ service. Hard rules, these override your own judgment: • Modify only files under /services/payments-retry and /shared/queue. Never touch /services/billing-core. • No new third-party dependencies without stopping to ask. • No schema migrations, no force-pushes, no changes to CI. • If a test fails for a reason unrelated to your change, stop and report instead of fixing it. • Every 30 minutes of work, write a checkpoint summary (what changed, why, current test status) to STATUS.md. Optimize the retry backoff logic to reduce duplicate-charge incidents. When uncertain between ‘safe’ and ‘clever’, choose safe and note the clever option in STATUS.md.”
2. Preserve Thinking History and Verify Before Trusting Two disciplines matter here. First, K3 was trained in preserved-thinking-history mode: your harness must pass prior thinking content back on every turn, and you should never switch another model’s session over to K3 mid-run (Moonshot recommends verified harnesses such as Kimi Code for exactly this reason). Second, independent verification is not optional: Artificial Analysis measured K3’s accuracy climbing from 33% to 46% on its Omniscience index while its hallucination rate also rose, from 39% to 51%, the model is more often right and more often confidently wrong at the same time. Build an independent check into every workflow that matters. Example Prompt (single-session verification loop): “Complete this task in three stages: Stage 1 (Solve): Write the data-migration script for moving user preferences from the v1 JSON blob to the normalized v2 tables. Stage 2 (Adversarial review): Now critique your own script as a skeptical reviewer who has never seen it. Identify at least 4 concrete failure modes: data-loss paths, encoding edge cases, idempotency violations (what happens if it runs twice?), and transaction/rollback gaps. Stage 3 (Prove): Fix every issue raised, then generate a verification suite: 10 test cases covering happy path, edge cases, and the failure modes from Stage 2, plus a dry-run mode that reports exactly what would change without writing anything. Finish with a one-paragraph diff summary: what Stage 1 got wrong and how Stage 3 fixes it.” Bonus: Combined Long-Horizon Workflow Prompt (Kimi Code / Goal Mode) For an overnight autonomous run that combines several practices at once: “Run this as a long-horizon task with checkpoints. Goal: reduce the p95 latency of our search endpoint from 850 ms to under 300 ms. • Explorer phase: Map the full request path (API → cache → query planner → storage) using the repo and the attached 24-hour trace logs. Use the full context window; do not sample. • Hypothesis phase: Produce a ranked list of bottlenecks, each with the evidence from the traces that implicates it. • Execution phase: Fix bottlenecks in ranked order. After each fix, run the benchmark suite and record the before/after p95 in STATUS.md. If a fix regresses anything, revert it and note why. • Vision phase: For any change touching the results UI, render before/after screenshots and verify the UI is pixel-identical except for timing overlays. • Boundaries: No dependency changes, no API contract changes, no edits outside /services/search. Stop and ask if the ranked list is exhausted before hitting the target. Continue until the goal is met or the bottleneck list is exhausted, then produce a final report with the per-fix latency waterfall.” A Broader Shift in the Open-Weight Frontier Taken together, Delta Attention, Max Thinking, and Vision in the Loop point toward a broader trend: the open-weight frontier is closing on the proprietary one. On GDPval-AA v2, real-world tasks across 44 occupations and 9 industries, Kimi K3 scores 1,668 Elo, third overall behind Claude Fable 5 (1,760) and GPT-5.6 Sol (1,748), and ahead of Claude Opus 4.8 (1,600). On AA-Briefcase, a private long-horizon knowledge-work evaluation, it ranks second (1,548), behind only Fable 5. On Artificial Analysis’s Intelligence Index it scores 57, on par with Opus 4.8 (56) and GPT-5.5, behind Fable 5 (60) and GPT-5.6 Sol (59), at an average of roughly $0.94 per task, about half the cost of Opus 4.8 ($1.80) and on par with GPT-5.6 Sol ($1.04). “Open source is no longer lagging six months behind Western closed-source models. Read that again, and think about what it all means.” Widely followed AI commentator, quoted by VentureBeat, 2026 The honesty matters as much as the headline numbers. Moonshot itself acknowledges a noticeable user-experience gap versus Fable 5 and GPT 5.6 Sol; the launch configuration supports only max reasoning effort, which makes simple queries slow; the benchmark suite mixes agent harnesses (KimiCode, Claude Code, Codex), so not every comparison is apples-to-apples; and the elevated hallucination rate means verification loops are a requirement, not a luxury. This is a frontier-class model with frontier-class caveats, that happens to be open. Future AI expertise may depend less on prompt engineering and more on run engineering: scoping goals, loading complete context, bounding an agent’s initiative, closing the visual feedback loop, and verifying independently. In that world, the most productive professionals won’t simply ask better questions. They will design better autonomous runs, and increasingly, they’ll design them on open models. Kimi Delta Attention and Attention Residuals buy the efficiency that makes a million-token, 2.8-trillion-parameter model practical. Max Thinking turns that efficiency into sustained, multi-day autonomous work. Vision in the Loop gives the whole system eyes on its own output. Together, they mark the moment the open frontier stopped being the cheaper alternative and started being a genuine peer.

Original article: https://www.fractal-apps.com/en/articles/035_inside_kimi

Sources
• Moonshot AI, “Kimi K3 Tech Blog: Open Frontier Intelligence” (July 2026), https://www.kimi.com/blog/kimi-k3
• VentureBeat, “China’s Moonshot AI releases Kimi K3, the largest open-source model ever, rivaling top U.S. systems” (July 17, 2026), https://venturebeat.com/technology/chinas-moonshot-ai-releases-kimi-k3-the-largest-open-source-model-ever-rivaling-top-u-s-systems
• The Decoder, “Kimi’s open model K3 nears GPT-5.6 Sol and Fable 5 while signaling the end of super cheap Chinese AI” (July 17, 2026), https://the-decoder.com/kimis-open-model-k3-nears-gpt-5-6-sol-and-fable-5-while-signaling-the-end-of-super-cheap-chinese-ai/
• Trending Topics, “Kimi K3 Is the China Shocker That Lifts Open-Weight Models to Frontier Level” (July 2026), https://www.trendingtopics.eu/kimi-k3-china-shocker/
• Kimi API Platform Documentation, Model List and Pricing, https://platform.kimi.com/docs/models
• OpenRouter, “Kimi K3, API Pricing & Providers”, https://openrouter.ai/moonshotai/kimi-k3
• Artificial Analysis, Independent Model Evaluations, https://artificialanalysis.ai/
• Hacker News, “Kimi K3 is now live”, community discussion (July 2026), https://news.ycombinator.com/item?id=48935342
• Moonshot AI on GitHub (open research: Kimi Delta Attention, Attention Residuals, model weights), https://github.com/moonshotai
• Kimi.ai (@Kimi_Moonshot), official announcements on X, https://x.com/Kimi_Moonshot