Kimi K3 + Claude Code Demo

At a glance

Hours after Moonshot AI shipped Kimi K3 on 16 July 2026, Data Science in your pocket opened a terminal that was already running Claude Code against it and asked, live and unrehearsed, for a game of snakes and ladders. Eight minutes later he was rolling dice in a working Pygame window that the model had specified, scaffolded, installed dependencies for, written, compile checked, and stress tested against thousands of simulated games without him touching a line of code. The demo is the whole video, and the interesting part is not the game. It is that the coding agent doing the work is Anthropic's, and the brain behind it is not. He states the three things that matter about running it this way, all in one breath at 1:28: it is slower than the Kimi K2.7 he had been running before, it costs "around Claude sonnets rates", and the model has "about 2.8 trillion parameter". Everything he then shows on screen is a test of whether that trade is worth taking.

This page rebuilds the run in order, and because the video shows a terminal that is already wired and never shows the wiring, it also rebuilds the part he skipped: the exact environment variables, base URL, and model string that put Kimi K3 behind Claude Code, drawn from Moonshot's own platform documentation and clearly marked as such.

The claim he opens with

He is not easing into it. Kimi has released Kimi K3, and in his words it is "a bonkers of a model". His benchmark claim, verbatim at 0:14, is that it beats "a GPT-5.6 all Claude 7 GLM 5.2 and everything else". Then the framing that the rest of the video hangs on:

"It's the best AI model that you can say not just open source, but it is able to beat all sources models also and I think the gap between open source and close source is now ending soon."

That is the pitch. The demo is the evidence. And the reason the demo is worth watching rather than reading about is the last sentence before he starts typing: "as you can see on my screen, this is Claude code and we are using Kimi K3 with it." Not Kimi's own CLI. Not a chat window. Anthropic's agent, someone else's model.

His choice of task is not arbitrary either. At 0:47 he says he read the documentation and "they have mentioned that Kimi K3 is quite great with game development", so he is testing the model on ground its own makers claim as a strength. Worth holding onto when you weigh the result: this is a favorable case, chosen on purpose, and he says so.

The part the video never shows: how Claude Code ends up talking to Kimi

Sourced, not shown. He never runs the setup on camera. The terminal is already pointed at Kimi K3 when the video opens, and the only thing he says about the switch is at 3:19: he was previously running Kimi K2.7 with Claude Code "in my system" and "I just changed it now". No commands, no config file, no /status output. So the mechanics below come from Moonshot's platform documentation and corroborating setup guides, not from anything on screen. It is the piece his video assumes you already have, and without it nothing else in the video reproduces.

The reason this works at all, and works without a proxy, a plugin, or a shim, is that Moonshot publishes an Anthropic compatible endpoint. Claude Code speaks the Anthropic Messages API wire format. Moonshot accepts that exact format at a dedicated path and answers it with Kimi. So the swap is not an integration in any real engineering sense. It is three environment variables that change where the CLI's HTTP requests land.

Wiring it yourself, the pay per token path

This is the path most people take, and the one that matches what the video shows. You need a key from the Moonshot platform console.

# Remove this first. A leftover ANTHROPIC_API_KEY silently wins over
# ANTHROPIC_AUTH_TOKEN and the connection fails with an auth error that
# points at nothing useful.
unset ANTHROPIC_API_KEY

export ANTHROPIC_BASE_URL="https://api.moonshot.ai/anthropic"
export ANTHROPIC_AUTH_TOKEN="<your Moonshot platform key>"
export ANTHROPIC_MODEL="kimi-k3"

Three lines and a deletion. That is the entire integration. Launch Claude Code in the same shell and it is running on Kimi.

Two refinements are worth adding, because Claude Code does not route everything through ANTHROPIC_MODEL. It has separate slots for its fast model, its subagent model, and its named tiers, and if you leave those unset the CLI will try to reach for a model name Moonshot has never heard of:

export ANTHROPIC_DEFAULT_OPUS_MODEL="kimi-k3"
export ANTHROPIC_DEFAULT_SONNET_MODEL="kimi-k3"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="kimi-k3"
export CLAUDE_CODE_SUBAGENT_MODEL="kimi-k3"

# Tool Search is not supported on the Kimi endpoint yet
export ENABLE_TOOL_SEARCH=false

# Kimi K3 carries a 1,048,576 token context window. Tell the CLI,
# or it will compact far earlier than it needs to.
export CLAUDE_CODE_AUTO_COMPACT_WINDOW=1048576

Verify it took. Run /status inside Claude Code. The base URL should read https://api.moonshot.ai/anthropic and the model should read kimi-k3. Do not look for Kimi in the /model picker; it will not appear there, and that is expected. The environment variables control routing, not the menu.

The subscription path

Moonshot also sells a coding subscription that fronts a different host and a different model string. This one is less widely documented than the pay per token path above, so treat it as the shape of the thing rather than a guarantee:

export ANTHROPIC_BASE_URL="https://api.kimi.com/coding/"
export ANTHROPIC_API_KEY="<your Kimi Code subscription key>"
export ANTHROPIC_MODEL="k3[1m]"
export CLAUDE_CODE_MAX_CONTEXT_TOKENS=1048576
export CLAUDE_CODE_AUTO_COMPACT_WINDOW=1048576

Note the inversion: the subscription endpoint takes ANTHROPIC_API_KEY where the platform endpoint takes ANTHROPIC_AUTH_TOKEN. That is the single most common way to get a confusing 401 when moving between the two. Note also the context ceiling is tier dependent. The entry tier is reported to cap at 262,144 tokens rather than the full million, so setting the compaction window to 1,048,576 on an entry tier plan will have the CLI happily fill a context the server will refuse.

Never paste a real key into a shell history or a recording. He does not show his, and neither should you.

The prompt

At 0:58 he types it. It is deliberately, almost provocatively thin:

help me develop a game called snake and ladders

No spec. No file layout. No language. No library. He says so out loud: "Let me see what it creates. I'm I have no clue what it'll do." And then the honest caveat that makes the next two minutes interesting, at 1:15: "I have very minimal requirements for game dev in my system. So, I think it'll do certain installations also."

That is the real test buried inside the toy one. A one line prompt on a machine with no game development stack means the agent has to choose a platform, choose a rule set, install what is missing, and then verify its own work. None of that is in the prompt. All of it has to come from the model.

Thirteen or fourteen seconds, and the first read on cost

The first thing he reports is latency. At 1:28, watching the spinner: "Channeling 13 14 seconds. I think compared Kimi K2.7 that I was using previously, it is a little slower."

Then, in the same beat, the economics, and this is the single most useful sentence in the video for anyone deciding whether to run this setup:

"But yes, it is costlier also as people have mentioned. It is costing around Claude sonnets rates. So, the model is expensive. Has about 2.8 trillion parameter." (1:35)

Both halves of that check out against published figures. Kimi K3 is a 2.8 trillion parameter model, and Moonshot's API pricing is $3 per million input tokens and $15 per million output tokens, with cache hits at $0.30. Those input and output numbers are identical to Claude Sonnet's published rates. "Around Claude Sonnet rates" is not approximately right. It is exactly right.

The sharper framing he does not draw out, and which is the actual argument for this setup: you are not saving money against Sonnet. You are paying Sonnet money and, if the benchmarks hold, getting something that competes further up the ladder. The saving only appears when you compare against the top tier.

The clarifying questions, and why they matter more than the code

While he is still talking about parameters, the agent has come back with a question rather than a file. He reads the options off the screen at 1:45: web, Python console, Python plus Pygame, or type something else. He wavers out loud, says "let's keep it web. Let me say web for now", then reverses himself two seconds later and picks Python plus Pygame.

More questions follow. Two player hot seat, or something else. He asks for one player against the computer. Then a rule set, and he takes the classic.

He then summarizes what the agent extracted, at 2:21, and it is a clean three item spec built entirely from a nine word prompt:

• Platform. Python plus Pygame. He explains for the audience: "Pygame is a game library in Python."
• Players. One player versus computer.
• Rule set. The classic one.

His verdict at 2:32:

"I think the initial start has been great. It has asked some very great questions to build out the game."

This is the part worth stealing regardless of which model you point at your agent. The thin prompt did not produce a thin guess. It produced an interview. And every ambiguity he would otherwise have discovered forty minutes later, when the game turned out to be a web app he did not want, got surfaced in the first ninety seconds. The questions are the deliverable at that stage.

The token counter, and a number that cannot be right

At 2:41 he glances at the counter and reports:

"I have already consumed about 1,000 K tokens. It would cost me a fortune, I guess, for building this video, but I think that's fine."

Then at 4:20, well after the clarifying questions and after the model has been thinking for minutes:

"Till now, it has consumed about 20K tokens and no code has been written."

Both are on the page verbatim, and both cannot describe the same counter. One thousand K is a million tokens; twenty K is twenty thousand. The later, smaller figure comes after strictly more work, so the reading is going the wrong direction. He is reading a live status line quickly while narrating, and misreadings are the likeliest explanation, but the video never resolves it and neither will this page. What the two numbers do establish, taken together, is his posture toward the spend: he expects the run to be expensive, he says so twice, and he does it anyway because he wants the test on record. If you want a real per run figure for the Kimi backed setup, this video does not give you one.

Five minutes of thinking

The long middle of the video is a spinner. He fills it honestly rather than cutting it, and that is to his credit, because the latency is the cost of this setup and hiding it would misrepresent the trade.

At 2:50: "It's channeling still taking its own good time, thinking some more." At 3:00 he restates why he is leaving it in: "I want to demonstrate how good the model is. And even if the model is not good, this is a real-time test of Kimi K3 live for the first time on this channel."

Then at 3:10, the comparison again, now with the switch made explicit:

"It is taking its own good time. It's a little slower, for sure, compared to Kimi K2.7 code which which I was using previously with Claude code in my system. I just changed it now."

That single sentence is the entire on screen evidence that this is a swap rather than a fresh install, and it is the only reference to the mechanics in the whole video.

The reply lands at 3:36. His readout: "for thinking for about 5 minutes, it is able to get a reply." Five minutes of reasoning before a single character of code. Kimi K3 runs with thinking enabled by default and, on the Anthropic compatible endpoint, engages it at full depth on every request. That is not a setting he chose. It is the default behavior, and it is simultaneously why the plan is good and why the wait is long and why the output token bill is higher than a non reasoning model would produce for the same task.

The plan, and the two assumptions it declares

What comes back is not code. It is a plan with its ambiguities flagged, which he reads out at 3:40: "Write the game smoke test logic plus rendering handles."

Then the part that a careful engineer would recognize immediately, at 3:46. The model states the two rule decisions it had to make and could not derive from "the classic one":

• Overshoot equals turn wasted. If your roll would take you past the final square, you do not move. This is one of several defensible readings of the classic rules, and it picked one and said so.
• Standard Milton Bradley snake and ladder positions, with no roll a six to enter rule.

Both are real forks in the snakes and ladders rule set. Both would have produced a game that felt subtly wrong to someone expecting the other convention. And rather than silently choosing, or asking a third round of questions and burning another five minutes, the model chose, declared, and moved. That is the correct behavior and it is the most quietly impressive moment in the video.

At 3:55 he reads a line as "53.13 is ready" and immediately follows it with the substance: Pygame is not installed, and the agent is installing it now. His summary of who is driving, at 3:58, contains the first of two slips of the tongue worth noting because they recur:

"So, everything is getting controlled by Gemini K3 here."

He means Kimi K3. He says Gemini again at 4:28. Nothing about the demo changes; it is a verbal stumble in a live recording, and this page flags it only so a reader watching along is not confused by it.

Pygame installs itself

At 4:12: Pygame 2.6.1 is installed. He had said at 1:15 that his machine had "very minimal requirements for game dev", and he was right, and the agent handled it. No pip install typed by him, no dependency error he had to read and fix. The environment gap he flagged at the start closed without his involvement.

This is the moment where the setup stops being a chat interface with a fancy loop and starts being an agent. A model in a browser tab cannot install Pygame on your machine. Claude Code can, and pointing it at Kimi K3 does not take that away, because the tool layer belongs to the CLI and not to the model behind it.

Writing the file, and the reject he did not mean

At 4:40 the code arrives in one pass, and Claude Code does what Claude Code does: it asks for permission before writing to disk.

Then the most human thirty seconds in the video. At 4:55: "Continue. What happened?" Then at 5:06:

"I didn't reject it. I think it got clicked by mistake."

He fat fingered the rejection. The agent takes it at face value, stops, and waits. He tells it to continue, and it recovers cleanly, narrating its own recovery: "just proceeding with the task. I'll reattempt the write."

Two things to take from an accident. First, the approval gate is real and it is the CLI's, not the model's, which is exactly what you want at the boundary where an agent writes to your filesystem. Second, a rejected tool call is not a poisoned session. The agent absorbed a contradictory signal, did not spiral, did not rewrite from scratch, and picked up where it left off.

Then the throughput observation at 5:24: "the token writing is shooting up very fast right now. Within seconds." Worth pairing with the five minute think. The wait is front loaded into reasoning; generation itself is quick. At 5:48 he stops gating each edit: "As you can see, I'm accepting allow all the edits."

The file lands in four seconds.

Verification, which is the actual headline

At 5:57 the agent finishes the write and, without being asked, starts checking its own work. He reads the plan off the screen:

"file written now verifying. First, a compile check. Then a headless smoke test that renders every element, simulates thousands of full games to confirm the rules logic."

Read that again slowly, because it is the strongest thing in the video and he almost passes over it. Three verification layers, none of them requested in his nine word prompt:

1. A compile check. Does the Python parse and import.
2. A headless render test. Does every visual element actually draw, without needing a window on screen.
3. Thousands of simulated full games. Does the rules logic terminate and behave, across a sample large enough to catch a snake or ladder wired to the wrong square, an off by one on the final square, or the overshoot rule it declared earlier failing to hold.

That third one is not a smoke test in the usual sense. It is a property check. A model that writes the game and stops has done half the job; a model that writes the game and then plays it ten thousand times against itself before handing it over has closed the loop that usually falls to the human.

His reaction at 6:08:

"This is crazy work, my friends. It is able to create an entire snakes and ladders game. You versus the computer without me touching anything. I think within 10 minutes I I waited for and it is able to do most of the stuff for me."

Ten minutes of wall clock, from nine words to a verified game. Note that this exceeds the video's own 8:11 runtime, so there are cuts in the spinner segments; the ten minutes is his figure for the real elapsed time, not the runtime you watch.

At 6:23 he generalizes, and flags it as a projection rather than a result: "this was a basic game that I asked, but I think creating complicated games with K3 won't be in that tough challenge given the team is boosting some great results out of K3." Fair enough, and worth marking as the untested claim it is.

All checks passed, and the game runs

At 6:38 the results come back: compile okay, render okay, everything looking good. At 6:49 the agent asks whether he wants any changes; he does not. At 6:52 he reads the summary: "All the check passed, the game is done and verified."

So he asks for the last thing, at 6:58, twice for good measure: "Run it for me. Run it for me."

At 7:08: "It has written the entire file for me in Pi Python plus Pygame." He notes at 7:13 that a more complicated version could be attempted, which is the sequel he promises rather than the thing he shows.

At 7:18 the window is up. He rolls the dice. The first roll is a five. He keeps rolling and reads the numbers off the screen at 7:38: six, three, four. He plays the whole game.

"Just look at the graphics that it is able to generate and look at the information I'm getting. 6 3 4. I'm able to play the entire game here." (7:33)

His close at 7:43 is enthusiastic and, unusually for this genre, includes the ceiling as well as the result:

"It is able to develop the entire UI using Pygame. I know Pygame is quite restrictive, but this is some another level of work that K3 has done."

That caveat is worth keeping. Pygame is a 2D surface blitting library. A snakes and ladders board is a grid, some line segments, and text. The UI achievement is real but it is bounded, and he says so himself rather than letting the shot speak for more than it shows. Final line, at 7:59: "bet yourself. Try out the model for sure. K3 is here to stay and it has just broken all the barriers for me. Try building a game."

The honest read: what this setup actually costs you

Everything above is the video rebuilt. This section is the part it does not cover, and it belongs at the end rather than the front because the demo deserves to be judged on what it shows before it is judged on what it omits.

Three things the demo does not test, and you should not read the result as covering:

It never leaves the happy path. One task, chosen because Moonshot's own documentation flags game development as a strength, on a codebase that did not previously exist. No existing repository to navigate, no failing test to debug, no ambiguous stack trace, no long session where the agent has to hold a large codebase in context. Those are the tasks where a backing model swap actually bites, and none of them appear.

The capability gaps never surface because he never reaches for them. He does not ask it to fetch a page, read a screenshot, or search a large tool surface. All three are exactly where the Kimi endpoint is currently thinner than the native pairing. A clean run that never touches the broken parts is not evidence the parts work.

The benchmark claim is his, and it is close but not exact. He says K3 beats "GPT-5.6 all Claude 7 GLM 5.2". The verifiable version, from the Frontend Code Arena results published at launch, is that Kimi K3 took first place with 1,679 points ahead of Claude Fable 5 at 1,631, GPT-5.6 Sol at 1,618, and GLM-5.2 at 1,587. There is no model called Claude 7. The shape of his claim holds on that particular leaderboard; the broader "beats everything else" does not follow from one arena, and on the wider Artificial Analysis intelligence index K3 sits fourth rather than first.

And one thing the demo genuinely does establish, which no amount of caveating erodes: the harness and the brain are separable. Everything that made the run good other than the reasoning itself, the approval gate that caught his misclick, the dependency install, the file write, the decision to verify unprompted, belongs to Claude Code and survived the swap intact. If you have built a workflow around that agent, you are not locked to the models it ships with, and the switch costs three lines of shell.

Key takeaways

• The integration is three environment variables, not an integration. ANTHROPIC_BASE_URL pointed at https://api.moonshot.ai/anthropic, ANTHROPIC_AUTH_TOKEN holding a Moonshot key, and ANTHROPIC_MODEL set to kimi-k3. Moonshot publishes an Anthropic compatible endpoint, so no proxy, plugin, or shim is involved.
• Unset ANTHROPIC_API_KEY first. A leftover value silently overrides ANTHROPIC_AUTH_TOKEN and breaks the connection on the platform endpoint. The subscription endpoint inverts this and wants ANTHROPIC_API_KEY instead.
• Verify with /status, not /model. Kimi will never appear in the model picker. That is expected and does not mean the swap failed.
• The cost claim is exactly right. Kimi K3 at $3 per million in and $15 out matches Claude Sonnet's published rates to the dollar. The 40 percent saving only exists against Opus 4.8 at $5 and $25.
• It is slower, and he says so twice. Thirteen to fourteen seconds to first response and about five minutes of thinking before any code, both worse than the Kimi K2.7 he was running before. Thinking is on at full depth by default on this endpoint, which is why.
• A nine word prompt produced an interview, not a guess. The agent asked for platform, player count, and rule set before writing anything, surfacing every ambiguity in the first ninety seconds.
• It declared the assumptions it could not resolve. Overshoot equals a wasted turn, standard Milton Bradley positions, no roll a six to enter. It chose, said so, and moved rather than asking a third round.
• Unprompted verification is the real headline. A compile check, a headless render test of every element, and thousands of simulated full games to confirm the rules logic, none of which were in the prompt.
• The tool layer belongs to the CLI, not the model. Pygame 2.6.1 installed itself, the approval gate caught his accidental reject, and the agent recovered cleanly. All of that survived the backing model swap intact.
• Tool Search must stay off and WebFetch does not work against the Kimi endpoint, and image input is restricted to base64 or ms:// file ids. The demo never touches any of these, so the clean run is not evidence they work.
• His token figures contradict each other. He reads "1,000 K tokens" at 2:41 and "20K tokens" at 4:20, after strictly more work. The video gives you no reliable per run cost.
• One favorable task is not a verdict. Game development is a strength Moonshot's own docs advertise, the codebase was new, and nothing here tests a large existing repository or a hard debugging session.

Chapters

0:00 Kimi K3 released, and the claim that it beats everything 0:37 The setup: Claude Code, with Kimi K3 behind it 0:47 Why a game: the docs say K3 is strong at game development 0:58 The prompt, nine words, no spec 1:15 A machine with no game development stack 1:28 Thirteen to fourteen seconds, and slower than Kimi K2.7 1:35 Around Claude Sonnet rates, and 2.8 trillion parameters 1:45 The agent asks: platform, players, rule set 2:21 The spec it extracted, read back 2:41 The token counter, and expecting a fortune 2:50 Waiting, and why he is leaving the wait in 3:10 The only line about the swap: "I just changed it now" 3:36 Five minutes of thinking, then a reply 3:46 The two rule assumptions it declares out loud 3:55 Pygame is missing, and it starts installing 4:12 Pygame 2.6.1 installed 4:20 Twenty thousand tokens, and no code yet 4:40 The code arrives, and asks permission 4:55 The accidental reject, and a clean recovery 5:24 Token generation is fast once thinking is done 5:48 Allow all the edits, file written in four seconds 5:57 Compile check, headless render test, thousands of games 6:08 Ten minutes, without touching anything 6:23 Projecting to more complicated games 6:38 All checks passed 6:58 Run it for me 7:18 The window is live, and he rolls a five 7:33 Playing it through: six, three, four 7:43 Pygame is restrictive, and this is still another level 7:59 Try it yourself

Notable quotes

"Kimi has released Kimi K3 and my friends, it is a bonkers of a model. It is able to beat a GPT-5.6 all Claude 7 GLM 5.2 and everything else." (0:08)

"It's the best AI model that you can say not just open source, but it is able to beat all sources models also and I think the gap between open source and close source is now ending soon." (0:24)

"As you can see on my screen, this is Claude code and we are using Kimi K3 with it." (0:37)

"If you have read the documentation, they have mentioned that Kimi K3 is quite great with game development." (0:47)

"Let me see what it creates. I'm I have no clue what it'll do. I have very minimal requirements for game dev in my system. So, I think it'll do certain installations also." (1:13)

"Channeling 13 14 seconds. I think compared Kimi K2.7 that I was using previously, it is a little slower." (1:28)

"But yes, it is costlier also as people have mentioned. It is costing around Claude sonnets rates. So, the model is expensive. Has about 2.8 trillion parameter." (1:35)

"I think the initial start has been great. It has asked some very great questions to build out the game." (2:32)

"I have already consumed about 1,000 K tokens. It would cost me a fortune, I guess, for building this video, but I think that's fine." (2:41)

"Even if the model is not good, this is a real-time test of Kimi K3 live for the first time on this channel." (3:02)

"It's a little slower, for sure, compared to Kimi K2.7 code which which I was using previously with Claude code in my system. I just changed it now." (3:13)

"Two assumptions I have made, overshoot equals to turn wasted, standard Milton Bradley, snake ladder positions, and no roller six to enter rule." (3:46)

"Till now, it has consumed about 20K tokens and no code has been written." (4:20)

"I didn't reject it. I think it got clicked by mistake." (5:06)

"As you can see, the token writing is shooting up very fast right now. Within seconds." (5:24)

"File written now verifying. First, a compile check. Then a headless smoke test that renders every element, simulates thousands of full games to confirm the rules logic." (5:57)

"This is crazy work, my friends. It is able to create an entire snakes and ladders game. You versus the computer without me touching anything. I think within 10 minutes I I waited for and it is able to do most of the stuff for me." (6:08)

"All the check passed, the game is done and verified." (6:52)

"Just look at the graphics that it is able to generate and look at the information I'm getting. 6 3 4. I'm able to play the entire game here." (7:33)

"It is able to develop the entire UI using Pygame. I know Pygame is quite restrictive, but this is some another level of work that K3 has done." (7:47)

"K3 is here to stay and it has just broken all the barriers for me. Try building a game." (8:02)

Resources mentioned

• Kimi K3, the model under test. 2.8 trillion parameters, a 1,048,576 token context window, and thinking enabled by default. Released 16 July 2026, hours before this video.
• Moonshot AI, the lab behind Kimi, and the publisher of the Anthropic compatible endpoint that makes this whole setup possible.
• Kimi API platform, where the API key comes from and where the pricing, model strings, and endpoint documentation live.
• Using Kimi in Claude Code, Moonshot's own setup guide. The source for the environment variables in this page, none of which appear in the video.
• Claude Code, the coding agent doing the work. Unmodified throughout; only its base URL and model string change.
• Anthropic, and the Messages API whose wire format is what makes the endpoint swap a three variable change instead of a port. Published model pricing is the comparison point for his "around Claude sonnets rates" claim.
• Kimi K2.7, the model he was running behind Claude Code before this, and his speed baseline throughout.
• Pygame, the Python game library the agent selected. Version 2.6.1, installed by the agent mid run.
• Python, the platform the agent chose over the web option he initially leaned toward.
• Models he names as beaten, for reference: GPT-5.6, GLM-5.2, and what he calls "Claude 7", which corresponds to Claude Fable 5 on the launch leaderboards.
• Frontend Code Arena, the leaderboard where Kimi K3 took first place at launch with 1,679 points, and Artificial Analysis, where it placed fourth on the broader intelligence index.
• Milton Bradley, whose standard snake and ladder positions the agent named as its rule set assumption.
• Data Science in your pocket on YouTube, the creator's channel.