The State of AI: A Field Report From Someone Who Actually Ships This Stuff

Last month I watched a coding agent refactor a 4,000-line service across eleven files, update the tests, and open a clean pull request in about twenty minutes. The same week, the same model confidently told a customer, through a support pipeline I help maintain, that a refund policy existed that has never existed at any point in the company's history. Both of these are the state of AI in mid-2026. If your mental model only contains one of them, you are going to make expensive decisions.

I build and operate ML systems in production. I've shipped through the deep learning wave, the transformer takeover, and now whatever we are calling this era. What follows is not a news roundup. It is a field report: what actually changed for people who ship, what turned out to be hype, and where I think the load-bearing work has moved.

The Scaling Era Ended Quietly, and Nobody Sent a Memo

For roughly five years, the industry ran on one recipe: more data, more parameters, more FLOPs, better model. The scaling laws papers, Kaplan et al. in 2020 and then Chinchilla in 2022, gave it the veneer of physics. Pretraining compute went up by orders of magnitude and capabilities followed.

Then, somewhere around late 2024, the returns visibly flattened. Not to zero, but the days of a new pretraining run making the previous generation look silly were over. The frank version got said out loud: the industry had more or less consumed the high-quality public internet. You cannot 10x a dataset that no longer exists to be collected.

What replaced it was a pivot everyone now takes for granted but which was genuinely surprising at the time: spend the compute at inference time instead. OpenAI's o1 in late 2024 was the proof of concept, and DeepSeek-R1 in January 2025 was the proof that the recipe was reproducible: train a model with reinforcement learning to produce long chains of reasoning before answering, and hard problems in math, code, and science get dramatically better. Not marginally. Benchmarks that had been graveyards, competition math, olympiad-level problems, suddenly fell.

The engineering consequence is underappreciated. We used to think of a model call as a roughly fixed-cost operation. Now inference cost is a dial. The same model, on the same question, can spend 500 reasoning tokens or 50,000, and the answer quality scales with the spend. That turns every production integration into an economics problem: what is this specific answer worth, and how much thinking are you willing to pay for? I now spend real design time deciding which requests deserve the expensive reasoning path and which get the fast cheap one. That routing layer did not exist as a concept three years ago. Today it is one of the highest-leverage components in our stack.

DeepSeek Was the Repricing Event

January 2025 deserves its own section because it reset assumptions across the whole industry. DeepSeek, a Chinese lab spun out of a quant fund, released V3 and then R1 with open weights, published training reports, claimed the V3 pretraining run cost on the order of $5.6 million in GPU time, and priced API inference at a small fraction of what the frontier labs were charging. Nvidia lost roughly $600 billion of market cap in a single trading day, the largest one-day loss for any company in history at the time.

The headline number was arguable, the $5.6M excluded research, infrastructure, and prior runs, but the direction was not. Frontier-adjacent capability turned out to be achievable with an order of magnitude less money than the prevailing narrative assumed, using mixture-of-experts routing, aggressive low-precision training, and clever engineering under export-control constraints. And because the weights were open, everyone could verify it and build on it.

For practitioners the effect was concrete and permanent: the open-weight floor rose to somewhere between six and twelve months behind the closed frontier, and it has roughly stayed there. In 2023, if you wanted top-tier capability, you had exactly one procurement option: a closed API. In 2026, for a large class of tasks, a distilled or fine-tuned open-weight model running on hardware you control is genuinely competitive, and it changes every conversation about cost, latency, data governance, and vendor risk. I have moved several internal workloads off frontier APIs onto self-hosted open-weight models this year, not for ideology, for the unit economics.

The irony nobody predicted: cheaper inference did not shrink spend. It expanded it. Every workload that was uneconomical at the old price points became viable, and total token consumption went vertical. Jevons paradox, live and in production.

Capabilities Are Real, and Jagged, and the Jaggedness Is the Whole Problem

Here is the thing I keep trying to explain to executives: the models are not "smart" or "dumb" along a single axis. They are jagged. The same system that solves competition math problems will fail a task a careful intern handles reliably, and the failure boundary does not follow human intuitions about difficulty.

The pattern I keep seeing this year: a model performs beautifully on the demo distribution, everyone extrapolates a straight line, and then production traffic finds the jagged edge within a week. Long-horizon tasks are where it shows most. A model that is 95% reliable per step is a coin flip after fourteen steps; agentic workflows live or die on that arithmetic. The reasoning models pushed the reliable-horizon out substantially, tasks that take a skilled human an hour are now routinely automatable, and that boundary has been moving fast. But "moving fast" is not "solved," and the systems I trust in production are the ones with checkpoints, verification steps, and cheap rollback, not the ones betting on a 40-step autonomous run completing cleanly.

Coding is the domain where the change is least deniable. Agentic coding tools went from curiosity to default in about eighteen months. The majority of engineers I know now work with an agent in the loop for a meaningful fraction of their output, and internal claims from the big labs that a large share of their own code is now model-written stopped sounding absurd. What did not happen is the elimination of engineers. What happened is the job tilted: less typing, more specifying, reviewing, and architecting. Code review became the bottleneck. Taste became the scarce skill. I read far more code than I write now, and the review muscle matters more than it ever has, because the failure mode of model-written code is not syntax errors, it is plausible-looking code that is subtly wrong about your system's invariants.

Evaluation Is the Bottleneck, and Almost Nobody Staffs It Like One

If I had to name the single biggest gap between AI discourse and AI practice, it is this: everyone argues about capabilities, and nobody can measure them.

The public benchmarks are cooked, sometimes literally. MMLU, HumanEval, GSM8K, all effectively saturated, and all almost certainly contaminated: their test items have been on the public internet for years, which means they are in the pretraining data. Researchers demonstrated repeatedly that renaming variables or perturbing numbers in benchmark problems drops scores in ways that should not happen if the model actually generalized. GSM8K's authors' follow-up work on perturbed variants (GSM-Symbolic) showed exactly this. New benchmarks get released, get climbed, and get contaminated within a cycle. FrontierMath and Humanity's Last Exam bought some headroom by keeping problems private and brutal, but even "private" benchmarks have had access-and-funding controversies that eroded trust.

So the honest answer to "which model is best" is: best at what, measured how, on whose data? In practice, the only eval that matters is the one you build yourself, on your task, with your traffic, graded against your definition of correct. Every serious AI team I know has converged on the same shape: a versioned suite of task-specific evals, run on every model change, every prompt change, every retrieval change, treated exactly like a CI test suite. Building and maintaining that suite is unglamorous, expensive, and the single highest-ROI activity in applied AI right now. Teams that skip it are flying instruments-dark and finding out from customers.

The uncomfortable corollary: as models climbed past the ability of casual human review to grade them, we started using models to judge models. LLM-as-judge works better than it has any right to, and it fails in correlated, self-flattering ways that you must audit with periodic human samples. Evaluation used to be a chapter in the ML textbook. It is now a discipline, and it is understaffed everywhere I look.

Production AI Is 10% Model, 90% Plumbing

The demo-to-production gap has not narrowed nearly as much as the demos have improved. The model is the easy part; you rent it. Everything around it, you build:

• Data plumbing. Retrieval pipelines, chunking, freshness, permissions-aware indexing. Most "the AI is wrong" incidents I have debugged this year were retrieval bugs wearing a model costume.
• Guardrails. Input validation, output schemas, policy filters, prompt-injection defenses. The moment you give a model tools and access to untrusted content, you have created a confused-deputy problem, and prompt injection remains fundamentally unsolved. We mitigate; we do not prevent.
• Cost control. Token budgets, caching, model routing, batch tiers. At scale, an unmonitored agent loop is a machine for converting venture capital into GPU heat.
• Observability. Tracing every generation with its full context, so that when something goes wrong you can replay it. "It said something weird yesterday" is not a bug report you can act on without traces.

None of this is intellectually glamorous. All of it is where production AI actually lives. Which is also what "AI engineer" turned out to mean. The title barely existed in 2022; now it is one of the most posted roles in the industry, and the job is not training models, maybe one team in fifty does that. It is systems engineering against a stochastic dependency: evals, retrieval, orchestration, guardrails, cost. Distributed-systems instincts transfer almost perfectly. The people struggling are the ones who expected it to be modeling; the people thriving are the ones who noticed it is production engineering with a probabilistic component.

Follow the Money: It All Flows to Compute

Whatever you think about AI economics, the capital expenditure is not subtle. The hyperscalers collectively guided to hundreds of billions of dollars of capex for 2025, the overwhelming majority of it AI datacenter buildout, and projects like Stargate put half-trillion-dollar figures into press releases. Nvidia became the most valuable company on Earth selling the shovels. Power, not chips, is emerging as the binding constraint; datacenter electricity demand is now a factor in national grid planning, and I have sat in meetings where the blocker for a deployment was literally megawatts.

Meanwhile, most application-layer AI companies are margin-thin, because their COGS is inference, and inference pricing is set by the same handful of vendors they compete with. The revenue is real and growing fast, but the gap between aggregate AI capex and aggregate AI revenue is the number every skeptic cites, and they are not wrong to cite it. My read from the trenches: the productivity gains I can personally verify, in software engineering, in support deflection, in document-heavy workflows, are real and compounding, and they are also nowhere near the level the aggregate spend is priced for. Yet. One of those two numbers is going to move to meet the other, and 2026 feels like the year the market starts demanding to know which.

What I Tell Engineers Who Ask Where This Goes

The capability curve is still climbing; it just climbs through inference compute, better post-training, and synthetic data now instead of raw pretraining scale. The reliability curve is climbing slower, and reliability, not capability, is what gates deployment. The distance between those two curves is where all the interesting engineering work lives, and I see nothing on the horizon that closes it for free.

So my bet for the next few years is boring and I hold it with conviction: the winners will not be the teams with access to the best model, because everyone has access to roughly the best model. They will be the teams with the best evals, the cleanest data, the tightest feedback loops, and the discipline to measure before they believe. The models became remarkable. Now comes the part the demos never show: making remarkable dependable, one unglamorous pipeline at a time.

That work does not trend on anything. It is also the only work that decides whether any of this was worth the megawatts.