AI Models & Assistants

All levels

Claude is our core — but the same skills travel. This section widens the lens to the whole AI world: the major assistants, how they differ, when to use which, and the techniques that transfer across all of them.

What you'll learn

• Pick the right model for a job without re-learning the field every time
• Move between assistants — ChatGPT, Gemini, Grok, open models — without losing your technique
• Run capable models on your own machine, and know when that is worth it
• Combine Claude with local models and agent frameworks

Start here

If you read one page in this section, read this one. Everything below is a branch off it.

• How to choose a model — a durable framework that outlives any particular release.

Then follow whichever thread matches what you are doing.

The current flagships

The September 2026 releases at the top of both stacks, read side by side.

• Claude Opus 5.5: the field guide — Anthropic's new recommended default: $4/$20, cache reads on a 5% tier, four 400-errors and one silent response-shape change
• Claude Fable 5.1: what changed and how to migrate — three breaking changes, five betas, cache reads at a quarter of the price
• GPT-6 Astra: the field guide for Claude users — same list price, different bill, Critical-tier cyber classification
• Gemini 4 Argon: the field guide for Claude users — Google's new generation: the 1M is the output limit (up from 64K), not the context window; why the independent index puts it five points behind Opus 5.5 despite the "frontier lead" headlines; 62K output tokens per task against Astra's 27K; and the Fairwind terms that mean you probably cannot call it

The workhorse tier

The cheap tier is where the interesting numbers are. Same lesson every time: match the model to the shape of the work, not to its position in the price list.

• Claude Sonnet 5.5: the field guide — Sonnet 5's exact prices, up to 30% less per task: five 400-traps, thinking that moves instead of switching off, and the one benchmark row where it beats Opus 5.5
• Claude Haiku 5.5: the 100K price cliff — the only current Claude model priced by prompt length: two rate cards 5x apart, where one token past 100,000 reprices the entire request; why the cliff arrives ~23% earlier in text than you expect; the honest saving (~87% below it, ~35% above, not the 90% on the rate card); and the one lever where trimming 21% of a prompt cuts 84% of the cost
• GPT-6.1 Sol: the field guide for Claude users — Sonnet 5.5's exact rate card at half its cached-read price: the 922K input ceiling inside a 1.05M window, the cost cliff at 272K, tool calling on only one of the two APIs, and the benchmark row Claude still wins by 8.7 points
• Gemini 3.8 Flash for Claude users — Sonnet-priced, "works harder" by default, ~30% more tokens per task
• DeepSeek-V4.1-Flash — 552B MIT open weight, 1M context, 890-byte KV cache, a 1–100 effort dial, and a routing change that silently replaced deepseek-v4-pro

Coming from another assistant

You already know one tool and want your habits to carry over.

• ChatGPT for Claude users
• Gemini for Claude users
• Grok for Claude users
• Porting prompts across models — what transfers, what breaks

Comparing before you commit

• How to read an AI benchmark without getting fooled — read this before any other row in this list: what a SWE-bench score literally measures, the 4.8 points a vendor's own footnote shows come from the harness rather than the model, the contamination discount that turns 70%-plus into ~23% on unseen code, and a six-question checklist for any number
• Is the model nerfed? How to actually tell — the question that follows every launch: what a pinned snapshot does and does not guarantee, the seven things that change without a new model, why the most-cited "GPT-4 got dumber" result was an eval bug, and a paired-design protocol you can run yourself
• Claude vs GPT vs Gemini for coding
• Reasoning models compared
• What AI costs across providers
• Hard spend caps: which providers actually stop the bill — the control that matters once agents can spend while you sleep: one event, four status codes (a 429 with no retry-after on Anthropic's tier cap, a 400 on the limit you set yourself, 429 on OpenAI, 402 on OpenRouter), why no cap can be exact, and the tier where the default safety net disappears
• Ember-1: Kimi K3's answers for 40% fewer tokens — identical rate card, materially smaller bill: why turning the effort dial down is not the same as efficiency, what one benchmark run really costs, and the reasoning-token share that caps your own saving
• Prompt caching across providers — explicit vs automatic control, a 512-to-4,096-token eligibility spread, and the break-even rule that says a prefix reused only once can cost you MORE cached than uncached
• Server-side conversation state across providers — all three majors now keep your conversation for you, and shipped three incompatible contracts: Anthropic's evaporates after 5 idle minutes and requires you to code a replay path, while OpenAI and Google retain it for 30 and 55 days by default — store: true is the setting nobody on your team chose
• Diffusion LLMs: the models that don't write left to right — a different decoding algorithm, not better hardware: why the open-weight pioneer's own README says quality peaks at one step per token, the conditional-independence bug that makes aggressive parallelism wrong rather than just coarse, how DiffusionGemma converted an autoregressive Gemma 4 for under 10% of its training budget, and the masked-infill jailbreak that reaches 100% on an aligned dLLM
• Latent reasoning: agents that think without words — the first open-weight agent that does most of its thinking as hidden states instead of tokens: 170-183 latent forward passes against ~302 text tokens where a text agent spends ~596, a ~10M-parameter adapter as the entire bridge, the reason the checkpoint loops forever in llama.cpp, and the causal test (44.9-51.3% accuracy loss) that quietly undermines the paper's own "inspectable thoughts" claim
• Optical context compression: sending text as an image — 86.5% fewer counted tokens on Anthropic, 6.95x MORE on Gemini for short inputs, and the accuracy cliff the token counter cannot see
• Generative media: image, audio, video
• World models: what you can actually build today — AMD is paying ~$8.2B for World Labs, and two opposite things share the name: frame generators where the world lives in the model's context and a session caps at 60 seconds, versus 3D generators that hand you Gaussian splats you own, render for free and cannot collide with
• AI explainer videos: the code-driven pipeline — the model writes a deterministic program, not a video: why Math.random() is banned, Remotion's 3-employee licence cliff, the two Manims that share an import name, and the dwell-time formula that makes it watchable
• Gemini 3.8 Live and Live Extended Thinking — Google's GA voice models for builders: async tools by default, the 15-min/2-min session walls, and why call cost grows faster than call length

Running models yourself

Local models trade some capability for privacy, cost control, and working offline. These pages cover when that trade is worth making.

• Run models locally with Ollama — the practical starting point
• Why a 35 KB system prompt breaks on a local model — context budgets, Ollama's silent middle-of-prompt truncation, and the failure signals to watch
• DeepSeek, Qwen & the open models
• DeepSeek V4-Flash-Vision: first native-vision frontier open weight
• DeepSeek-V4.1-Flash: the 1M-context open weight that replaced it — serving stacks, sampling defaults, and the effort-dial protocol
• Mistral Large 4 (Le Chonk): the 1.05T open weight you can't download yet — why "49B active" still needs ~525 GB at 4-bit, an Intelligence Index of 38 against Opus 5.5's 58, a 50% launch promo that hides the real cost-per-task, a 1M context evaluators measured near 512K, and the staged release where vetted partners get a less-moderated build first
• Colibrì: run a 744B MoE from your SSD — expert streaming on 16–32 GB machines, and what it really costs in tok/s
• Strata: a 125B MoE at 94 tok/s on a 12 GB card — the other end of that hierarchy, at interactive speed: why only 12 of 48 layers grow a KV cache, why a 58 GB download needs just 29.6 GB of RAM, and the quality bill nobody prints — 91.3% of SWE-bench Verified next to 98.7% of LiveCodeBench, a KV default that passes needle tests while losing 8–12% perplexity, and a 3x vision regression on identical weights
• DwarfStar (ds4) and the rise of overfit inference engines — a pure-C engine that runs three model families and refuses everything else: asymmetric expert quantization, bounded SSD streaming, KV snapshots that survive a restart, and its numbers read honestly
• DeepInfer: DeepSeek's own inference engine, read honestly — 16.3k stars in a day, and four things the coverage missed: it's a vLLM fork, "SM100" excludes every H100 and every consumer card, its decode throughput counts drafted tokens whether or not they were accepted, and batch-invariant inference is mutually exclusive with its own speculative decoder
• Ternary quantization in practice: Bonsai 2 27B in 5.95 GB — why stock llama.cpp loads it and silently emits garbage, why the bigger file is faster on an H100, and what "98.2% retention" hides
• MiMo-V2.6: Xiaomi's 1T open-weight omnimodal model — MIT, 42B active, video and audio in; the Terminal-Bench version trap, why Pro wants two nodes, and what the 10x UltraSpeed tier actually sells
• Whistle: speech-to-text in 16.9 MB — on-device ASR that genuinely beats Whisper base on close-mic speech, and is the worst of three models on real meeting audio: the benchmark bars the vendor's chart declines to label, the 30-second wall that lives in the encoder, the streaming API the launch thread concluded did not exist, and the one knob that took a tester from 41% to 96%
• A private local AI stack
• Claude plus local models — using both, deliberately

Agents beyond Claude

• Local AI agents
• Open-source agent frameworks
• The third-party memory layer: how claude-mem works — 103k stars for fixing session amnesia across Claude Code, Cursor and Codex, and what it actually is underneath: a second model in a daemon reading every tool call, whose hosted observer the project's own cost dataset prices as a DeepSeek model; plus the exit-code contract that decides whether a broken memory layer blocks your session
• Claude, MCP and local tools
• A2A: the agent-to-agent protocol
• Agent payments: x402, MPP and AgentCore GA — how agents actually pay for things now
• Commerce agents blueprint — Anthropic's open-source reference for shopping and merchant agents: the split-agent shape and the staged-write guardrail
• OpenAI Agents API vs Claude Managed Agents — the two hosted agent loops side by side: permissions, vaults, budgets, network policy, sandbox cost
• OpenAI Dots: the always-on agent — a persistent agent with its own cloud computer that works while you are logged off: the five-rung permission ladder, why proactive research is read-only at the tool layer rather than the prompt layer, and what the published safety numbers really measure
• Open Code Review: Alibaba's hybrid AI reviewer — deterministic rails around any model; 4.7x Claude Code's precision on its own benchmark, and a 20% recall ceiling
• AX (Agent Executor): Google's open agent runtime — kubectl-shaped Tasks, Workspaces, Gateways and Models on top of Agent Substrate; what survives a suspend/resume, the runner contract, and why the June docs no longer match the CLI
• System One decision models: Jev, Kev and the open clones — a model that returns calibrated probabilities instead of text; what "cannot hallucinate" really guarantees, the vendor numbers next to the one independent test, and where it sits in a Claude agent loop
• Train your own decision model: Jeff, Jeeves and the DIY stack — the recipe is cross-entropy over option letters plus a separately fitted temperature; ~2 hours on one GPU, the benchmark rows where a 0.8B beats the API by 19 points and the rows where it loses by 30, and the boring embeddings baseline you have to beat first
• Async-first agent harnesses: what Unreal Agent changes — why turn count, not token count, is what you pay for; 28 turns against 44 for the same score, and the three designs Unreal Labs refused to build
• Pi 1.0: the minimal harness and the codemode trick — the most complete published answer to MCP context bloat: a QuickJS/WASM sandbox where tool results never enter the transcript, four exposure modes where the default declares nothing, a 3,000-token ceiling on inlined declarations, and a suffix-append trick that keeps your prompt cache alive when a server connects
• DeepSeek Harness: the agent loop as a plugin — 242k stars and an "everything is a plugin" claim that holds: it runs your Claude Code hooks.json, speaks anthropic-messages, and defaults run_code to codemode
• Desktop agents without pixels — Vercel's agent-desktop reads OS accessibility trees instead of screenshots, and ships the clearest published spec for how a computer-use harness should handle uncertainty: refs scoped to a snapshot so a stale identifier cannot even be expressed, resolution that fails closed instead of guessing, properties that keep Unknown distinct from Absent, and a retry rule built on delivered vs not delivered rather than success vs failure

Everything in this section

The full list, including pages added since this index was written.

AAI Models & Assistants

Claude is the core here, but the same skills travel. Start with how to choose, then go as deep as you need on any assistant, on running models locally, or on agents.

TThe AI Model Landscape: Choosing Among Claude, ChatGPT, Gemini & Open Models

A durable framework for picking the right AI model for a task — across Claude, ChatGPT, Gemini, Llama, Mistral, Grok and the open/local models — plus what skills transfer across all of them.

GGemini 4 Argon: The Field Guide for Claude Users (Sep 30, 2026)

Google's Gemini 4 generation opens with Argon and one headline number: a 1M-token OUTPUT limit, up from 64K. Context stayed at 1M. What the coverage gets wrong: the independent Artificial Analysis index puts Argon at 53 — five points BEHIND Claude Opus 5.5's 58 — and its cheaper $1.99-per-task cost comes from the rate card, not efficiency, since it burns 62K output tokens per task against GPT-6 Astra's 27K. Plus: a 15% hallucination rate (lowest measured), and why you almost certainly cannot call it yet.

CClaude Opus 5.5: The Field Guide

Opus 5.5 shipped 22 September 2026 at $4/$20 per MTok — 20% under Opus 5, with cache reads at $0.20 (a 5% tier, not the usual 10%). Four breaking changes 400-error a naive migration, one more changes the response shape without failing anything and makes your UI go quiet mid-task. Thinking can no longer be disabled at all, forced tool_choice is gone, and the default effort dropped from high to medium — while each level now thinks more than it did on Opus 5.

CClaude Fable 5.1: What Changed and How to Migrate

Anthropic shipped Claude Fable 5.1 and Mythos 5.1 on September 1, 2026: same $10/$50 price, cache reads cut to $0.25, three breaking API changes (forced tool_choice errors, one-way thinking blocks, append-only history) and five additive betas. The migration field guide for anyone pinning claude-fable-5 or claude-opus-5.

CClaude Fable 5 & Mythos 5: The Flagship Field Guide

Fable 5 was Anthropic's first Mythos-class flagship — now a legacy model, superseded by Fable 5.1. Its API refuses in-band (HTTP 200, stop_reason: refusal), has adaptive thinking only, and never returns raw thinking. If you're pinning a top-tier model, this changes how you write integrations. When to use it vs Opus 4.8, the fallback pattern, the prompting shifts.

CClaude Sonnet 5.5: The Field Guide

Sonnet 5.5 shipped 28 September 2026 at exactly Sonnet 5's prices — $2/$10 per MTok — and Anthropic still claims up to 30% less per task. The saving is in the token count, not the rate card. Five breaking changes 400-error a Sonnet 5 codebase, a sixth returns 200 and silences your progress UI, thinking can no longer be disabled (only moved between tool calls), and on Terminal-Bench 4.0 the cheap model scores 70.6% against Opus 5.5's 66.4%.

CClaude Haiku 5.5: The 100K Price Cliff

Haiku 5.5 shipped 7 October 2026 at $0.10/$0.50 per MTok — a 90% cut — and it is the only current Claude model priced by prompt length. One token past 100,000 reprices the entire request 5x. The threshold is measured on the new tokenizer, so it arrives ~23% earlier in text than you expect, and the 90% headline is ~87% in practice below the cliff and ~35% above it.

CClaude Opus 5: The Field Guide

Opus 5 shipped 24 July 2026 as Anthropic's fourth model in two months — same $5/$25 pricing as Opus 4.8 but more than double the Frontier-Bench score, 3× ARC-AGI-3 vs the next-best model, and a new xhigh/max effort tier. The benchmarks that matter, the two 400-errors that break naive migrations, and when Opus 5 replaces Fable 5 in your stack.

CClaude Sonnet 5: The Field Guide

Sonnet 5 is Sonnet 4.6's drop-in successor and Claude Code's default on Pro and Team Standard — but three API constraints will 400 you on migration and a new tokenizer produces ~30% more tokens for the same text. The pricing math, the effort re-mapping (Sonnet 5 medium ≈ Sonnet 4.6 high), and the prompting shifts that catch teams out.

CChatGPT for Claude Users

Fluent in Claude, need to use ChatGPT? The differences that matter, what transfers, and when to reach for which — including the Custom GPT retirement and the Plugins that replace them.

GGPT-5.6 & ChatGPT Work for Claude Users

OpenAI shipped the GPT-5.6 family (Sol, Terra, Luna) and ChatGPT Work on 9 July 2026. What actually changed for a Claude user — 1.05M context, a $1 tier, an agent that runs for hours, and the parts of the launch nobody is writing about.

GGPT-6.1 Sol: The Field Guide for Claude Users

OpenAI shipped GPT-6.1 Sol at DevDay on September 29, 2026 with the exact rate card Claude Sonnet 5.5 has — $2/$10 — and a cached-input price half of Sonnet's. The launch line is 'near-Astra intelligence for a fifth of the price'. The details that decide whether that is true for you: a 922K input ceiling inside a 1.05M window, a hard cost cliff at 272K tokens, tool calling that only works on one of the two APIs, and the benchmark row where Sonnet 5.5 still wins by 8.7 points.

GGPT-5.6 August 2026 Update: Effort Slider, Free Think Button & the 272K Price Cliff

On 6 August 2026 OpenAI shipped a mid-cycle update to GPT-5.6 that most write-ups reduced to 'Sol got smarter.' The real story: a six-tier effort control that changes how you price a request, a free-tier Think button, a 272K token pricing cliff that re-prices the whole call, and a Fast mode that only runs on Sol. What each means for a Claude user.

GGPT-6 Astra: The Field Guide for Claude Users

OpenAI's GPT-6 Astra went GA on September 4, 2026: 1.05M context, $10/$50 per MTok, a Critical cyber classification, and a 'recurrent depth' architecture that hides part of its reasoning. What's confirmed, how it stacks against Claude Fable 5.1 and Opus 5, the four API gotchas, and when a Claude user should reach for it.

CCodex Agent Plugins & Catalog Federation (v0.147.0): The Practical Guide

On 7 August 2026 OpenAI shipped Codex CLI v0.147.0 — the release that turns Skills into portable Agent Plugins with a four-tier catalog, ships an --approve-for-me flag that doesn't do what it sounds like, quietly removes --full-auto, and opts you into MCP 2026-07-28. What every part actually does, in Claude-user terms.

SSign in with ChatGPT

OpenAI's new identity layer, three days old. What data actually crosses the line, what enterprise admins can do about it, and how to accept it in your app without giving OpenAI a foothold you didn't intend.

RRun AI Models Locally with Ollama

Run open-weight models (Llama, Mistral, Qwen…) on your own machine — private, offline, free to run — with Ollama. Setup, CLI, and calling it from code.

CClaude vs GPT vs Gemini for Coding

A framework (not a leaderboard) for choosing a frontier model for coding — the factors that matter, and why an eval on your own repo beats every benchmark.

CCoding Agent CLIs Compared

Claude Code, Codex CLI, Gemini CLI and the open-source terminal agents — how the harness (not just the model) decides your results, and how to keep your setup portable with AGENTS.md.

SSupabase Evals — Real-Backend Agent Benchmark

Supabase open-sourced a benchmark that runs Claude Code, Codex and OpenCode against real containerized Supabase stacks — not mocks. Here's what it measures, what it found about how models actually use docs and skills, and how to run it locally in an evening.

AApple Foundation Models 3 & the On-Device LLM Stack for Claude Users

Apple's third-generation Foundation Models (AFM 3) landed at WWDC 2026 with a 3B dense on-device model, a 20B sparse MoE that runs on iPhone, and a Swift-native framework that now lets you bring your own LLM provider — including Claude. What actually shipped, the non-obvious mechanisms, and how it changes the on-device story for anyone who ships Claude apps.

GGemini for Claude Users

Fluent in Claude, need Google's Gemini? The differences that matter — Gems, Workspace integration, huge context, multimodal — and what transfers.

GGemini 3.6 Flash, Flash-Lite & Flash Cyber for Claude Users

On 21 July 2026 Google skipped Gemini 3.5 Pro entirely and shipped three Flash-tier models instead. Real prices, real benchmarks, the migration gotchas, and the parts most write-ups miss — including a cybersecurity fine-tune that beat Claude Opus 4.6 at V8 bug-hunting.

GGemini 3.7 Flash for Claude Users: Coding-Agent Workhorse at Half Price (Aug 2026)

On 13 August 2026, three weeks after 3.6 Flash, Google shipped Gemini 3.7 Flash at half the introductory price with a 16-point DeepSWE jump. The gotchas most write-ups skip: an expiring intro price, a 3× throughput advantage that matters for agent loops but not chat, and where it still trails Claude Sonnet 5.

GGemini 3.8 Flash for Claude Users: The Workhorse That Now Ties Opus 5 on DeepSWE (Sep 2026)

On September 2, 2026, three weeks after 3.7 Flash, Google shipped Gemini 3.8 Flash at the same $0.75 / $3.75 intro price: DeepSWE 73.7 (+8.4), Terminal-bench 2.1 89.4, HLE-Verified 54.9, plus a Cyber variant gated behind the new Fairwind Program. What the headlines skip: it 'works harder' by emitting ~30% more tokens per task, the same model ID migration rules from 3.7 still apply, and Terminal-bench 4.0 is where Claude Opus 5 stays 33 points ahead.

GGrok for Claude Users

Fluent in Claude, need xAI's Grok? The differences that matter — real-time X/web search, an OpenAI-compatible API, and the Grok Build coding agent — plus everything that transfers.

MMuse Code + Muse Spark 1.2: Meta's Terminal Coding Agent

On 5 August 2026 Meta shipped Muse Code, a terminal coding agent, and Muse Spark 1.2, the model co-trained with it. What the append-only event log actually buys you, why the contributor tier is 12.5× cheaper than standard, how it stacks up against Claude Code on Terminal-Bench 2.1, and the three bundled skills that are worth stealing regardless of which agent you use.

OOpen-Source AI Agent Frameworks

A provider-neutral map of the main open frameworks for building LLM agents — LangGraph, LlamaIndex, AutoGen, CrewAI and the minimal-loop approach — and how to choose.

NNative Multi-Agent APIs: OpenAI's Responses Multi-Agent Beta vs Building It Yourself

On 9 July 2026 OpenAI shipped the Responses API multi-agent beta and Sol Ultra Mode — the first frontier vendor to make 'the model spawns and synthesises N subagents in one HTTP request' a first-class primitive. What actually ships, the API shape, the cost math, what Anthropic does instead, and when the native primitive beats a DIY fan-out.

AA2A: The Agent-to-Agent Protocol

MCP connects agents to tools. A2A connects agents to other agents — across frameworks, clouds, and companies. Learn the Agent Card, tasks, the eight lifecycle states, streaming vs. webhooks, and how A2A composes with MCP.

AAgent Payments: x402, MPP and AgentCore GA

How AI agents actually pay for things now — the x402 HTTP-402 protocol, the exact/upto/batch-settlement schemes, facilitators, Amazon Bedrock AgentCore Payments' Aug 2026 GA (payment sessions, Coinbase Bazar MCP, Stripe Privy, Machine Payment Protocol), and how to add a paywall or a spending agent without inventing a wallet.

PPorting Prompts Across Models

Move a prompt between Claude, GPT, Gemini and open models — what transfers cleanly, what to adjust per model, and a migration workflow.

MModel Routing Patterns: Cascades, Classifiers, and What Actually Ships

The design patterns for sending each request to the right AI model — rule-based, classifier, complexity, cascade, ensemble, fallback. When to use each, what breaks, and the recipes that actually ship in 2026.

DDeepSeek, Qwen & the Open-Weight Wave

Strong open-weight models (DeepSeek, Qwen, Llama, Mistral) closed much of the gap. What 'open weight' means, the trade-offs vs closed frontier, and how to use them.

QQwen3.8-Max: The First Open-Weight Max-Class Model (When the Weights Ship)

August 3, 2026: Alibaba's Qwen3.8-Max shipped API-only with a 2.4T parameter MoE (95B active), a 1M context, dual OpenAI/Anthropic-spec APIs, and benchmark scores that beat GPT-5.6 Sol Max on OSWorld. What's genuinely new, what 'open weight' actually means when the Hugging Face page is empty, and the sparsity math that makes self-hosting expensive.

DDeepSeek V4-Flash-Vision: First Native-Vision Frontier Open Weight

On Aug 31 2026 DeepSeek open-sourced V4-Flash-Vision-Exp — a 305B MoE that adds native vision to V4-Flash without hurting text agent scores, matches or beats Claude Opus 4.8 on ApexBench / Agents' Last Exam / ZeroBench at a fraction of the price, and ships MIT. The specific numbers, the hard 384-token-per-image cap most guides ignore, and the concrete way to run it.

DDeepSeek-V4.1-Flash: A 1M-Context Open Weight That Ties Opus 5 on DeepSWE (Sep 2026)

On September 10, 2026 DeepSeek shipped V4.1-Flash — a 552B MIT-licensed MoE with native vision, a 1M-token window, a KV cache a quarter the size of V4-Flash's, and a 1–100 reasoning-effort dial. It ties Claude Opus 5 on DeepSWE v1.1 (74.2 vs 74.0) at $0.30 per million input tokens, and trails badly on Terminal-Bench. The numbers, the routing change that silently moved every deepseek-v4-pro call, and where Claude still wins.

KKimi K2 for Claude Users

Moonshot's Kimi K2 is an open-weight, trillion-parameter agent built for long tool-use chains. What actually makes it different from Claude — native INT4 weights, 200–300 sequential tool calls, a permissive license — and when it's worth reaching for.

GGLM-5.2: Open-Weight Frontier Coding Model

Z.ai's 753B MoE (~40B active), 1M-token context, MIT-licensed — closes to within a point of Claude Opus 4.8 on long-horizon coding, at roughly one-sixth the API cost. What IndexShare actually does, how to run it locally, and where it beats Claude Code in the wild.

IInkling: Thinking Machines' Open-Weights Model

Mira Murati's Thinking Machines Lab shipped Inkling — a 975B-parameter Apache 2.0 multimodal MoE with a continuous thinking-effort dial. What the launch coverage got wrong, why it deliberately loses benchmarks, and what the effort knob actually does.

KKimi K3: World's Largest Open-Weight Model

Moonshot AI's 2.8-trillion-parameter open-weight model beats Claude Opus 4.8 on many benchmarks and tops the Frontend Code Arena. What makes it architecturally different, when the cache-hit pricing flips the cost math, and whether it's worth reaching for.

RRunning Kimi K3 Locally: vLLM, DSpark & the Real Hardware Bill

The definitive practical guide to self-hosting Moonshot's 2.8T open-weight Kimi K3 in 2026. What DSpark speculative decoding actually does, minimum hardware (1× DGX B300 or 16× DGX Spark), the exact vLLM serve commands, the prefill/decode asymmetry nobody warns you about, and when hosted inference undercuts your own rack.

MMiMo-V2.6: Xiaomi's 1T Open-Weight Omnimodal Model

A 1.02T-parameter MoE with 42B active, 1M context, text/image/video/audio input — MIT-licensed on Hugging Face. What the benchmark tables actually say once you check which version was run, why Pro needs 32 GPUs and Flash doesn't, and what the 10x UltraSpeed tier is really selling.

IInside Grok Build: Reading an Open Agent Harness

xAI published the full Rust source of its coding agent under Apache 2.0 — the agent loop, tool layer, TUI and extension system. What the crate map teaches you about building agents, why 'open source' here means source-available, and what the data-collector code still in the tree tells you.

PPoolside Laguna: Open-Weight Coding Models That Punch Above Their Class

Poolside AI's Laguna family (XS 2.1, S 2.1, M.1) — MoE coding models with 3B–23B active params, 1M-token context, OpenMDW-1.1 license. What the 8B-active S 2.1 actually beats, why the 3B-active XS 2.1 runs on a MacBook, the first-known RL-in-FP8 training pipeline, and when to reach for it over Claude, GLM-5.2 or Kimi K3.

GGenerative Media: Image, Audio & Video AI

Beyond text chat — a map of AI for images, video, voice and music: the major tools, the durable skills, and the rights/ethics that matter.

OOpen Code Review: Alibaba's Hybrid AI Reviewer vs Claude Code, Codex and Any Model (2026)

Alibaba's open-code-review (ocr) is the AI code reviewer trending on GitHub: a Go CLI that puts deterministic file selection, rule matching and line anchoring around an LLM agent. Same Claude model, 4.7x the precision of a Claude Code review at 1/15 the tokens on its own benchmark — and a best-case recall of 20%. How it works, how to run it with Claude, GPT, Qwen or a local model, delegation mode, CI, and the gotchas.

MMiniMax H3 (Hailuo 3.0): The Open-Weight Omni Video Model

MiniMax open-sourced a 33B single-stream transformer that generates 4–15s of 2K video with native stereo audio in one pass. The license quietly blocks self-hosting in the US/EU/UK/Korea, the open base is 768p (not 2K), and ~13B of 33B params are AdaLN branches you can skip at inference. What H3 actually is, what it costs, and when it beats the closed video APIs.

WWhat AI Actually Costs (Across Providers)

A durable framework for comparing AI cost across providers — the pricing archetypes, how to estimate a workload, the levers to cut the bill, and when open/local wins.

HHard Spend Caps: Which AI Providers Actually Stop the Bill

A soft cap emails you. A hard cap blocks the request. This page maps which AI providers do which — and the trap nobody documents: the same event (you hit your cap) returns HTTP 429 with no retry-after on Anthropic's tier cap, HTTP 400 on the limit you set yourself, 429 on OpenAI, and 402 on OpenRouter. Plus why no cap can be exact, where the Custom tier loses its safety net, and how to build a pre-flight killswitch.

PPrompt Caching Across Providers

Every major provider caches your prompt prefix — but explicit vs automatic, 5 minutes vs 24 hours, and a write premium that can make caching cost you more. The portable break-even rule and the five traps when you move a workload.

WWhy AI Agents Burn Tokens (and How to Cap the Bill)

Agentic runs cost 50–1000x a chat — not because the model is dumber, but because of the context snowball. The mechanism, the surprising numbers, and the four levers that actually cut the bill across Claude, GPT, Gemini, and open models.

SServer-Side Conversation State Across Providers

Anthropic, OpenAI and Google all now keep your conversation on their servers — and shipped three incompatible contracts. One is an ephemeral latency trick you must code a replay path for; two are durable storage that is ON by default, for 30 and 55 days. The axis that actually decides your design.

OOptical Context Compression: Sending Text as an Image

Render your context into a picture and the vision encoder becomes a compression dial. Measured across Anthropic, OpenAI and Google, an image of code counts 76–87% fewer input tokens than the same code as text — and on Gemini it can cost 6.95x MORE. The mechanism, the accuracy cliff, and how to test it on your own documents.

AAI Explainer Videos: The Code-Driven Pipeline

Opus 5.5 explainer videos hit the Hacker News front page — and almost nobody explains what is actually happening: the model writes a deterministic animation program, not a video. The mechanism, the three render engines and their licences, the two traps that break agent-written animation code, the pacing formula that makes the difference between watchable and unwatchable, and what the bill really looks like.

BBuilding Local AI Agents

Autonomous agents that run entirely on your machine with a local open-weight model — private, offline, free to run. The architecture, the trade-offs, and how to start.

CClaude + Local Models: Hybrid Patterns

Make Claude and local open-weight models work in synergy — router, draft-then-refine, privacy redaction, bulk pre-processing — for the reasoning of frontier with the privacy and cost of local.

AAI Gateways: LiteLLM, OpenRouter, Portkey, Vercel

A production AI gateway is the missing router between your app and every model — Claude, GPT, Gemini, Llama. Compare LiteLLM, OpenRouter, Portkey, and Vercel AI Gateway, then wire Claude Code through your own proxy.

LLocal Coding Agents (and How They Pair with Claude)

Coding agents that run on your machine and edit your repo — Aider, Cline, Continue, OpenHands, Claude Code — powered by Claude for quality or a local model for privacy.

CConnect Claude to Local Tools & Agents with MCP

The Model Context Protocol lets Claude orchestrate tools, data and agents running privately on your own machine — the Claude-as-brain, local-capabilities synergy. Add or build a local MCP server.

BBuild a Private Local AI Stack (End-to-End)

Tie it together: a local model (Ollama) + a model-agnostic agent + tools via a local MCP server — a private assistant on your own machine, with Claude as an optional smart layer.

LLocal Agent or Claude? A Decision Guide

Fully-local agent, Claude-powered, or hybrid? The factors that decide it — privacy, task difficulty, cost, latency, reliability — and why hybrid often wins.

SSecuring Local & Hybrid Agents

An agent that can edit files and run commands is powerful and dangerous. Least privilege, sandboxing, human approval, prompt-injection defense, budget caps — how to run agents safely.

RReasoning Models Compared

Thinking budgets and reasoning effort across Claude, GPT, Gemini, DeepSeek, and Qwen — when to spend tokens on thinking, and when not to.

FFull-Duplex Voice AI: Why Voice Agents Suddenly Got Real

GPT-Live and the new speech-native models listen and talk at the same time. What full-duplex changes, how it works, and the voice-AI landscape now.

CClaude Voice with Opus & Sonnet (July 2026): Reasoning-First Voice vs GPT-Live

Anthropic opened Claude voice to Opus, Sonnet, and connected apps on July 23, 2026 — but kept the turn-based stack. What actually changed, when to switch models mid-call, and how the design bet differs from OpenAI's full-duplex GPT-Live.

GGemini 3.8 Live and Live Extended Thinking: The Builder's Field Guide to Google's New Voice Models (Sep 2026)

On September 15, 2026 Google shipped gemini-3.8-live and gemini-3.8-live-extended-thinking. The launch post covers benchmarks. This page covers the rest: which model to pick, the migration traps coming from 3.1 Flash Live (async tools are now the default, thinkingLevel errors, proactive audio can't be turned off), the 15-minute and 2-minute session walls, and why a voice session's cost grows faster than its length.

CCommerce agents blueprint (Anthropic reference)

Anthropic's Sept 2026 open-source blueprint for shopping and merchant agents on Claude — the split-agent shape, the staged-write guardrail, and the patterns you can steal even if you're not building commerce.

TToken Speed: Why AI Inference Suddenly Got 10-15× Faster

Wafer-scale chips and LPUs are serving frontier models at hundreds of tokens per second. What actually limits inference speed, the new hardware race, and why fast tokens change agents, voice and reasoning.

DDiffusion LLMs: The Models That Don't Write Left to Right

Mercury 2 answers a full reasoning question in 1.7 seconds at 1,009 tok/s; Gemini Diffusion samples at 1,479 tok/s against Gemini 2.5 Flash's 272.4. Same transformers, different decoding algorithm. The practical guide: why the open-weight pioneer's own README says quality peaks when you use one step per token, the conditional-independence bug that makes parallel decoding wrong, block diffusion as the fix that restored the KV cache, how DiffusionGemma converted an autoregressive Gemma 4 for under 10% of its training budget, and the masked-infill jailbreak that hits 100% on an aligned dLLM.

CComputer-Use Agents Compared

Claude, GPT and Gemini can all drive a screen now — but each exposes a different action space, coordinate contract and safety gate. What actually breaks, and how to build a loop that survives it.

SShared-Login Browsers for AI Agents: The ego lite Pattern

A new class of browser — best exemplified by ego lite, which hit #1 on GitHub Trending on July 24, 2026 — lets Claude Code, Codex, Cursor, and any other coding agent drive an isolated Chromium session that inherits your real logins. What Spaces and semantic snapshots actually solve, why it undercuts Playwright for agent work, and the security cost of sharing session cookies with an autonomous process.

CCloudflare Kitesurf: The First Browser Runtime Built for AI Agents (Not Humans)

On August 6, 2026 Cloudflare launched Kitesurf, a stateless, agent-first browser that runs entirely in V8 isolates on Workers. It uses 3-7x less CPU and memory than Chromium on common agent tasks — at the cost of ~1.7x wall-clock time. Written in Rust, using Firefox's CSS parser (Stylo) and the Blitz rendering engine, drop-in compatible with Puppeteer/Playwright via the Chrome DevTools Protocol. This page: what changed, when to reach for it instead of headless Chrome, how to wire it into Claude Code / Codex / your MCP client, and the four things it flat-out can't do yet.

DDesktop Agents Without Pixels

Vercel Labs shipped agent-desktop on 28 October 2026 — accessibility-tree computer use in Rust, Apache-2.0, for macOS/Windows/Linux. The headline is 'AX trees instead of pixels'. The part worth stealing is its correctness model: refs scoped to a snapshot, fail-closed resolution that refuses to guess, tri-state properties, and a retry rule built on DELIVERED vs NOT DELIVERED rather than success vs failure.

SSKILL.md: The Cross-Agent Open Standard

One SKILL.md file, thirty-two agents. What the Agent Skills open standard actually is, how progressive disclosure keeps context cheap, what breaks portability, and how to write a skill that runs unchanged in Claude Code, Codex, Gemini CLI and Cursor.

CColibrì: Run a 744B MoE From Your SSD (and What It Really Costs You)

Colibrì is a pure-C, zero-dependency engine that runs GLM-5.2 (744B), Kimi K3 (2.8T), DeepSeek V4.1 Flash and six other frontier MoE models on a 16–32 GB machine by keeping the dense layers in RAM and streaming the routed experts from NVMe. This page explains the memory hierarchy, the numbers that decide whether it is usable for you (0.05 to 6.8 tok/s), the SSD-wear and speculative-decoding gotchas, and the exact commands to get a first token.

OOpenAI Agents API vs Claude Managed Agents: The Hosted Agent Loop, Compared

On September 10, 2026 OpenAI put the Codex harness behind a single API call: the Agents API public beta — durable sessions, hosted or self-hosted sandboxes, automatic compaction, tool search, subagents. Anthropic has run the same shape since April as Managed Agents. Both use the same four primitives; they differ on permissions, secrets, budgets, network policy and what the sandbox costs. The side-by-side, the request shapes, the six gotchas, and when to pick which.

AAX (Agent Executor): Google's Open Agent Runtime, Explained for Builders (2026)

google/ax hit the Hacker News front page on September 20–21, 2026 (507 points). It is not a model, a harness or a hosted API: it is a kubectl-shaped orchestrator that runs agent Tasks in sandboxes on top of Agent Substrate, with Workspaces (git + MCP + skills), Gateways (egress allowlists) and Models (provider + secret) as declarative resources. What the four primitives do, what survives suspend/resume and what does not, the runner contract your image must honour, the GKE requirements, and why the June-era docs no longer match the CLI.

SSystem One Decision Models: Jev, Kev and the Open Clones, Explained for Builders (2026)

TypeSafe AI's Jev (out of stealth September 15, 2026) is a model that never writes text: you send it program state plus typed questions and it returns calibrated probabilities for all of them in one parallel pass, 70–500 ms, $0.042 per million input tokens, output free. Two Hacker News front-page stories on September 21 (Kev, an Apache-2.0 recreation on Qwen3.5, and the jev-leftpad joke) made it the week's topic. What a System One model actually does, what the 'cannot hallucinate' claim really guarantees, the vendor numbers next to the one independent test, where a decision model belongs in a Claude agent loop, and how to run Kev or Nimble locally.

TTrain Your Own Decision Model: Jeff, Jeeves and the DIY System One Stack (Sep 2026)

Two weeks after Jev made decision models a category, the open stack caught up: Jeff fine-tunes a 0.8B Qwen into a Jev-compatible classifier in ~2 hours on one workstation GPU, and PostHog's Jeeves shows that letting a decision model think first beats Jev on its own benchmark. What the training recipe actually is (cross-entropy over option letters, a separately fitted temperature), where tiny models beat the API and where they get destroyed, the 26-option ceiling, the 20x CPU latency cliff, and the boring embeddings baseline that scored 93.0% and that you must beat before any of this is worth doing.

TTernary Quantization in Practice: Bonsai 2 27B in 5.95 GB

PrismML compressed Qwen3.8-27B to 1.75 bits per weight and 5.95 GB. The practical guide nobody wrote: why stock llama.cpp loads the file and silently produces garbage, why the bigger 7.21 GB file is faster on an H100 but slower on a 4090, why 5.95 GB of weights needs 12 GB of VRAM, and which capabilities the 98.2% retention headline quietly loses.

AAsync-First Agent Harnesses: What Unreal Agent Changes

Unreal Labs shipped an MIT-licensed Go harness that matches Codex's pass rate on Terminal-Bench 4.0 for 39% less money — by never making the model wait for a tool. The event-log mechanism, why turn count is the real cost unit, and the three things they deliberately refused to build.

HHindsight: agent memory that learns

The MIT-licensed memory server that topped GitHub trending — retain, recall and reflect, four parallel retrievers fused by RRF, observations that get refined instead of overwritten, and the 83.6%-vs-39.0% result that says architecture beats model size.

EEmber-1: Kimi K3's Answers for 40% Fewer Tokens (Sep 2026)

Fireworks post-trained Kimi K3 to stop over-thinking and shipped the result as Ember-1 — same price per token, 35–50% fewer reasoning tokens, and it beats K3 at max effort on two of five benchmarks. Why turning effort down is not the same thing, what the '-51.9% / -23.1 USD' column really says, the implied cost per benchmark task, the modality that quietly disappears, and the Kimi K3 licence clause that lets a derivative stay closed.

OOpenAI Dots: The Always-On Agent, and the Permission Ladder Underneath It

At DevDay on September 29, 2026 OpenAI shipped dots — persistent agents that each get their own cloud computer and browser, run on GPT-6 Astra, and keep working while you are logged off. The launch coverage stops at the demo. This page covers the mechanism: the five-rung permission ladder, why proactive research is read-only at the tool layer rather than the prompt layer, what the published safety numbers actually measure, and how a dot compares to Claude Managed Agents and Cowork.

WWorld Models: What You Can Actually Build Today

AMD is paying about $8.2 billion for World Labs, and two very different things are being sold under the same name. Frame generators like Genie keep the world inside the model and cap a session at 60 seconds. 3D generators like Marble hand you Gaussian splats you own, render for free and cannot collide with. The API shapes, the export tiers, the WorldScore evidence, the open weights you can run, and the five jobs a world model will not do.

IIs the model nerfed? How to actually tell

"They nerfed it" is the most-repeated claim in AI and the least-measured. On the Claude API the weights behind a model ID cannot change — every current ID is a pinned snapshot. But seven other things can change under you without a new model, from a published system-prompt update to a harness that silently swaps models mid-session. Here is what can and cannot move, why the most-cited 'GPT-4 got dumber' result was an eval bug, and a measurement protocol you can run in an afternoon.

PPi 1.0: The Minimal Harness, and the Codemode Trick That Fixes MCP Token Bloat

Pi 1.0 shipped 1 October 2026 and went to #1 on Hacker News. The interesting part is not the TUI — it is the context engineering: a QuickJS/WASM sandbox where tool results never enter the model's context, four MCP exposure modes, a 3,000-token ceiling on inlined tool declarations, and a trick that appends a new system-prompt section to the transcript instead of mutating tool definitions so your prompt cache survives. Plus the deliberate omissions (no sub-agents, no plan mode), the $0.05 cache-warming rule, and the trust gap that loads a cloned repo's AGENTS.md without asking.

DDeepSeek Harness: the agent where the agent loop itself is a plugin

DeepSeek Harness (dsh) passed 242,000 stars and shipped desktop installers on 1 October 2026. The headline is 'everything is a plugin' — and unlike most such claims this one is load-bearing: the model adapter, the tool registry, the session log and the agent loop are all replaceable from a YAML patch file. This page covers the three facts that matter to a Claude user (it runs your existing Claude Code hooks.json, it speaks anthropic-messages, and run_code is codemode by default), the three-mode sandbox and the kernel primitives behind it, the append-only session log invariant, and the config override that silently deletes your other providers.

SStrata: a 125B MoE at 94 tok/s on a 12 GB Card — and the Exact Bill

Strata runs Qwen3.8-Flash-Next (125B, 6B active) on a 12 GB gaming GPU at interactive speed. This page explains the three architecture facts that make it possible, reads the benchmark table honestly, and prices the quality you give up: 91.3% of SWE-bench Verified against 98.7% of LiveCodeBench, a KV-cache setting that passes needle tests while losing 8-12% perplexity, a speed mode that strips refusal directions, and a measured vision regression on identical weights.

HHow to Read an AI Benchmark Without Getting Fooled

Every launch post leads with a benchmark number. Almost none of them tell you the three things that decide what it means: which scaffold produced it, how many trials it averages, and whether the model had already seen the answers. A reader's manual for SWE-bench, SWE-bench Verified, SWE-bench Pro and the arena leaderboards — with the vendor's own footnotes as evidence.

DDwarfStar (ds4) and the Rise of Overfit Inference Engines

ds4 is a 23.6k-star, pure-C engine from the creator of Redis that runs DeepSeek V4 Flash, GLM 5.x and Qwen3.8-Flash-Next locally — and refuses to run anything else. This page explains the three mechanisms a general runtime will not give you (asymmetric routed-expert quantization, bounded expert streaming from SSD, KV snapshots that survive a restart), reads its own numbers honestly — the 126 t/s headline is an eight-GPU aggregate across 16 sessions, not your Mac — and prices the real cost of the overfit bet: deliberately disposable model support, 761 open issues, and a main branch that last moved on 20 September 2026.

MMistral Large 4 (Le Chonk): the 1.05T open weight you can't download yet

Europe's trillion-parameter MoE: why 49B active params still need ~525 GB at 4-bit, the 1M context that evaluators measured at ~512K, a 50% launch promo that hides the real cost-per-task, an Intelligence Index of 38 against Opus 5.5's 58 — and the staged weight release where vetted partners get a less-moderated build first.

WWhistle: Speech-to-Text in 16.9 MB — and the Benchmark Bars Nobody Labelled

Cactus Compute's Whistle fits a multilingual ASR model in 16.9 MB and hits 11.1 ms to first token on a CPU. The size claim is real. This page reads the vendor's own benchmark chart bar by bar — including the three competitor columns it declines to label — and finds the pattern that explains every field complaint: Whistle wins on close-mic single-speaker audio and is the worst of the three on real meeting audio, 4.6 WER points behind a model 8.6x its size. Plus the 30-second architectural wall, the streaming API the launch thread missed, and the one knob that took a tester from 70/170 to 164/170.

DDeepInfer: DeepSeek's Own Inference Engine, Read Honestly

On 20 October 2026 DeepSeek open-sourced DeepInfer, the engine behind its production service — 16.3k stars in a day, 2,251 points on Hacker News. This page covers the four things the headlines missed: it is a vLLM fork, not a from-scratch engine; 'NVIDIA SM100' excludes every H100 and every consumer GPU you own; its decode throughput is published under full-acceptance accounting, which counts drafted tokens whether or not they were accepted; and its genuinely important feature — batch-invariant inference — is mutually exclusive with its own speculative decoder.

LLatent Reasoning: Agents That Think Without Words

HybridAgent is the first open-weight agent that does most of its thinking as hidden states instead of tokens — 170-183 latent steps per task against ~300 text tokens, 35.5-54.7% fewer tokens, 2.7-3.7x cheaper. The mechanism (a ~10M-parameter adapter), the reason it loops forever if you load it in llama.cpp, and why 'inspectable latent thoughts' is the most contested claim in the paper.

TThe Third-Party Memory Layer: How claude-mem Actually Works

claude-mem has 103,000 GitHub stars and solves the complaint every coding-agent user has: the agent forgets everything when the session ends. Underneath, it is a second model running in a background daemon that reads every tool call you make — and on the hosted path its own cost dataset maps that observer to a DeepSeek model, not Claude. The six hooks, the exit-code contract that can block your session, the three-layer recall that makes the token math work, where the data lands, who pays for the compression, and a checklist for evaluating any memory layer before you install it.

WWhy a 35 KB System Prompt Breaks on a Local Model

Moving a big Claude/GPT system prompt to Ollama or another local runtime: the context-budget math, Ollama's silent middle-of-prompt truncation, the failure signals of context exhaustion, and the restructuring that actually works.

Next

• Put it to work: Playbooks
• Go deeper: Power User

Share this page

• X
• LinkedIn
• Reddit
• Hacker News