Medium Blog Writer — Research → Draft → Humanize → Publish-Ready Export

Turns a topic into a fully researched, humanized, publish-ready Medium post — not a single generic draft, but a managed pipeline with checkpoints you control at every stage.

What it does

1. Research — multi-source web research (10–15 sources by default, more on request), summarized for your approval before any writing starts.
2. Outline — a structured outline you can approve, edit, or send back before the draft is written.
3. Draft — a full-length post written section by section against the approved outline.
4. Humanize (mandatory) — every draft gets a dedicated pass that strips AI writing tells: no em-dashes, no "in today's fast-paced world"-style filler, no inflated significance, no robotic rule-of-three patterns.
5. Quality check — readability score, header structure, citation count, image placement, and basic SEO checks.
6. Plagiarism/AI-detection prep — splits the final draft into chunks sized for external checkers (Originality.ai, Copyleaks, etc.) so you can verify before publishing.
7. Export bundle — a clean Medium-ready Markdown file, a sourced references list, metadata (title, subtitle, tags, read time), and a QA report.

You stay in control

At every checkpoint (research, outline, final draft) you choose:

• Allow once — approve just this step
• Allow always — approve everything from here on, hands-off
• Edit — give feedback, it revises and re-shows you
• Deny — reject it and it redoes the stage

Configurable

Sample input → output

Input:

"Write a technical Medium post on the new Kimi K2.7 release, medium length, comprehensive research."

Output bundle:

Kimi K2.7 Code: The Benchmarks Behind the Hype

Moonshot's newest coding model beats Claude Opus 4.8 on one real benchmark, but still isn't catching GPT-5.5. Here's the full picture.

Source: kimi.com/resources/kimi-k2-7-code, official release page, June 2026

On June 12, 2026, Moonshot AI quietly dropped the weights for Kimi K2.7 Code on Hugging Face. No keynote, no countdown timer, just a model card and a benchmark table. That's become Moonshot's style, and it's part of why the Kimi line keeps showing up in serious coding workflows instead of just demo videos.

K2.7 Code is built on top of K2.6, and it's pitched as Moonshot's strongest coding model yet. It is. But "strongest coding model Moonshot has shipped" and "state of the art" are two different claims, and the gap between them is exactly the part most of the launch coverage skipped past. So let's go through what this thing actually is, what the benchmarks actually show, how you'd actually run it, and where it lands in a field that's gotten brutally crowded. This is the long version, with every number traced back to where it came from, including the official charts straight from Moonshot's own announcement and from a competing lab's, so you can see for yourself instead of trusting a paraphrase.

For anyone who hasn't been tracking the line: this is the fifth major Kimi K2 release in roughly a year, after K2, K2 Thinking, K2.5, and K2.6. Each one has been an iteration rather than a reset, same MoE backbone, same general training recipe, with the gains coming from refinement rather than a new architecture. K2.7 Code keeps that pattern. It's the first release in the line aimed specifically at coding rather than general use, which is also why Moonshot is telling people to keep using K2.6 for anything that isn't code.

That split itself is part of a broader pattern worth naming. A year ago, "best coding model" and "best general-purpose model" from a given lab were usually the same checkpoint. That's stopped being true. OpenAI ships Codex-tuned variants alongside its general models, Anthropic's Claude Code product has its own optimization path distinct from the chat experience, and now Moonshot is doing the same split inside its own K2 line. The implicit argument from all three labs is the same: a model tuned hard for one job, agentic coding over long sessions, can outperform a generalist on that job even when the generalist has more raw capability. K2.7 Code is Moonshot's bet on that argument.

What Kimi K2.7 Code Actually Is

It's a coding-focused, agentic model, open-weighted under a Modified MIT license, and it's a fairly direct evolution of K2.6 rather than a ground-up rebuild. Here's the spec sheet, straight from the model card:

• 1 trillion total parameters, 32 billion activated (Mixture-of-Experts, 384 experts, 8 selected per token, 1 shared expert)
• 256K context window (262,144 tokens exactly)
• Multi-head Latent Attention (MLA), SwiGLU activations, 61 layers
• MoonViT vision encoder (400M params). Yes, it takes images and video, not just code and text
• Native INT4 quantization, the same approach Moonshot used for Kimi K2 Thinking
• 160K vocabulary size

The detail that actually matters day-to-day: thinking mode is mandatory. There's no instant/non-thinking switch. If you try to call it without thinking enabled through Kimi Code, it just routes you to K2.6 instead. Moonshot's reasoning seems to be that for a model this specialized, reasoning-first is the only mode worth shipping. Whether you'll like that depends entirely on whether you want a fast, cheap autocomplete model or a slower model that plans before it edits your files.

There's a second, less obvious detail tied to that: K2.7 Code forces preserve_thinking mode across every multi-turn interaction. In practice, that means the model's full chain of reasoning from a previous turn stays in context for the next one, rather than getting thrown away once it produces an answer. For a one-shot chat question, that's a minor implementation detail. For an agent looping through edit-run-check cycles across a long session, it's the difference between a model that remembers why it made a decision three tool calls ago and one that's quietly re-deriving its own logic from scratch every turn. If you've ever built an agent loop yourself, you already know how much that matters for keeping a multi-step task coherent.

Worth understanding, too, is what Moonshot is actually testing it against. The model card leans on three coding benchmarks and three agentic ones, and they're not interchangeable toys:

• Kimi Code Bench v2 is Moonshot's in-house benchmark, spanning 10+ programming languages and pulling tasks from real production incidents and open-source projects, weighted toward backend, infrastructure, performance, security, and ML/data engineering work.
• Program Bench is genuinely brutal: the agent gets an executable binary and its documentation, nothing else, no source, no decompilation, no internet, and has to rebuild the program from scratch in a language of its own choosing, then pass over 248,000 fuzz-generated behavioral tests comparing its output to the original.
• MLS Bench Lite is a 30-task subset testing whether a model can invent generalizable ML methods, not just implement known ones, with a 5-hour exploration window per task.
• Kimi Claw 24/7 Bench moves past single tasks entirely: 17 professional scenarios across 610 evaluation points, covering software engineering, ML research, recruiting, trading, and marketing, all run through the OpenClaw harness and averaged over three runs. This is the benchmark meant to simulate a model left running unattended for an extended stretch, not answering one prompt and stopping.
• MCP Atlas evaluates tool use through a 100-tool-call budget and a 32K max-token-per-step limit, scored as an average over three runs, which is closer to how an agent actually burns through a real task than a single graded response.

That's a meaningfully harder bar than the SWE-bench-style "fix this GitHub issue" tasks most coding leaderboards lean on.

The Benchmark Numbers, Without the Spin

Here's Moonshot's own comparison chart, pulled straight from their announcement:

Source: kimi.com/resources/kimi-k2-7-code, official release chart, June 2026

And the raw numbers, again straight from the model card, so you don't have to take anyone's word for it:

Two things jump out, and they pull in opposite directions.

First: the jump over K2.6 is real and not small. +21.8% on Kimi Code Bench v2, +31.5% on MLS Bench Lite, +11% on Program Bench. If you're already in the Kimi ecosystem, this is a genuine, no-asterisks upgrade. Notably, the gain is largest exactly where the task is hardest and least benchmark-gameable (MLS Bench Lite's "invent a method, don't just implement one" framing), which is a better signal than a flat across-the-board bump would be.

Second: it does not beat GPT-5.5 anywhere on this table, and it only beats Claude Opus 4.8 on one line: MCP Mark Verified, where it scores 81.1 against Opus's 76.4. Everywhere else, GPT-5.5 and Opus 4.8 are still ahead, sometimes by a wide margin (GPT-5.5 leads MCP Mark Verified by almost 12 points over K2.7 Code, and leads Program Bench by more than 15 points over both Kimi models).

That MCP Mark Verified result is worth sitting with for a second, because it's the most interesting line in the whole table. MCP Mark Verified tests tool use across five real server environments (Notion, GitHub, Postgres, Filesystem, Playwright), and it's human-verified, not just auto-graded, with results averaged over three runs. Beating Opus 4.8 there, specifically, says something about how well K2.7 Code handles the connective tissue of agentic coding: reading a ticket, touching the right files, running the right tool, checking the result. It's not winning on raw coding skill. It's winning on follow-through.

So no, this isn't "Kimi beats GPT and Claude." It's "Kimi closed most of the gap on coding and actually pulled ahead on one specific agentic skill that matters a lot in practice." That's a less exciting headline. It's also the true one.

Where It Actually Wins: Efficiency

The benchmark gains are nice. The efficiency story might matter more for anyone running this thing in production.

Source: kimi.com/resources/kimi-k2-7-code, official release chart, June 2026

Moonshot says K2.7 Code cuts thinking-token usage by roughly 30% compared to K2.6, while scoring higher on every benchmark above. That's the chart you actually want to stare at if you're paying per token. Reasoning models have a well-known overthinking problem: they'll spend two thousand tokens deliberating over something a junior engineer would just type out. A 30% cut in reasoning tokens, stacked on top of better scores, is the kind of unglamorous improvement that shows up directly in your API bill rather than in a launch tweet.

Put a number on it: if a typical multi-step coding task on K2.6 burned through, say, 15,000 reasoning tokens before producing a diff, the same task on K2.7 Code should land closer to 10,500, while getting the answer right more often. Multiply that across a CI pipeline running agentic checks on every pull request, or a long Kimi Claw session left running overnight, and the savings stop being a rounding error and start being a line item.

The pricing backs this up. Through the Kimi API, K2.7 Code runs $0.19 per million input tokens on a cache hit, $0.95 on a cache miss, and $4.00 per million output tokens, over that same 262,144-token context. Fewer reasoning tokens per task plus cheap per-token pricing is a combination that adds up fast across a real agentic workload, where a single task might burn through dozens of tool calls.

How to Actually Run It

This is the part most launch coverage skips, and it matters if you're deciding between the API and self-hosting.

If you'd rather use it through an actual coding agent instead of raw API calls, it now ships as the default model in Kimi Code, Moonshot's terminal-and-IDE coding agent:

Source: kimi.com/resources/kimi-k2-7-code, official release page, June 2026

Kimi Code's annual-billing plans start at $15/month (Moderato) and scale up to $159/month (Vivace) for teams that need bigger weekly quotas and higher concurrency. Monthly billing without the annual commitment runs a bit higher across the board, so check Moonshot's pricing page before you commit to a tier.

Self-hosting is the other path, and the model card lists vLLM, SGLang, and KTransformers as the supported engines, with deployment reusing whatever setup you already have for K2.5 or K2.6. The catch is hardware. This is a 1-trillion-parameter model, and even Moonshot's native INT4 quantization (the same scheme used for Kimi K2 Thinking) doesn't make it small. For a concrete sense of what "self-host this" actually costs in disk and memory, the community GGUF builds from Unsloth lay it out plainly:

Even the most aggressively quantized 1-bit build needs over 300GB of fast storage and a multi-GPU rig (or a serious unified-memory Mac Studio setup) to run at usable speed. This isn't a model you're loading on a single consumer GPU over a weekend. For the overwhelming majority of developers, the API or Kimi Code is the realistic path, and the self-hosting option exists mainly for labs, enterprises, and the genuinely hardware-rich.

It's Not Competing in a Vacuum

Here's the part that gets lost when every model launch gets covered as its own isolated event: 2026 has turned into the most competitive year the open-weight coding space has ever had. K2.7 Code isn't stepping into an empty ring, and the other entrants are shipping their own charts, too.

Take MiniMax M3, which landed less than two weeks before K2.7 Code, on June 1. It's the first open-weight model claiming all three of frontier coding, a 1M-token context window, and native multimodality at once, built on a new sparse-attention design MiniMax calls MSA. Here's their own release chart:

Source: minimax.io/blog/minimax-m3, official release post, June 2026

MiniMax reports 59.0% on SWE-Bench Pro for M3, ahead of the GPT-5.5 figure they cite (58.6%) and Gemini 3.1 Pro, though still behind Claude Opus 4.7 on their own table (note: MiniMax's published comparison uses Opus 4.7, not the newer 4.8, since 4.8 shipped the week before M3 and wasn't in their test window). All of that, like Moonshot's numbers, is vendor-reported on internal infrastructure, so treat the cross-lab comparisons as directional, not gospel.

The rest of the field moved just as fast. GLM-5.1, from Z.ai (formerly Zhipu AI), shipped back in April with a 754B MoE architecture under a fully permissive MIT license, and Z.ai's own developer docs claim a 58.4 on SWE-Bench Pro, ahead of GPT-5.4 and Claude Opus 4.6 at the time. Qwen3-Coder-Next has gone the opposite direction on size, chasing efficiency-per-active-parameter with an 80B-total MoE that activates only around 3B parameters and still lands respectable SWE-bench Verified scores, the kind of footprint that can plausibly run on a single beefy machine instead of a GPU cluster. DeepSeek V4-Pro remains the team people reach for when the job is LiveCodeBench-style raw coding or genuinely huge contexts.

None of those numbers come from the same controlled methodology as Moonshot's own table above, so take the cross-lab comparisons as directional rather than exact. But the pattern holds regardless of which specific leaderboard you trust: Kimi K2.7 Code's real competition right now isn't GPT-5.5 or Claude Opus 4.8. It's the other five or six open-weight labs all shipping inside the same quarter. Moonshot's actual edge here looks less like "best coding model" and more like "best agentic follow-through in the open-weight tier, at a price closed models can't touch."

This is worth remembering the next time a launch post calls something "the new state of the art." In a market with this many labs shipping this often, state of the art lasts about as long as it takes the next lab to publish their own model card. GLM-5.1's "new state-of-the-art" claim from April was true for about six weeks before MiniMax and Moonshot both published competing tables in the same ten-day window.

One more data point worth noting, since it's easy to check and rarely gets mentioned: in the first week after release, the community GGUF quantizations of K2.7 Code on Hugging Face had already pulled in tens of thousands of downloads, far outpacing the full-precision BF16 weights. That tracks. Almost nobody has the hardware for the 1.1-terabyte original. People want a quant that fits on something they actually own, and that's exactly what third-party quantizers raced to provide within days.

Quick Answers to the Obvious Questions

Moonshot's own FAQ on the release page covers most of what people actually ask, so here it is condensed:

Is it really open-source? Yes, both the weights and the code repository are under the Modified MIT license, with no waitlist or approval step to download them from Hugging Face.

What's the actual context window? 256K tokens (262,144 exactly), tuned for repository-scale work rather than just long chat history.

Does it handle images and video? Yes, natively. The MoonViT encoder isn't bolted on; the model was trained multimodal from the start.

Can I turn thinking mode off to save money? No. It's the one hard constraint in the whole release. Ask for non-thinking mode through Kimi Code and you'll get routed to K2.6 instead.

Should I use this for non-coding work? Moonshot's own answer is no, use K2.6 for general writing, analysis, and conversation. K2.7 Code is deliberately narrow.

Should You Actually Switch?

Depends entirely on what you're doing.

If you're already running K2.6 in production: upgrade. Better scores, fewer tokens burned, same architecture and deployment story (vLLM, SGLang, KTransformers all work the same way). This is about as close to a free upgrade as open-weight models get.

If you're doing long-horizon agentic work (multi-file refactors, MCP-based tool orchestration, anything that runs for hours instead of seconds), K2.7 Code's MCP Mark Verified result is a genuine reason to put it on your shortlist. Beating Opus 4.8 on a human-verified, real-server agentic benchmark isn't nothing.

If you need the single best coding model regardless of cost or openness: GPT-5.5 and Claude Opus 4.8 are still ahead on raw coding benchmarks, full stop. K2.7 Code doesn't pretend otherwise, and neither should the coverage of it.

If you're choosing between open-weight options: this is genuinely the hard part right now, because GLM-5.1, MiniMax M3, Qwen3-Coder-Next, and DeepSeek V4 are all credible alternatives depending on whether you care more about context length, multimodality, or raw efficiency. K2.7 Code's case is the 256K context, the mandatory-but-efficient thinking mode, and that MCP score. Worth running your own eval on your own tasks before picking a lane. The benchmark gaps between these models are narrow enough that workload-specific testing will tell you more than any leaderboard will.

If self-hosting is the plan: budget for it honestly. Even the smallest usable quantization clears 300GB, and that reality doesn't show up on any benchmark chart. For most teams, the API or Kimi Code subscription will be the cheaper, faster path to actually shipping something.

Moonshot didn't ship the best coding model in the world on June 12. They shipped their best one, made it meaningfully cheaper to run, and found one specific lane, verified agentic tool use, where they're actually ahead of Anthropic's flagship. In a field where five different labs published a "frontier" benchmark table in the same month, that's a perfectly good way to spend a quarter. Just read the table yourself before you believe the headline above it, including this one.