Which CLI for which job - The Coding CLI Landscape

The capstone of this course. After §2.1 (Claude Code vs Perplexity Computer), §2.2 (Kilo Code + BYOK), and §2.3 (the /model hot-swap), the question this course started with — which CLI should I actually use? — has a single answer: all three, in different slots. The channel's working position in 2026 is not "pick one" but "match the slot to the workload." This article synthesizes the three subtopics into a decision matrix, a worked example, and the failure modes the matrix hides.

The shape of the answer: Claude Code for control, Perplexity Computer for parallel, Kilo Code for BYOK. The hot-swap is the bridge that lets a single session move between them. The channel's pattern, in production, is to use all three — sometimes in the same task.

What you'll learn

The decision matrix: which CLI to reach for first, given the task shape, the budget, and the process-visibility requirement.
The capstone worked example: a research scaffold on Perplexity Computer, a controlled build on Claude Code, a cheap loop on Kilo Code, with /model hot-swaps between the three.
The "all three" pattern: the channel's working position is not "pick one CLI" but "match the slot to the workload," and the three CLIs are complementary, not competing.
The failure modes the matrix hides: Perplexity's Max-plan gating, Claude Code's plan-mode requirement, Kilo Code's OpenRouter dependency, the hot-swap's pre-configuration rule.
The escape-hatch chain: when one CLI fails, the next one is already configured. The setup cost is paid up front; the recovery cost is paid on demand.
The combo stack recipes that combine the right CLI with the right model: budget combo (Mimo V2 Pro everywhere, $0/month), paid combo (GPT 5.4 + Minimax, $60–$95/month), and the channel's preferred bridge stack (DeepSeek orchestrator + Minimax executor, both paid).
The "no CLI" cases: when the workload doesn't fit any of the three, and the right answer is KaneAI (for browser-driven QA) or a self-hosted OpenClaw (for full control).

The decision matrix

The channel's coverage across the three subtopics lands on a four-axis matrix. Pick the CLI by the task's position on each axis.

Axis	Claude Code	Perplexity Computer	Kilo Code
Process visibility	High (plan mode, agent teams)	Low (orchestration hidden)	High (VS Code fork, see the diff)
Parallel agents	Optional (must enable)	Native (fan out by default)	Optional (must configure)
BYOK / model choice	Yes (env-var swap, see §2.2)	No (Opus 4.6 only)	Native (OpenRouter)
Cost	$20–$200/month + token burn	$176/month flat	$0–$9/month harness + BYOK model cost
Best for	Controlled build, code review, security-sensitive code	Research scaffold, parallel report, no-code output	Cheap executor loop, multi-model routing, Mimo V2 Pro free window
Worst for	Quick research, no-code output	Process-sensitive build, security-sensitive code	Anthropic-flavored MCPs, computer use

The matrix is a starting point, not a verdict. The channel's pattern is to use all three in the same workflow — research on Perplexity, build on Claude Code, executor on Kilo Code + Minimax. The hot-swap is the operation that lets a single session cross between them.

The matrix's hidden fourth axis is the model underneath the CLI. Claude Code defaults to Opus 4.6 (or Sonnet 4.6) on Anthropic, but the env-var swap from Course 4 §4.2 lets you point it at Minimax M2.7 or Mimo V2 Pro. Perplexity Computer is locked to Opus 4.6. Kilo Code is OpenRouter-native, which means any model in the Hermes tier list is one config line away. The CLI choice is upstream of the model choice, but the model choice is what determines the cost. Picking the right CLI for the wrong model is the failure mode the matrix hides.

Reading the matrix

The matrix is dense — six rows, three columns, eighteen cells. The way to read it is row-by-row, not column-by-column. The question is always "for this axis, which CLI fits?" — not "which CLI is best overall?" The channel's framing is consistent: there's no "best CLI," only "best CLI for this slot."

Process visibility row: Claude Code and Kilo Code tie (both high), Perplexity Computer is low. If the task is process-sensitive (a security audit, a money-handling change, a multi-step build), reach for Claude Code or Kilo Code. If the task is process-insensitive (a research scaffold, a quick report), Perplexity Computer is fine.

Parallel agents row: Perplexity Computer wins (native), the other two require configuration. If the task is parallel-friendly (multi-source research, dashboard builds, scheduled report runs), Perplexity Computer is the right shape. If the task is sequential (a refactor, a content-inventory script), the other two are fine.

BYOK / model choice row: Kilo Code wins (native), Claude Code requires an env-var swap, Perplexity Computer is locked. If the model matters (you want Mimo V2 Pro for the free window, or Minimax for the cheap loop), Kilo Code is the right shape. If the model doesn't matter, any of the three works.

Cost row: Kilo Code wins (cheapest), Perplexity Computer is fixed at $176/month, Claude Code is variable. If the budget is tight, Kilo Code is the right shape. If the budget is flexible and the workload justifies the spend, Claude Code or Perplexity Computer is fine.

Best for row: the channel's recommendation for each CLI's natural slot. Use this as the default routing: Claude Code for controlled builds, Perplexity Computer for research scaffolds, Kilo Code for cheap executor loops.

Worst for row: the channel's anti-recommendation. Use this to catch the failure mode: don't use Claude Code for quick research, don't use Perplexity Computer for process-sensitive code, don't use Kilo Code if you need Anthropic-flavored MCPs.

The matrix is the channel's "which CLI for which slot" answer in tabular form. The capstone is the worked example. The hot-swap is the operation that lets you change slots mid-build. The escape-hatch chain is the layered defense when the slot is wrong.

The "all three" position, restated

The channel's working position, drawn from the three subtopics:

Claude Code = control. The plan mode, the agent teams, the process visibility — Claude Code wins on the things you can see. Reach for it when the build is multi-step, the diff matters, and the code is security-sensitive or money-handling.
Perplexity Computer = parallel. The fan-out, the no-code output, the scheduled reports — Perplexity Computer wins on the things you don't have to write. Reach for it when the task is research-heavy, the output is a report or dashboard, and you don't need to see the orchestration.
Kilo Code = BYOK. The OpenRouter-native model routing, the VS Code fork, the Mimo V2 Pro free window — Kilo Code wins on the things you control. Reach for it when the model matters more than the harness, the budget is tight, and the workflow is high-volume.

The hot-swap is the bridge. When the orchestrator (Claude Code, GPT 5.4, Z) plans a multi-step build, the executor (Minimax M2.7, Mimo V2 Pro) runs the file edits, and the review pass goes back to the orchestrator — all in the same session. The escape hatch is the second model: set it up before the first one fails.

The channel's working stack in production is a multi-CLI, multi-model stack:

Research and reports: Perplexity Computer, on the rare weeks the Max plan is worth it.
Controlled builds: Claude Code, with plan mode + agent teams, and the env-var swap to Minimax M2.7 as the executor.
Cheap overnight loops: Kilo Code + Mimo V2 Pro (while free) or Minimax M2.7 (when paid).
Review pass: Claude Code in plan mode, with the orchestrator reviewing the executor's diff.
QA / browser testing: KaneAI, with the video recording as the artifact.

That stack uses all three CLIs and the closing tool (KaneAI), in different slots, with the hot-swap as the bridge between them. The cost frame: $0 (Kilo Code + Mimo free window) to $200/month (Claude Max) depending on which slot is active.

The worked example: a 30-minute coding agent

The capstone, expanded. A single coding brief, executed three ways, end-to-end, with a clear verdict on which CLI won for which step.

The brief: a small web app with three features — fetch a list of items, render a chart, save a user note. Total scope: ~30 minutes of agent work, ~150 lines of code, one integration test.

Step 1: research scaffold on Perplexity Computer. Don't write code yet. Open Perplexity Computer, send the brief, let it fan out parallel agents. The output is a finished scaffold — file structure, a wireframe, a sample data shape, a test plan. No code written, but the structure is decided. Time: ~3 minutes.

Step 2: controlled build on Claude Code. Open Claude Code, paste the scaffold from step 1 as the brief, force plan mode + agent teams. Approve the plan. Watch the sub-agents fan out and write the three features in parallel. Time: ~15 minutes. Output: a clean diff, three working features, a test suite.

Step 3: cheap loop on Kilo Code + Mimo V2 Pro. Open Kilo Code, BYOK Mimo V2 Pro (free), re-run the same brief. Output: a working app, but with rougher edges — Mimo's 55% WildClaw success rate shows up in the diff. Time: ~20 minutes (slower than Claude Code because Mimo is less reliable on the first pass).

Step 4: /model hot-swap to escalate. When Mimo V2 Pro starts misbehaving on the security-sensitive parts (the user-note save, the auth check), /model swap to Minimax M2.7 (or GPT 5.4 if you have the budget). The session context carries the rough draft over; the new model patches the failing steps.

Step 5: review pass on Claude Code. Open the diff in Claude Code's plan mode, run the test suite, diff against the original scaffold. The orchestrator (Claude Code in plan mode) reviews the executor's (Mimo + Minimax) output and flags the rough edges.

The verdict:

Perplexity Computer won step 1. The research scaffold was faster and cleaner than either Claude Code or Kilo Code could have produced. The channel's framing: "you don't really need to know any code" — Perplexity's no-code output is the right shape for the research step.
Claude Code won step 2. The controlled build, with plan mode + agent teams, produced a cleaner diff than Kilo Code + Mimo could match. The process visibility is the difference — you can see the plan, audit the sub-agents, and review the diff.
Kilo Code won step 3. The cheap loop, with Mimo V2 Pro free and Minimax M2.7 as the fallback, cost literally $0 for the executor step. The same workflow on Claude Code + Opus would have been $5–$10 in tokens.
The hot-swap won step 4. When Mimo started misbehaving, the swap to Minimax fixed the failing steps without losing the rough draft. The escape hatch worked.
The review pass won step 5. Claude Code's plan-mode review caught the rough edges Mimo + Minimax left behind. The orchestrator's job is the review.

Total time: ~45 minutes (research + build + cheap loop + review). Total cost: $0 in tokens (Kilo Code's $9/month harness + free Mimo V2 Pro) + Claude Code's plan-mode review pass (Sonnet or a cheap backend, ~$1). The same brief on Claude Code + Opus 4.6 alone would have been ~$15–$30 in tokens. The "all three" pattern is cheaper and cleaner.

A second worked example: the "no CLI" case

Not every workload fits the three-CLI stack. The channel's coverage flags two "no CLI" cases:

Browser-driven QA. If the task is "verify the user-facing flow works in a real browser," none of the three CLIs is the right tool. Claude Code running Playwright blind doesn't record; Perplexity Computer's parallel agents don't have a browser; Kilo Code + Mimo hallucinate on visual references. The right tool is KaneAI — a real-browser agent that records video, runs unattended, and ties into Jira for team pipelines. The channel's framing: "this is the tool you reach for when you want to make money with your app, not the tool you use to write the app."
Full root access, custom ports, self-hosted control. If the workload needs to host a web server, expose non-OpenClaw services, or run on your own hardware, KiloClaw's no-port-access limitation is a blocker. The right tool is a self-hosted OpenClaw instance on a $3/month VPS — you get full root access, custom ports, and the same OpenRouter backend. The channel's reference: the How to Build Your OpenClaw AI Agent the RIGHT Way video, with the $6/month 2 GB VPS recommendation (up from $2 at promo).

The "no CLI" cases are not failures of the 3-way race — they're the edges where a different tool is the right shape. The capstone's lesson is "match the slot to the workload," and sometimes the slot is outside the three CLIs.

A third worked example: the cost-only comparison

The same brief, run on each CLI in isolation, with the cost frame:

CLI	Harness cost	Model cost (5-hour run)	Total	Quality
Claude Code (Opus 4.6)	$200/month Max plan	~$15–$30 in tokens (5-hour run)	$215–$230	51% WildClaw, but stronger on the side-by-side brief
Claude Code (Minimax M2.7 routed)	$200/month Max plan	$0 (token-plan flat)	$200	60–70% WildClaw, near-Opus for executor work
Perplexity Computer	$176/month flat	$0 (included)	$176	Variable — no public benchmark; the side-by-side test passed
Kilo Code + Mimo V2 Pro (free)	$9/month	$0 (free window)	$9	55% WildClaw, "high-volume king"
Kilo Code + Minimax M2.7 (Plus)	$9/month	$0 (Plus plan flat)	$9	60–70% WildClaw, near-Opus for executor work
Kilo Code + GPT 5.4	$9/month	~$5–$10 in tokens (5-hour run)	$14–$19	63–75% WildClaw, "new orchestrator king"

The cost frame tells the story. The same brief on Claude Code + Opus 4.6 is 24× the cost of Kilo Code + Mimo V2 Pro, with a quality delta that's mostly configuration (plan mode + agent teams). The 3-way race isn't a quality race — it's a cost and shape race. Match the slot to the workload, and the cost falls out of the slot choice.

The table also surfaces the "all three" answer in concrete terms. A serious coding workflow uses Claude Code for the controlled build (~$5 in tokens for a 30-minute build), Kilo Code + Mimo for the cheap loop ($0 in tokens for the same build), and Perplexity Computer for the research scaffold ($0 incremental cost, since the Max plan is a flat subscription). The combined cost is the highest single line — Claude Max at $200/month — but the per-build cost is the lowest of any single-CLI setup.

A fourth worked example: the "all three in one session"

The capstone's most ambitious pattern: a single coding brief that uses all three CLIs in sequence, with the hot-swap as the bridge.

Step 1: Perplexity Computer — research scaffold. Send the brief, let parallel agents fan out, get a finished structure. Time: ~3 minutes.

Step 2: Claude Code — controlled build. Paste the Perplexity scaffold, force plan mode + agent teams, approve the plan. The build runs in parallel. Time: ~15 minutes.

Step 3: Kilo Code + Mimo V2 Pro — cheap loop. Open Kilo Code in a second window, BYOK Mimo, paste the Claude Code diff, run a cheap executor pass. The rough edges show up. Time: ~20 minutes.

Step 4: Kilo Code + Minimax M2.7 — /model hot-swap. When Mimo starts misbehaving, swap to Minimax. The session context carries the rough draft over; the new model patches the failing steps. Time: ~10 minutes.

Step 5: Claude Code — review pass. Open the final diff in plan mode, run the test suite, audit the executor's output. The orchestrator reviews and flags the rough edges. Time: ~10 minutes.

Step 6: KaneAI — overnight regression test. Run a real-browser flow against the finished app, record the video, post the link to the morning thread. Time: overnight, unattended.

Total time: ~60 minutes of active work, plus overnight regression.

Total cost: $0 in tokens (Kilo Code + Mimo free window) + ~$1 for Claude Code's plan-mode review (Sonnet) = $1 incremental, on top of the harness subscriptions ($9 KiloClaw + $200 Claude Max + $176 Perplexity Max = $385/month, but only if all three are active).

The verdict: the multi-CLI session produces a cleaner output than any single CLI could match, at a per-build cost that's lower than Claude Code + Opus alone. The harness subscriptions are the fixed cost; the per-build cost is the variable. The "all three" pattern is the channel's working position in 2026, and the worked example is the receipts.

The session is also a stress test for the hot-swap. Step 4 is the load-bearing step — if the /model swap doesn't work mid-task, the whole pattern collapses to a single-CLI setup. The channel's framing is that the hot-swap is the operational form of the multi-CLI stack: it's the bridge that lets a single brief use multiple CLIs without losing the work-in-progress.

The hot-swap in step 4 is intra-CLI (Kilo Code Mimo → Kilo Code Minimax), not inter-CLI. The inter-CLI version of the pattern would be to copy the session context (the brief, the plan, the diff, the test results) from one CLI to another. The channel's framing is that the inter-CLI hot-swap is a manual operation, not a turnkey feature.

The failure modes the matrix hides

The decision matrix is a starting point, but the channel's coverage flags four failure modes that the matrix doesn't surface:

1. Perplexity Computer's Max-plan gating

The $176/month Max plan is the only way to access Perplexity Computer. The Pro plan is blocked, "the scammy part" — you can't unlock it on an existing Pro subscription. If you already pay for Claude annually, switching costs both money and the process visibility Claude Code gives you. The matrix hides this: "cost: $176/month flat" is correct, but the switching cost is not in the row.

The fix: reserve Perplexity Computer for the use case where parallel-agent orchestration actually pays back (multi-source research, dashboard builds, scheduled report runs) and route single-shot scaffolds through Kilo Code + a free model.

2. Claude Code's plan-mode requirement

Default Claude Code is single-track and will brute-force a parallel problem unless you tell it not to. The matrix says "process visibility: high" but the cost of that visibility is the plan-mode + agent-teams configuration. If you skip it, Claude Code looks like a worse Perplexity Computer.

The fix: always force plan mode + agent teams before any non-trivial build. The channel's framing: "this is the single biggest mistake."

3. Kilo Code's OpenRouter dependency

Kilo Code is OpenRouter-native, which is the whole point — but it means Kilo Code is only as good as your OpenRouter configuration. If you don't have a key, or the key is rate-limited, or the model you picked is down, Kilo Code is offline. The matrix says "BYOK / model choice: native" but the dependency is not in the row.

The fix: set up the OpenRouter key and the model in advance. Don't reach for Kilo Code as a backup after Claude Code fails; have it configured as a parallel harness from day one.

4. The hot-swap's pre-configuration rule

The escape hatch only works if the second model is already configured. The matrix says "escape hatch: native" but the cost is the up-front setup. If you have to install Kilo Code, add an OpenRouter key, and configure the second model after Opus 4.6 starts ignoring your Skills, you've already lost the work-in-progress.

The fix: install the second harness, add the second key, verify the second model works before the primary model starts failing. The setup cost is paid up front; the recovery cost is paid on demand.

The escape-hatch chain

The capstone's deeper lesson is the escape-hatch chain — when one CLI fails, the next one is already configured. The chain is:

Primary harness: Claude Code (with Minimax M2.7 routed in via env-var swap, per §2.2 and Course 4 §4.2).
First fallback: Kilo Code (with Mimo V2 Pro BYOK while free, or Minimax M2.7 as the paid fallback).
Second fallback: Perplexity Computer (for research scaffolds and parallel reports, when the coding harness is blocked).
Last resort: hot-swap to a different model in the same harness, using /model (Hermes) or the model selector (Kilo Code / Codex).

The chain is pre-configured, not assembled on demand. The channel's framing is consistent: "set up your backup model in advance, don't reach for it after the failure." If you're using Claude Code as the primary, Kilo Code should be open in a second window. If you're using Kilo Code as the primary, the OpenRouter key for Minimax should already be in the model menu.

The chain has a fifth rung the channel's coverage flags: when the harness is the wrong shape, the right answer is KaneAI or a self-hosted OpenClaw. The "no CLI" cases from the worked example are the chain's exits — when all three CLIs are wrong, the recovery is a different tool, not a different configuration.

The escape-hatch chain in detail

Each rung of the chain has a specific failure mode it's designed to recover from, and a specific configuration the channel's coverage recommends:

Rung 1 — Claude Code (primary). The default harness. Configured with the env-var swap from Course 4 §4.2: ANTHROPIC_AUTH_TOKEN set to the Minimax token-plan API key, base URL https://api.minimax.io/anthropic. The harness is Anthropic-flavored (plan mode, agent teams, Claude.md context engine) but the backend is cheap. The failure mode this rung covers: any coding task that needs process visibility, multi-agent fan-out, or security-sensitive review.

Rung 2 — Kilo Code (first fallback). The BYOK alternative. Configured with an OpenRouter key for Mimo V2 Pro (free) or Minimax M2.7 (paid). The harness is a VS Code fork with full file access. The failure mode this rung covers: when Claude Code's harness is too restrictive (no port access, no custom MCPs) or when the model is the bottleneck (Mimo V2 Pro hallucinating, Minimax in the dumb zone).

Rung 3 — Perplexity Computer (second fallback). The parallel-agent alternative. Configured with the $176/month Max plan. The harness is a closed sandbox with no code output, but with parallel-agent orchestration and built-in scheduling. The failure mode this rung covers: when the task is research-heavy (multi-source research, dashboard builds, scheduled report runs) and the coding harness is overkill.

Rung 4 — Hot-swap (last resort). The intra-CLI model swap. Configured in advance with two or more models wired up. The failure mode this rung covers: any single-model failure — Opus 4.6 ignoring Skills, Minimax in the dumb zone, Mimo hallucinating, GLM burning through a 5-hour allowance.

Rung 5 — KaneAI or self-hosted OpenClaw (chain exit). The "no CLI" cases. KaneAI for browser-driven QA; self-hosted OpenClaw on a $3/month VPS for full root access. The failure mode this rung covers: when all three CLIs are wrong — the task needs a browser, or custom ports, or self-hosted control.

The chain is a layered defense, not a single point of failure. Each rung covers a specific failure mode; the next rung covers the failure of the previous one. The channel's framing is that the chain is "pre-configured, not assembled on demand" — the setup cost is paid up front, the recovery cost is paid on demand.

The cost frame for the escape-hatch chain

Each rung has a cost, and the costs don't stack linearly:

Rung 1 (Claude Code): $200/month Max + $0–$30 in tokens per build, depending on backend.
Rung 2 (Kilo Code): $9/month KiloClaw + $0 (Mimo free) or $10–$20/month (Minimax Plus).
Rung 3 (Perplexity Computer): $176/month Max.
Rung 4 (Hot-swap): $0 incremental — same harness, different model.
Rung 5 (KaneAI / self-hosted): $0–$10/month for KaneAI, $3–$6/month for a self-hosted VPS.

The minimum viable stack — Rung 1 + Rung 2 + Rung 4 — costs $209/month. Add Rung 3 for the research-scaffold use case, and the total is $385/month. Add Rung 5 for the "no CLI" cases, and the total is $398/month (KaneAI is essentially free; the VPS is $3–$6/month).

The channel's recommendation for most users: start with Rung 1 + Rung 2 + Rung 4 ($209/month, or $9/month if you skip Claude Max and use a cheap routed backend), and add Rung 3 only when the research-scaffold use case actually pays back. Most users don't need Perplexity Computer's parallel-agent orchestration more than once a quarter — the $176/month is steep for occasional use.

Try it yourself

The hands-on goal: reproduce the channel's "all three" working stack, end-to-end, on a real coding brief.

Pick a brief. A small web app with three features — fetch, render, save. Total scope: ~30 minutes, ~150 lines, one integration test.
Configure all three CLIs in advance. Claude Code (Node CLI, Anthropic-authenticated). Perplexity Computer (Max plan, $176/month — only if you don't have it already). Kilo Code (VS Code fork, OpenRouter BYOK with Mimo V2 Pro while free and Minimax M2.7 as the fallback).
Run the research scaffold on Perplexity Computer. Don't write code. Send the brief, let it fan out, capture the scaffold. Time the run.
Run the controlled build on Claude Code. Paste the scaffold, force plan mode + agent teams, approve the plan, watch the sub-agents. Time the build.
Run the cheap loop on Kilo Code + Mimo V2 Pro. Re-run the same brief, BYOK Mimo. Note the rough edges. Time the build.
Hot-swap when Mimo misbehaves. When the security-sensitive parts (auth check, user-note save) start failing, /model to Minimax M2.7. Confirm the swap is mid-task, not a fresh session.
Review on Claude Code in plan mode. Open the final diff, run the test suite, audit the executor's output. The orchestrator's job is the review.
Compare the three outputs. Perplexity's scaffold vs Claude Code's diff vs Kilo Code's rough draft. The verdict is rarely "one CLI wins" — it's almost always "Perplexity for research, Claude Code for the controlled build, Kilo Code for the cheap loop."
Lock in the combo stack. Pick your default harness, pick your fallback model, pick your review orchestrator. The escape-hatch chain is pre-configured, not assembled on demand.
Document the failure modes you hit. The matrix hides them; the worked example surfaces them. Note which axis each failure mode hit, and add it to your team's pre-flight checklist.

The "if I had to start over" sequence

A condensed 60-minute sequence for users who want the "all three" pattern without the full evaluation:

Minutes 0–5: Sign up for the KiloClaw free trial. Create an instance. Wire Telegram.
Minutes 5–10: Get a Mimo V2 Pro key from the News Portal (free). Add the provider to KiloClaw. Switch the model.
Minutes 10–15: Install Claude Code (Node CLI). Authenticate against your Anthropic account. Default to Sonnet.
Minutes 15–20: Edit Claude Code's settings.json with the env-var swap to Minimax M2.7. Verify the swap took.
Minutes 20–30: Run a real coding brief — a refactor, a content-inventory script, an integration test. Send it through Claude Code with plan mode + agent teams.
Minutes 30–40: Open the same brief in Kilo Code + Mimo V2 Pro. Time the build. Note the rough edges.
Minutes 40–50: Hot-swap in Kilo Code from Mimo to Minimax when Mimo starts misbehaving. Confirm the swap is mid-task, not a fresh session.
Minutes 50–60: Review the final diff in Claude Code's plan mode. Audit the executor's output. Lock in the combo stack.

The sequence ends with a working multi-CLI stack and a documented pre-flight checklist. The total cost is $9/month (KiloClaw) + $0 in tokens (Mimo free window, Minimax Plus flat) + Claude Code's Anthropic subscription (whatever tier you have). For a user starting from scratch, the cap is $209/month (Claude Max + KiloClaw), with the option to drop to $9/month if you skip Claude Max and use only the cheap routed backend.

The "if I had to start over" sequence is the channel's recommended minimum viable stack: Kilo Code + Mimo for the cheap loop, Claude Code for the controlled build, /model hot-swap as the bridge. Perplexity Computer is the optional add-on for users who do research-heavy work often enough to justify the $176/month.

The pre-flight checklist

A pre-flight checklist for any serious coding brief, distilled from the channel's coverage:

Pick the slot. Research scaffold (Perplexity), controlled build (Claude Code), cheap loop (Kilo Code + Mimo), review (Claude Code in plan mode), or QA (KaneAI).
Configure the harness in advance. Don't wait for the failure. Install Kilo Code, add the OpenRouter key, verify the Mimo V2 Pro model. Edit Claude Code's settings.json with the env-var swap. Wire Telegram on the KiloClaw instance.
Set up the backup model. For Claude Code, the backup is Minimax M2.7 (env-var swap). For Kilo Code, the backup is Mimo V2 Pro (free) or Minimax M2.7 (Plus plan). The escape hatch is the second model — set it up before the first one fails.
Compress soul.md and agents.md to 15–30 lines if you're using a long-running OpenClaw agent. The dumb zone is the failure mode that makes the hot-swap load-bearing.
Pick a brief scope. A small web app with three features is the right size for a 30-minute capstone. A refactor is the right size for a 1-hour calibration. A multi-file refactor is the right size for a half-day capstone.
Time the build. Both single-CLI and multi-CLI runs should be timed. The cost frame is the per-build spend, not the per-token rate.
Audit the diff. The review pass is the orchestrator's job. Claude Code in plan mode is the channel's pattern.
Run KaneAI overnight. The video replay beats a stack trace. The closing step is the verification step.

The pre-flight checklist is the channel's "what to do before you start a serious coding brief" answer in eight lines. The combo stack is the working position; the pre-flight checklist is the setup; the hot-swap is the bridge.

Common pitfalls

Picking one CLI for everything. The channel's working position in 2026 is "all three, in different slots." Picking one CLI is the failure mode the side-by-side was designed to surface — the gap between Claude Code and Perplexity Computer is mostly configuration, but the gap between Kilo Code and Claude Code is model choice, not configuration.
Treating the matrix as a verdict. The decision matrix is a starting point, not a verdict. The channel's pattern is to use all three in the same workflow. The matrix hides the escape-hatch chain; the worked example shows it.
Skipping the up-front configuration. The escape hatch only works if the second model is already configured. Don't reach for Kilo Code after Claude Code fails; have it open in a second window from day one.
Letting Mimo V2 Pro handle security-sensitive work. The 55% WildClaw success rate is fine for high-volume non-critical tasks. For security-sensitive or money-handling code, escalate to a more reliable model. The /model swap is the operation that lets the session escalate.
Trusting the Mimo V2 Pro free tier for production-critical workflows. The free period is promotional. Build the skill library now, but don't lock in tooling that only works with Mimo V2 Pro. Plan for the migration.
Routing Claude Code + Opus for executor work. The WildClaw data is clear: Opus scored 51% but cost $80 per suite, while GPT 5.4 was close at a quarter of the cost. Use Opus only for orchestrator planning if you must; route execution to Minimax M2.7, Mimo V2 Pro, or Kilo Code + a cheap model.
Forgetting the review pass. The orchestrator's job is the review. Claude Code in plan mode is the channel's pattern for the final diff audit. Skip the review pass and you're back to "the agent said it's done, no idea what's happening on the screen."
Reading "all three" as "use all three at once." The pattern is match the slot to the workload — research on Perplexity, build on Claude Code, executor on Kilo Code. You don't run all three in parallel; you move between them as the task shape changes.
Paying for the Max plan on Perplexity when Kilo Code + Mimo is free. $176/month Max vs $9/month KiloClaw + free Mimo V2 Pro is a 19× cost difference for comparable coding-agent output. Reserve Perplexity Computer for the specific use cases where parallel-agent orchestration actually pays back.
Skipping KaneAI on the closing step. Vibe-coded apps from any of the three CLIs need browser verification. The video replay beats a stack trace. If your tool doesn't record, you're back to Playwright-without-screenshots.
Hosting custom web apps on KiloClaw. No port access. Use KiloClaw for the agent, a separate VPS for hosting. The platform is great for one thing — a hosted OpenClaw instance — and the wrong shape for "I also want to host my portfolio site."

Closing: the 3-way race in one paragraph

The 3-way race between Claude Code, Perplexity Computer, and Kilo Code is a race between three different shapes, not three different products. Claude Code is the right shape when you need control — plan mode, agent teams, process visibility, security-sensitive review. Perplexity Computer is the right shape when you need parallel-agent orchestration — multi-source research, dashboard builds, scheduled report runs, no-code output. Kilo Code is the right shape when you need BYOK — OpenRouter-native, any model, Mimo V2 Pro free window, VS Code fork. The hot-swap is the bridge that lets a single session cross between them. The escape-hatch chain is the layered defense that keeps the build alive when one CLI fails. The combo stack is the practical position: "all three, in different slots," not "pick one."

The channel's working stack in 2026 is a multi-CLI, multi-model stack. The harness subscriptions are the fixed cost ($9–$385/month depending on which rungs of the escape-hatch chain you activate). The per-build cost is the variable ($0–$30 depending on which models you route and how heavy the build is). The verdict on which CLI wins is almost never "one CLI wins" — it's almost always a slot-by-slot answer: Perplexity for research, Claude Code for the controlled build, Kilo Code for the cheap loop, KaneAI for the closing test pass.

The deeper lesson is that the question "which CLI?" is downstream of the question "which slot?" The slot is determined by the workload shape (research, build, executor, review, QA), the budget frame (per-build cost vs harness cost), and the process-visibility requirement (plan mode vs parallel-agent vs BYOK). Pick the slot first; the CLI follows. The hot-swap is what lets the slot change mid-build. The escape-hatch chain is what keeps the build alive when the slot is wrong. The combo stack is the working position when the workload is mixed.

The course has walked through all three subtopics in turn: the side-by-side that framed the race (§2.1), the BYOK-on-Kilo pattern that unlocked the cheap executor (§2.2), the hot-swap that tied the three together (§2.3), and the decision matrix that synthesizes them (§2.4). The capstone is a 30-minute coding brief executed three ways, with a clear verdict on which CLI won for which step. The answer is "all three" — and the answer is also "match the slot to the workload." Both are true.

The 3-way race as a forecasting exercise

A year ago, the channel's coding-CLI coverage was a binary question: Claude Code or not Claude Code. The 3-way race framing is a recent shift, driven by three specific events:

Perplexity Computer's launch (Q4 2025) — the first credible no-code parallel-agent alternative to Claude Code. Forced the channel to ask "what does Claude Code win on, exactly?"
The Anthropic-limit controversy (March/April 2026) — Anthropic silently tightened the 5-hour rolling window for Pro/Max/Max 20x subscribers. Forced the channel to ask "is the consumer tier reliable enough to plan around?"
Kilo Code + Mimo V2 Pro's BYOK pattern (early 2026) — the first credible OpenRouter-native coding harness with a free-tier model. Forced the channel to ask "is the lock-in worth it?"

Each event pushed the channel's coverage toward the multi-CLI framing. The 3-way race isn't a theoretical position — it's a response to three concrete market shifts. The capstone's "all three" answer is the channel's working position in mid-2026; the question is whether the position holds as new CLIs ship and new models free-tier.

The forward-looking question: what's the fourth slot in the race? The channel's coverage flags two candidates:

Codex (OpenAI's coding agent). Already a viable harness for GPT-5.4-class builds, with the same /model mid-task swap as Hermes. The channel's coverage of the Opus regression included "agent work moving to Kilo Code and Codex so models can be hot-swapped mid-task" — Codex is the OpenAI-flavored fourth slot.
A self-hosted OpenClaw with a Claude Code-style harness. The skill layer + the OpenRouter backend + the Claude Code interface is a buildable product, and the channel's coverage of the How to Build Your OpenClaw AI Agent the RIGHT Way video lands on the architecture. The fourth slot is the "build it yourself" option — full control, no platform lock-in, but you own the maintenance.

The 3-way race is the 2026 framing; the 4-way race is the 2027 projection. The combo stack's escape-hatch chain has a fifth rung for the "no CLI" cases; the 4-way race has a fourth rung for the "build it yourself" case. The channel's framing is consistent: pick the shape that matches the workload, and let the slot change as the workload changes.

A note on the Mimo V2 Pro free-window urgency

The Mimo V2 Pro free window is a time-stamped promo. The channel's framing is consistent across the Mimo coverage: "try it NOW while it's free" and "the free period is promotional and will end eventually." The transition plan is concrete: build the skill library now, pick a fallback model (Minimax M2.7 or GPT 5.4), and migrate gradually when the free period ends.

The free window is also what makes the "BYOK-on-Kilo" pattern the channel's recommended default. Kilo Code + Mimo V2 Pro costs $9/month + $0 in tokens during the free window — 19× cheaper than Perplexity Computer, and the model is yours to swap. The post-promo Mimo V2 Pro price ($20–$40/month) is competitive with Minimax M2.7 ($10–$20/month) but more expensive; the migration path is to Minimax M2.7 for executor work and GPT 5.4 for orchestrator planning.

The urgency is real, not marketing. The channel's pattern is to exploit the free window while it's open, build the skill library on Mimo, and migrate the model underneath when the promo ends. The skills carry over; the model is the variable.

A note on the Anthropic-limit window

The Anthropic 5-hour rolling window can be tightened at any time without changelog notice. The channel's Anthropic-limit controversy coverage documents the late-March / early-April 2026 tightening, and the follow-up Anthropic admits fault video shows that the limit was partially rolled back after community pressure. The framing: don't plan around the consumer tier's rate limits — they can change.

The mitigation: the env-var swap from Course 4 §4.2 lets you point Claude Code at Minimax M2.7 (or any third-party model) on a flat-rate coding plan. The harness is Anthropic-flavored, but the backend is predictable. The hot-swap is the operation that lets the session escalate to a different model when the rolling window tightens.

The mitigation also covers the Kilo Code path: the OpenRouter backend is independent of Anthropic's rolling window, so the Kilo Code + Mimo V2 Pro + Minimax M2.7 stack is unaffected. The escape hatch is the second model — set it up before the first one rate-limits.

A note on "all three" in the long term

The "all three" position is the channel's working answer in mid-2026, but the long-term question is whether the position holds. The 4-way race framing (Claude Code + Perplexity Computer + Kilo Code + Codex) is the 2027 projection. The 5-way race (add a self-hosted OpenClaw with a Claude Code-style harness) is the 2028 projection. Each new entrant shifts the matrix and adds a row.

The long-term answer the channel's coverage implies: the slot is durable, the CLI is replaceable. The slot ("controlled build," "research scaffold," "cheap loop," "review pass," "QA") is the workload shape; the CLI is the implementation. If a new CLI takes over the "controlled build" slot, the matrix updates, but the slot doesn't. The hot-swap is what makes the slot change survivable.

The capstone is a 30-minute coding brief executed three ways, but the deeper pattern is "match the slot to the workload, with the hot-swap as the bridge." That pattern survives any new CLI that lands in 2027. The matrix updates; the slot persists; the hot-swap is the operational form.

The five takeaways

The course's five core takeaways, in the channel's framing:

The 3-way race is a race between shapes, not products. Claude Code = control, Perplexity Computer = parallel, Kilo Code = BYOK. Each wins in a different slot; the channel's working position is "all three, in different slots."
The hot-swap is the bridge. /model mid-session in Hermes (since v0.8), in Kilo Code / Codex, and inside Claude Code's plan-mode review. The escape hatch is the second model — set it up before the first one fails.
The BYOK-on-Kilo pattern unlocks the cheap executor. Mimo V2 Pro is free through Kilo's partner providers; Minimax M2.7 is $10–$20/month on the Plus plan. The skill library is the long-term memory; the hot-swap is the short-term operation.
The combo stack is the working position. Pair a smart orchestrator (GPT 5.4, Opus 4.6) with a cheap executor (Minimax M2.7, Mimo V2 Pro) and /model between them. The combo stack's per-build cost is the lowest of any single-CLI setup.
The escape-hatch chain is the layered defense. When one CLI fails, the next one is already configured. Rung 1: Claude Code. Rung 2: Kilo Code. Rung 3: Perplexity Computer. Rung 4: hot-swap. Rung 5: KaneAI or self-hosted OpenClaw.

The five takeaways are the course's compressed output. The rest of the course is the receipts — the worked examples, the failure modes, the cost frame, the matrix, the Sources block. The takeaways are what to internalize; the receipts are how to verify.

A note on reading the course

The course is structured to be read in order, but the capstone (§2.4) and the hot-swap (§2.3) are the load-bearing pieces. §2.1 (the side-by-side) and §2.2 (Kilo Code) provide the context; §2.3 and §2.4 are the operational form. If you only have time for two articles, read §2.3 and §2.4. If you only have time for one, read §2.4 — it synthesizes the other three.

The Sources block at the end of each article is the receipts. Every claim that requires a citation has one; every video that informs an article is listed. The Supabase query at the end of each Sources block is the verification path — you can run the query against the project and confirm the transcripts and summaries.

The course's structural note: §2.1 is the entry point, §2.2 is the cheap-executor unlock, §2.3 is the operational form, §2.4 is the structural form. The capstone is the worked example that ties them all together. The cross-references in the Sources blocks are the navigation — the course is one of many in the BoxminingAI courses library, and the cross-references tell you which other courses extend the same coverage.

The final note: the 3-way race is a snapshot. The "all three" answer is the channel's working position in mid-2026. The matrix updates as new CLIs ship and new models free-tier. The hot-swap is the bridge that survives any update. The capstone is the receipts.

Sources

All videos referenced across the course 2 syllabus have has_transcript = true and has_summary = true in public.videos as of 2026-06-18. Aggregated below, with view counts and the role each video plays in the "all three" pattern.

Perplexity Computer Just KILLED Claude Code (Side-by-Side Test) — 18,483 views · video_id: E4gc4-9O1JE · the side-by-side that frames the race · cited: Perplexity $176/month Max plan, Claude Code plan-mode + agent-teams override, process visibility moat, "Opus 1.6" / Opus 4.6 interchangeable naming
KiloClaw one-click — video_id: Bpwu_1JpbCQ · the Kilo Code / KiloClaw install guide · cited: 60-second deployment, 29-day free trial ($2.50 credits), $9/month plan, 2 CPU / 3 GB RAM / 10 GB SSD, full OpenClaw instance, dashboard, approvals system, Telegram BotFather integration, "Edit Files" view, Kilo AutoBalanced default model
Top AI Models for Hermes Agent (Tier List) — 8,107 views · video_id: Af7Fg1m7hRw · the /model hot-swap and the BYOK model menu · cited: orchestrator vs executor framework, v0.8 hot-swap feature (~two weeks before video), GPT 5.4 as new orchestrator king, GLM 5.1 as standout executor, Mimo V2 Pro high-volume king, Qwen 3.6 Plus reasoning persistence, Kimi 2.5 swarm agents, WildClaw scores, combo stack recipes
Xiaomi MiMo V2 Pro: Complete Guide — video_id: liSNV7kPnYg (Course 17) · the Mimo V2 Pro deep-dive · cited: ~55% WildClaw success rate, $26 paid-suite cost, free period is promotional, News Portal / Kilo.ai / OpenRouter access, Hermes Agent partnership, Xiaomi financial backing, free extended access via Kilo Code partner providers, budget combo ($0/month), paid combo ($60–$95/month), Hermes skill generation, hot-swap strategy
Claude Code + Minimax 2.7: Unlimited AI Coding on a Budget — 6,532 views · video_id: dURSH_Fwu6s · the Claude Code env-var swap · cited: 4,500/5h Plus and 15,000/5h Max token-plan request limits, settings.json config, trailing-comma JSON gotcha, Kilo Code / Open Claude / Grok CLI transfer, overnight-build arithmetic
Is Minimax the Best AI Model for OpenClaw? — 3,219 views · video_id: 258R3kzDRAQ · the dumb-zone failure mode that makes the hot-swap load-bearing · cited: 300-line soul threshold, 15–30 line compressed target, M2.1/M2.5 reinstall fix, scrape-and-cron workflow, $30/hour Opus burn, $0.30/M vs $5/M cost ratio
Best Model for Openclaw (WildClaw Benchmarks!) — 4,574 views · video_id: 31Ij4Cum5tg · the model-picking framework · cited: 51% Opus / $80, GPT-5.4 cheaper, Mimo V2 $26, Grok 94min vs ~500min, coding-plan beats token-plan framing, M2.7 internal usage on Loki/Gambit agents
Anthropic pulled a fast one on us! (Opus plans LIMITED) — 24,059 views · video_id: MkabEkgGpjA · the Anthropic-limit controversy · cited: 5-hour rolling window tightened, "feature not a bug" framing, Mythos / Mephisto / Glasswing successor models, $20–$200/mo consumer tier squeezed
Anthropic admits fault (Claude limits to be INCREASED) — 9,673 views · video_id: WiAx9sPw69U · the follow-up · cited: Lydia's "way faster than expected" admission, 50% weekly limit on 8 prompts, computer use shipped in Claude Code
Claude Fable 5 + Loop Designs is TOO STRONG! (Full Tests) — 3,482 views · video_id: 8De7s6WG7Bo · the "Claude is back" counterweight · cited: 11/11 self-QC checks, loop syntax harness, $16/project cost, June 21–22 cheap-window close, Fable 5 = new "Opus" / Opus 4.8 = "Sonnet"
KaneAI: The Best AI Coding Assistant — 9,240 views · video_id: KcoId-HwOD4 · the test-runner that closes the loop · cited: real-browser QA, video replay for LLM debug, hidden sign-up button demo, magic-link send, overnight regression pattern, Jira integration
How to Build Your OpenClaw AI Agent the RIGHT Way — 2,690 views · video_id: Zkw8jIDzspc · the infrastructure layer · cited: $6/month 2 GB VPS, 6-line soul rule, Mac Mini failure mode, "made up the numbers" honesty warning, Jeff Goldblum persona liability
Supabase query — SELECT video_id, title, views, summary_content, summary_key_takeaways FROM public.videos WHERE video_id = ANY(ARRAY['E4gc4-9O1JE','Bpwu_1JpbCQ','Af7Fg1m7hRw','liSNV7kPnYg','dURSH_Fwu6s','258R3kzDRAQ','31Ij4Cum5tg','MkabEkgGpjA','WiAx9sPw69U','8De7s6WG7Bo','KcoId-HwOD4','Zkw8jIDzspc']); against project ttxdssgydwyurwwnjogq. All 12 video_ids have has_transcript = true and has_summary = true as of 2026-06-18.
public.ai_models — confirmed rows include claude-opus-4-6 (Anthropic), claude-opus-4-7 (Anthropic), claude-sonnet-4-6 (Anthropic), minimax (MiniMax M2.7), minimax-m2-5 (MiniMax), openai (GPT-5.4), xiaomi-mimo (Mimo V2 Pro), grok (xAI), glm-5-1 (Zhipu AI), kimi (Moonshot K2.5/2.7), qwen-3-6-plus (Alibaba), deepseek (DeepSeek V4 Pro). Vendor names used in the course cross-match these rows. The pricing_info column is null for every row pulled — token-level rates cited in the course come from the video transcripts, not from the DB.
public.ai_updates — searched 2026-06-18 with title ~* '(claude code|perplexity computer|kilo code|kiloclaw|mimo|minimax|hot.?swap|model)' against the ai_updates table. No rows match the specific CLI-comparison coverage in this course; the closest are AI Briefing 2026-05-03 (notes 1M context as a competitive baseline) and Anthropic Plan Limit Changes 2026-04 (the Anthropic-limit controversy from Course 4 §4.2). The CLI-race framing here is sourced from the videos themselves, not from the AI-briefings table.
Cross-references to the syllabus sections this course teaches into: Course 4 §4.1 (the Claude Code deep-dive, including the Fable 5 / Loop Designs and KaneAI writeups), Course 4 §4.2 (cheap-model routing, the env-var swap), Course 4 §4.5 (OpenClaw as a coding agent, the skills architecture, the 6-line soul rule, the $6/month VPS pattern), Course 1: OpenClaw (the agent platform the coding CLIs route into), Course 1 §1.5 (the skills architecture), Course 1 §1.7 (KaneAI cross-reference), Course 2 §2.1 (the model-choice framework, the four axes), Course 2 §2.2 (the Claude cost controversies), Course 3: Hermes Agent (the multi-agent successor where /model hot-swap gets its richest expression), Course 5: Setup, Hosting & Local Inference (where the coding agent actually runs, the self-hosted alternative to KiloClaw), Course 17: Xiaomi MiMo V2 Pro (the Mimo V2 Pro deep-dive, the combo stack recipes, the skill-generation trick).

NOTE on pricing, version numbers, and roadmap claims: the $176/month Perplexity Computer Max plan price, the $200/month Claude Max tier, the $9/month KiloClaw plan, the 29-day free trial with $2.50 credits, the 2 CPU / 3 GB RAM / 10 GB SSD spec, the Mimo V2 Pro 55% WildClaw success rate, the $26 paid-suite cost, the $20–$40/month post-promo Mimo V2 Pro price, the 4,500/5h Plus and 15,000/5h Max token-plan request limits on Minimax, the 300-line soul-file dumb-zone threshold, the 15–30 line compressed target, the $30/hour Opus burn, the $0.30/M vs $5/M Minimax vs Opus cost ratio, the 51% Opus / $80 WildClaw suite cost, the 94-minute vs ~500-minute Grok vs other-model runtime, the v0.8 Hermes release timing (~two weeks before the tier-list video), the Anthropic 5-hour rolling-window tightening, the Mythos / Mephisto / Glasswing successor-model names, the Fable 5 / Loop Designs benchmark numbers (29.3% Frontier Coding Diamond, 11/11 self-QC checks, $16/project cost), the June 21–22 Fable 5 cheap-window close, the 100-file Claude Code upload limit, the 40% Opus vs 63% GPT 5.4 Boxmining benchmark score, the $6/month 2 GB VPS reference price (up from $2 at promo), the Mimo V2 Pro free-period promo, and the Kilo AutoBalanced default model are all drawn from the source videos cited above. These are time-stamped claims — re-check the official Anthropic, Perplexity, and Kilo Code documentation if you read this course after a new release. The Mimo V2 Pro free-period end date is time-stamped and should be re-verified before signing up for the BYOK-on-Kilo pattern.

Supabase query — SELECT video_id, title, views, summary_content, summary_key_takeaways FROM public.videos WHERE video_id = ANY(ARRAY['E4gc4-9O1JE','Bpwu_1JpbCQ','Af7Fg1m7hRw','dURSH_Fwu6s','258R3kzDRAQ','31Ij4Cum5tg']); against project ttxdssgydwyurwwnjogq. All six video_ids in the 2.x syllabus have has_transcript = true and has_summary = true. Course 17 (Mimo V2 Pro) is the cross-listed source for the BYOK-on-Kilo pattern; its video_id is liSNV7kPnYg and it is also confirmed in public.videos as of 2026-06-18.
public.ai_models — confirmed rows include claude-opus-4-6 (Anthropic), claude-opus-4-7 (Anthropic), claude-sonnet-4-6 (Anthropic), minimax (MiniMax M2.7), minimax-m2-5 (MiniMax), openai (GPT-5.4), xiaomi-mimo (Mimo V2 Pro), grok (xAI), glm-5-1 (Zhipu AI), kimi (Moonshot K2.5/2.7), qwen-3-6-plus (Alibaba), deepseek (DeepSeek V4 Pro). Vendor names used in the course cross-match these rows. The pricing_info column is null for every row pulled — token-level rates cited in the course come from the video transcripts, not from the DB.
public.ai_updates — searched 2026-06-18 with title ~* '(claude code|perplexity computer|kilo code|kiloclaw|mimo|minimax|hot.?swap|model)' against the ai_updates table. No rows match the specific CLI-comparison coverage in this course; the closest are AI Briefing 2026-05-03 (notes 1M context as a competitive baseline) and Anthropic Plan Limit Changes 2026-04 (the Anthropic-limit controversy from Course 4 §4.2). The CLI-race framing here is sourced from the videos themselves, not from the AI-briefings table.
Cross-references to the syllabus sections this course teaches into: Course 4 §4.1 (the Claude Code deep-dive), Course 4 §4.2 (cheap-model routing, the env-var swap), Course 4 §4.5 (OpenClaw as a coding agent, the skills architecture), Course 1: OpenClaw (the agent platform the coding CLIs route into), Course 3: Hermes Agent (the multi-agent successor where /model hot-swap gets its richest expression), Course 5: Setup, Hosting & Local Inference (where the coding agent actually runs), Course 17: Xiaomi MiMo V2 Pro (the Mimo V2 Pro deep-dive).