The Engineer

The spec that matters isn't the parameter count — it's Kimi Delta Attention. Instead of paying full quadratic attention across a growing window, KDA maintains a fixed-size learned per-request state, claiming up to 6.3x cheaper decode at 1M tokens with pricing that stays flat as context grows. That's a genuine architectural bet, not a spec-sheet flex — but fixed-size state means bounded recall. Before you delete your chunk-and-retrieve RAG pipeline, test whether needle-in-haystack retrieval degrades at the tail, where linear-attention variants have historically failed.

The moat moved up-stack

Every source this cycle converges on one read: model selection is becoming a commodity decision, and the durable engineering sits in the harness. MemoHarness decomposed the agent loop into six editable control surfaces and scored 0.806 on Shell-Agent versus 0.722 for the strongest fixed-harness baseline — while lowering per-task cost. Anthropic separately moved an inventory agent from 62% to 92% accuracy on the same model using a five-task pass/fail loop. The accuracy ceiling is a systems problem, not a model problem.

Where the sources diverge

The disagreement lives in the pricing claim. @theo's counterpoint: K3's token efficiency and throughput often erase the per-token price advantage versus GPT-5.6 Sol — sticker price is not cost-per-completed-task. Serving 2.8T params realistically means tensor-parallel across 64-128 GPUs, so self-hosting only pencils above high request volume. Yet the economics are already shifting: open-weight models now take ~60% of OpenRouter tokens, and Google's inability to ship Gemini 3.5 Pro's coding upgrade shows the frontier premium is thinning exactly where teams lean hardest.

FLOPs no longer gate the frontier — attention architecture, routing, and harness quality do.

The smart move isn't ripping out your closed API. It's building the seam that makes the model swappable and the eval that tells you when to swap.

Skip the 11-day headline and read the token ledger. The $165K decomposed into 72B cached input reads, 5.9B uncached input, and 690M output tokens — the model re-read repo context roughly 12x more than it read novel input and ~100x more than it wrote Rust. Context caching is the dominant cost lever. Price that 72B pool at uncached rates and the project balloons to a multiple of $165K. Anyone modeling an AI-migration budget who ignores cache-hit economics will be wildly wrong.

The compiler was the hero, not the swarm

Sixty-four agents worked because Rust's borrow checker was the correctness oracle — each transformation was accepted or rejected, and 1,600 compiler errors formed the feedback loop that made autonomous migration safe. This generalizes only where you have strong compile-time or test-time gating. Run the same swarm against a dynamically typed target with weak tests and you ship silent correctness bugs at scale. Gradability — test coverage, type strictness, deterministic builds — is the precondition, and the gap between a gradable and non-gradable codebase is now a ~10x cost difference on this class of work.

Note the strategic subtext: Bun abandoned Zig for Rust specifically for memory safety in a production runtime — a data point against building runtimes on languages without memory-safety guarantees.

The moat is a gradable codebase plus the human judgment to know what to migrate and why.

One caveat threads through: an AI-migrated 535K-LOC codebase no engineer fully understands is a maintainability liability. Pair velocity with deliberate context-preservation — keep hand-writing critical paths and interrogate what the agents produced.

The GPT-5.6 Codex mechanism is mundane, and that's the point: in Full-Access mode without a sandbox, the agent overrides $HOME to a temp directory during environment setup, path resolution fails, and rm -rf lands on the real home directory. One engineer lost a production database. The model card admits GPT-5.6 takes more "severity level 3" actions than 5.5 — more capability, more side effects. A chroot or container boundary catches this; a config toggle does not.

The human-in-the-loop assumption just broke

Across 1,200 runs on six agent frameworks, stop buttons failed 215 times (18%) — payments and emails fired after cancel. That invalidates the kill-switch most agentic designs lean on. Treat agent actions like distributed transactions: saga/compensation patterns and pre-commit confirmation gates, not post-hoc cancels. The kill switch is the thing that failed 215 times.

The patterns that hold

Two defenses stand out. Prismata cut prompt-injection success from 85% to under 1% by sanitizing inputs before they reach the model — the XSS playbook applied to agents. And 1Password's zero-exposure injection hands the agent authenticated access through a channel it cannot read; it gets the capability, never the secret. That removes the model from the trust boundary — critical, because anything in a context window is loggable, cacheable, and reachable by injection.

One regression to flag: OpenAI encrypted agent-to-agent comms in GPT-5.6 Sol/Terra, so subagent delegation, cost attribution, and reasoning are no longer auditable. For audit-bound domains that pushes you toward single-agent or open-weight stacks you control.

Build agent infrastructure like a multi-tenant SaaS platform — assume every agent is potentially hostile and enforce the boundary at the infra layer.

Netflix's real-time service dependency map was burning more CPU on gRPC serialization and connection-pool management than on business logic. They reached for message queues first. That added complexity and returned nothing. The fix was Server-Sent Events with reactive streams: lighter text framing, backpressure that comes for free, and CPU spread evenly across instances. The hot nodes that had been carrying 10x load went away. Bandwidth dropped too. Read the caveat exactly. SSE is one-directional server-push. It wins for high-fanout streaming of changing state. It does not replace typed bidirectional RPC. This is not "drop gRPC everywhere."

The same failure mode on Base

The DeFi version is the same bug in a different stack. Base produces new block state every 200ms. Standard DEX aggregators poll over RPC at 250ms+ per fetch, so they quote on state up to 15 seconds stale. 0x measured propAMMs working exactly that window on 97.4% of swaps, at 5-10 bps each. PropellerHeads' Fynd streams block deltas into in-memory state and co-locates to kill the ~500ms round-trip.

When your latency budget is smaller than the network round-trip, the round-trip has to go — push-based streaming plus local materialized state.

The generalizable point is narrow. Any system that treats a fast-moving source of truth as request/response is mismatched at the architecture layer. Do the measurement before the optimization. Instrument the gap between your state-snapshot timestamp and current reality. Staleness you haven't measured is staleness you can't fix. And measure serialization plus connection-layer CPU as a fraction of the total before you assume the RPC framing is free. Netflix showed that tax can exceed the business logic itself.