
Agent Model Benchmark skill and the Yalc Framework
The only model comparison that runs on your own work instead of a leaderboard, and the only one honest enough to tell you when it cannot call a winner. Dual family judges, both orders, multiple trials, and significance testing. Run it before you move any high volume workload to the cheaper model.
Say this to fire the Agent Model Benchmark skill
Any of these natural language phrases activates the skill inside Claude Code.
Agent Model Benchmark, plainly
The short version first. We ran Kimi K3 and Claude Fable 5 on 11 real tasks from a production GTM agent, 3 trials each, judged by both Opus and Kimi in both orders. Correctness was dead even, every objective check that Fable passed, Kimi passed too, on every trial. Fable showed a real but modest quality edge overall, a 71 percent win rate that clears significance and is not just longer answers. But the two judges agreed only 48 percent of the time, position bias flipped some verdicts 100 percent of the time on an order swap, and no single task had a clean consensus winner. Kimi K3 runs at roughly a third of Fable's list price. The honest verdict: on the work that has a right answer, the cheap model is as good, and even a careful benchmark disagrees with itself far more than anyone admits.
Kimi K3 is Moonshot AI's flagship model, kimi-k3 on the platform and kimi-for-coding on the Kimi Code membership plan. Claude Fable 5 is claude-fable-5, Anthropic's premium tier and the default brain of Claude Code. On list price Kimi runs at roughly a third of Fable per token, a 3x cost cut sitting on the table for anyone running agents all day. The question is what you lose when you take it. A leaderboard cannot answer that, because a leaderboard tests riddles and toy code, not your skills, your output formats, or your reliability bar. This kit answers it the boring way: run both models on the work your agent already does, and score it blind.
It works in five parts. The kit scans your .claude/skills folder and turns each skill you confirm into a self contained task with a realistic invented input, and a four task starter suite covering coding, extraction, tool use, and long context runs if the folder is empty. Each task runs through both models fully headless, as many trials as you ask for: claude -p on claude-fable-5 reports real measured cost and latency, kimi -p is timed by wall clock with cost estimated from visible tokens and always labeled as an estimate. Every pair is then scored by two blind judges, one from each model family, Opus and Kimi, and each pair is judged in both orders because judge models have position bias. A win only counts when the judges agree; disagreements become ties. Reliability is reported as pass@k and pass^k across trials, errored trials count as failures with their own error rate column, and a model call that returns nothing fails loud. The output is one results page plus model-routing.json and a paste ready CLAUDE.md snippet, so the verdict becomes live routing your agents actually follow. A sample report ships in the repo.
The run's biggest finding is about benchmarks themselves. The two judge families agreed on the winner only 48 percent of the time, and on some tasks the verdict flipped completely when we swapped which answer came first. Score once, with one judge, in one order, the way almost everyone does, and half your verdicts are noise. That is why the tool judges twice, with two families, across both orders, and calls a tie whenever the evidence does not clear significance.
So the play is patience, not a hasty switch. On correctness the cheap model is already even, so the money argument is real. But the quality gap is small and contested enough that the run's own routing policy routed nothing to Kimi and marked every category insufficient evidence. Move your objectively checkable, high volume work to the cheaper model where correctness parity is proven, keep customer facing writing on the premium model, and re-benchmark after any major model release rather than trusting one screenshot.
Position in the GTM operating system
The benchmark sits at the **intelligence** layer of the Yalc workflow. Every other skill produces work; this one tells you which model should be doing that work, using your own skills as the test set instead of a public leaderboard.
The honesty rules are the point. A model call that returns nothing fails loud instead of being scored as a loss. The judge is blind with the answer order randomized. Kimi's cost is always labeled as an estimate because its CLI hides reasoning tokens on stderr. If a benchmark cannot fail loudly, it lies confidently.
Running the Agent Model Benchmark skill end to end
Workflow position
Run it before moving any high volume workload to a cheaper model, and re run it monthly. The output is a routing decision that every other skill benefits from: which model handles the lean structured work, which one handles the customer facing polish.
Required inputs
- → An authenticated claude CLI (a Claude subscription is enough, no API credits required)
- → An authenticated kimi CLI (installs to ~/.kimi-code/bin, OAuth login with a Kimi membership)
- → A .claude/skills folder to benchmark, or nothing at all (the 4 task starter suite runs on an empty machine)
Outputs
- → results.json with per task quality scores (1 to 10 plus a written reason), winner, latency for both models, cost, and pass or fail across trials
- → A self contained results.html verdict page with a headline that prints a tie when the difference is not statistically meaningful
- → model-routing.json plus a paste ready CLAUDE.md routing snippet, emitted only when the evidence clears the statistical gates
- → Fable cost measured from the claude CLI; Kimi cost estimated and always labeled as an estimate
- → Errored trials counted as failures, with a separate error rate column per model
Chaining recommendations
Anti patterns to avoid
Pros, cons, who it's for
Pros
- Benchmarks on your own skills, not a public leaderboard
- Symmetric comparison, both models run headless through their own CLI on the identical prompt
- Blind Opus judge with A/B order randomized, so it cannot favor a side
- Fail loud design, an empty response can never be silently scored as a loss
- Honest cost labeling, measured for Fable, estimated and flagged for Kimi
- Works on an empty machine via the 4 task starter suite
Cons
- Kimi cost is an estimate because its CLI hides reasoning tokens on stderr
- One run is one sample, re run before betting a production workload on the verdict
- The kimi CLI can error on complex agentic tasks (2 of 11 in our run), plan a retry budget
- A full run takes minutes, not seconds, since every task runs twice plus a judge pass
Who it's for
- Operators deciding whether to move agent workloads to a cheaper model without gambling in production
- Founders running Claude Code agents daily who review their model bill monthly
- Anyone shipping high volume AI output where "correct and cheap" beats "polished and pricey" for part of the work
What the rigorous run actually found
This is the v2 run: 11 tasks, 3 trials each, every answer pair judged by both Opus and Kimi in both orders, with significance testing. It is deliberately harder to fool than a single judge scoring once, and the results are humbler and more interesting than the first pass.
Correctness is dead even. On all five tasks with an objective check, regex, strict JSON, merge intervals, the bug fix, and the train reasoning problem, both models passed every single trial. Kimi K3 is exactly as correct as Fable 5 on checkable work.
The two judges agreed only 48 percent of the time. A Claude judge and a Kimi judge disagree on the winner more than half the time. That one number should end your trust in any benchmark that uses a single judge, including our own first run.
Position bias was severe. On some tasks the verdict flipped 100 percent of the time just by swapping which answer came first. The judge was picking by slot, not by content. Judge once in one order and you are reporting noise as a result.
Fable 5 does have a real but modest quality edge. Its win rate was 71 percent, the confidence interval clears a tie, and it is not a length artifact since Fable's answers were actually a touch shorter. But no single task produced a clean consensus winner once both judge families had to agree across both orders. Fable is reliably a little better on average, not a task by task champion.
And the honest kicker: the run's own routing policy routed nothing to Kimi. Every category came back insufficient evidence. The tool refused to recommend a switch on data this thin, which is the whole point.
What changed from the first pass: the clean "Fable swept writing five to zero" story from v1 was largely judge artifact. Make two model families agree, swap the answer order, and run it three times, and the sweep dissolves into a small real edge plus a big lesson about how much benchmarks lie.
How to connect Kimi to Claude Code
Claude Code does not know Kimi exists unless you tell it. Three ways in.
1. Side by side. Install the kimi CLI, log in with your Kimi membership, confirm with kimi -p "say hello". Two agents, one terminal.
2. Claude Code powered by Kimi. Point the harness at Kimi's endpoint and launch with the kimi-for-coding model using the three commands below. Same interface, different brain.
3. Delegation, the path this kit uses. Add one note to your CLAUDE.md: "The kimi CLI is installed and authenticated. To get a second model opinion or delegate a subtask, shell out with: kimi -p the task." From then on, asking Claude Code to get Kimi's opinion just works, and your existing logins are the only credentials involved.
export ANTHROPIC_BASE_URL=https://api.kimi.com/coding/v1export ANTHROPIC_API_KEY=your_kimi_console_keyclaude --model kimi-for-codingRun the benchmark in 5 minutes
Clone, preview, run. The dry run builds your task list and costs nothing. The real run needs only the claude and kimi logins you already have.
gh repo clone Othmane-Khadri/kimi-k3-vs-fable-5-benchmarkcd kimi-k3-vs-fable-5-benchmarknode scripts/run.mjs --dry-runnode scripts/run.mjs --trials 3 --judges dual5 traps that corrupt model benchmarks
Our first run said Fable won 5 out of 5. Then we saw Kimi's latency, 3 milliseconds. No model answers in 3 milliseconds. The CLI had never launched, and the harness had scored empty output as a loss. Every rule below exists because a run lied to us first.
1. An empty response must fail loud, never score as a loss. If a benchmark cannot fail loudly, it lies confidently.
2. Strip CLI chrome before judging. kimi -p prepends a bullet that breaks strict JSON. The same task went from a 3 out of 10 loss to a 9 against 8 win once we stopped scoring the wrapper. The kit strips it for you.
3. Kimi streams its reasoning to stderr, so visible token counts undercount its real cost. Label every estimate as an estimate.
4. Never write "run the X skill" in a task prompt. An agentic CLI goes hunting for a skill file by that name instead of doing the work, and can die trying.
5. Never reuse a Kimi membership key in a standalone script. It is ToS locked to the official CLIs and misuse can get access restricted.
Frequently asked
Is Kimi K3 as good as Claude?
On correctness, in our rigorous 11 task run, yes. It passed every objective check Fable 5 passed, on every trial. Fable showed a small overall quality edge, a 71 percent win rate that clears significance, but no single task had a clean consensus winner once both judge families had to agree across both answer orders. On the work that has a right answer, the cheap model is as good.
Is Kimi K3 good for coding?
Both models passed every coding and reasoning probe on all three trials, correct code every time. For work you review anyway, Kimi is good enough at roughly a third of the price. The interesting caveat is not Kimi, it is the judging. On some coding tasks the verdict flipped 100 percent when we swapped answer order, which is why a single judge cannot be trusted here.
How much cheaper is Kimi K3 than Claude Fable 5?
Roughly a third of the list price per token. Ignore per task estimates that look 100x cheaper, they exclude the reasoning tokens Kimi's CLI hides on stderr. The kit labels its Kimi cost as an estimate for exactly this reason.
Does Kimi work with Claude Code?
Yes, three ways. Run the kimi CLI side by side, point Claude Code itself at Kimi's endpoint with ANTHROPIC_BASE_URL and the kimi-for-coding model, or add one CLAUDE.md note so Claude Code can delegate subtasks with kimi -p. The kit uses the delegation path.
Why two judges instead of one?
Because in our run a Claude judge and a Kimi judge agreed on the winner only 48 percent of the time, and swapping the answer order flipped some verdicts entirely. A single judge scoring once, the industry default, is coin flipping half its calls. The kit judges every pair with both families in both orders and calls a tie when they do not agree, so a reported win is one you can actually defend.
Do i need a new API key to run the benchmark?
No. A Claude subscription and a Kimi membership login are the only credentials used. The judge panel runs through the same two CLIs, so both judges are covered by the logins you already have.
I have no skills in .claude/skills yet. Is it useless?
No. A 4 task starter suite covering coding, extraction, tool use, and long context runs instead, so you still get a real verdict.
What happens when a model call fails mid run?
The trial is recorded as an error and counted as a failure, with a separate error rate column per model, and the rest of the run continues. For agents, reliability is the metric, so flakiness lowers the score instead of hiding. A call that returns nothing still fails loud. Our first ever run scored a never launched Kimi as a 5 out of 5 Fable sweep, and these rules exist because of it.
Can i benchmark a different model pair?
Yes. The CLIs, model ids, and prices live in config/models.json and config/pricing.json. Any two models reachable through a headless CLI can be compared the same way.
Get the Agent Model Benchmark skill
Clone the Yalc skill set, drop in your env, run from your next Claude Code session.
gh repo clone Othmane-Khadri/kimi-k3-vs-fable-5-benchmark && cd kimi-k3-vs-fable-5-benchmark && node scripts/run.mjs --dry-run