The Models Are Interchangeable Now. Stripe Paid $7B for the Switch.

Everyone says training data is the moat. It is also the liability the moat is built from — which is why no frontier lab will ever open its corpus.

Docker joined the agent-sandbox war this week. The isolation is the free part — here's what you're actually choosing.

why the fix for a slow, context-hungry multi-tool agent is a code sandbox — and the patent that just landed on top of the idea.

The felt Opus 5 regression is a training-objective trade on the one axis no leaderboard measures.

why a 16-year WAL race survived the most-tested code most engineers will ever ship — and fell in 15 minutes.

the session — not the subagent — is Claude Code's real unit of parallelism, and the control plane for it shipped this week

why a secret you ship to the client isn't a secret — and what that does to the distillation moat

Oracle bans AI-generated code from OpenJDK and allows it in GraalVM — same company, opposite calls. The variable that decides isn't the tool. It's whether you can warrant where the code came from.

This week the whole industry argued about whether AI makes coding skill matter more or less. Both sides are measuring the wrong thing.

AMD paid to bake a model's weights into silicon. The economics turn on one number — how long the model stays worth freezing.

One file every agent reads — and everything that actually governs the agent, still stuck in one harness.

why the biggest drain on your context budget isn't the preamble — it's what your tools print back, and how to compress it before the model reads it.

Why a saturated benchmark and a commoditized model are the same event, arriving on the same day.

a layer-streaming trick puts a frontier-class model on your laptop GPU — and quietly moves the wall from what fits to how fast you can feed it

Why the rule you paste into an agent's context is a suggestion that decays with distance — and what actually binds an autonomous system

The EU AI Act's synthetic-content marking rule takes effect today — measured against what marking can actually deliver.

The new MCP spec drops server-side sessions — here's what changes in your remote server on Monday.

Why "an AI found a flaw in the algorithm itself" is a labor story, not a security story — and how every result sorts by what you can check.

why the payoff from fanning agents out is the tokens you keep out of your main window — and how to see what the workers you never watched actually did.

why the Zig→Rust arrow, not the eleven days, is the real lesson of the agent-fleet port.

OpenAI turned ChatGPT ads into a self-serve business this week. The real question isn't whether it sold out — it's whether a conversation can keep the ad and the answer in separate slots.

Anthropic cut 80% of Claude Code's system prompt and lost nothing — so what should you cut from yours?

Why "the hyperscalers can pay for it from cash flow" is a claim about the wrong balance sheet.

Why AI is out-counterexampling mathematicians but not out-proving them — and why your coding agent sits on the same line.

why OS-level sandboxing cuts 84% of your permission prompts without going YOLO — and where the box still leaks

The agent writes most of the code and the human reviews it — but review is the exact skill automation erodes.

OpenAI quietly cut Codex's context window from 372k to 272k. The number it cut *to* is the one that was always real.

Microsoft's bet that governed, good-enough models beat the frontier — where it wins, where it breaks, and why the real product is the router, not the model.

Your coding agent is a networked program holding your keys — here's how to see what it actually sends.

the fixed preamble every request pays — measured, itemized, and trimmed

An on-device transcriber just matched the cloud on English accuracy at zero marginal cost — so what is the round-trip still buying you?

Chinese open-weight models now serve nearly half of US enterprise tokens. The reason is boring, the export playbook can't reach it, and you are probably already running them.

How much of AI's capex boom is real demand — and which link breaks first if it isn't.

The browser turned into a typed tool surface this week. There are three ways an agent can read a page — and only one of them guesses.

Five frontier models shipped this week. xAI paid $60B for the one thing they can't copy from each other.

Why the right unit of automation isn't the prompt or the CLAUDE.md line — it's the deferred body you pay for only on use.

The committer went off-camera this week. Your audit trail is the brake that's left.

An LLM agent ran a full ransomware attack end to end. Look at where it got in.

The web's payment layer sat unused for 30 years because humans hesitate over a penny. Agents don't. That single fact is why HTTP 402 is finally waking up — and why it changes how you price a developer product.

why a smarter model invents keys your validator rejects — and the two moves that stop it

developer docs quietly became a distribution channel for agents — llms.txt is the passive bet, MCP is the one that's paying.

why encoding source as PNGs to dodge text-token pricing trades a token cut for silent errors on the exact characters code depends on

how statistical LLM watermarking actually works — and the one quantity that decides whether it catches anyone

why the boundary that actually holds is code, not a pattern — and the matcher change that just broke a lot of hooks

the Claude Code "steganographic marking" panic, and why the marks you can see and strip aren't the tracking that matters

Long context didn't kill retrieval — the effective-context gap and the per-query bill keep both alive

OpenAI taped out a custom inference chip in nine months. The question isn't whether it works — it's when owning the silicon actually pays, and who keeps the savings.

When a model price cut is a moat move, not a gift.

How training on another model's outputs actually copies it — and why black-box access turns the copy into a volume game.

the retry stopped being an edge case — now it's the loop, and your tools are exposed.

The usable context budget is smaller than the advertised one — drive below the line, and don't let compaction pick what survives.

Why a model can emit tokens faster without changing a single one of them — and the two numbers that decide how much faster.

Why parallel coding agents collide, and the twenty-year-old git feature that fixes it before you reach for a new VCS.

The export ban made "go multi-provider" the reflex. A gateway swaps your URL in an afternoon. It can't swap your prompts, your tools, or your evals.

Why mixture-of-experts decouples a model's size from its price — and the two numbers to read on every model card.

how Claude Code's context compaction works, and how to stop it summarizing away the thing you needed.

What you actually buy — and build — when you ship an "agent."

The advertised discount is real; almost nobody collects it, and the reason is one number.

What it actually takes to replace Claude with a local model on your own machine.

"Open" tells you almost nothing about an AI model; the license — and whether it caps you — tells you the rest.

The crypto wars already ran this experiment. The government lost — and left American products weaker for a decade.

Nested sub-agents just shipped 5 deep. Here's what each one actually costs, and when one context is cheaper.

A coding benchmark number is a claim about a harness, not about your codebase — read it like one.

A funded, adopted, well-built open-source LLMOps startup just gave its money back. The product worked. The position didn't.

Two npm worms beat code review, signed provenance, and install-script scanning in one week. Here's why every layer failed, and what actually changes now.

When the model commoditizes, who owns the off-ramp?

We made agents proactive by default before we shipped the cost-control, consent, and observability to make proactive safe. Who pays, and who has to disclose?

Can AI coding tools survive honest pricing — and was the flat rate ever real?