In January 2025, OpenAI released an agent that could use a browser to order groceries or book a reservation. Its own system card reported that the underlying model completed just 38.1% of tasks on OSWorld, a benchmark of computer use. That score wasn't a shopping success rate, but it put the achievement in perspective: an AI could operate software, and handing it the controls still required supervision. Operator system card.

That tension explains 2025 better than a list of model launches. Reasoning became more accessible, models gained ways to act, and cheaper inference made more applications worth trying. What did those improvements actually change for someone building software? They expanded the work we could attempt while making evaluation and integration harder to avoid.

This is a retrospective on 2025, viewed from January 19, 2026. The release dates and cost attribution have been fact-checked in an October 2026 editorial revision; the conclusions retain that historical scope.

Reasoning became a choice developers could make

The year began with a capability already in motion. OpenAI released the full o1 in ChatGPT on December 5, 2024. Spending more computation before answering gave developers another way to approach difficult problems, alongside choosing a larger model or supplying better context. More thinking still had to justify its additional time and cost. OpenAI's o1 announcement.

DeepSeek released R1 on January 20, 2025, reporting performance comparable to o1 on math, coding, and reasoning evaluations. It also released six smaller models distilled from R1, based on Qwen and Llama. Distillation means training a smaller model on examples produced by a larger one. Those smaller releases made experimentation possible on a different hardware budget from the full R1 model. The smaller models were available alongside R1 at launch. R1 release, R1 technical report.

The famous training-cost figure needs care. The roughly $6 million figure came from the DeepSeek-V3 report: $5.576 million for its official training, calculated from 2.788 million H800 GPU-hours at an assumed $2 per hour. The report excluded prior research and ablation experiments. That figure does not establish R1's total development cost. The efficient training work was substantial enough without assigning its price tag to a different model. DeepSeek-V3 technical report.

The useful engineering consequence was choice. A team could evaluate a reasoning model through an API, experiment with released weights, or investigate a smaller distilled model. None of those options guaranteed equal performance on its own task. A model that does well on a mathematics benchmark might still misunderstand an invoice exception or generate the wrong database query.

I would treat additional reasoning like giving someone more time to check a calculation. It can help if the problem requires several steps. It won't supply a missing exchange rate or correct an outdated business rule. The decision is where extra computation improves a result you can check.

Models acquired a route into applications

Google made Gemini 2.0 Flash generally available on February 5, with multimodal input, native tool use, and a million-token context window. Pro was experimental at that point. Flash's generally available output was text; image and audio output were still listed as forthcoming capabilities. Those release distinctions matter when a team is deciding what it can build and support. Google's February release.

Tool use gives a model a way to request work from other software. Consider an illustrative customer-support workflow: find an order, check the delivery record, and prepare a reply. The model selects the operations and interprets their results; application code performs the authorized lookups. That is a useful step beyond asking a chatbot to compose an answer from whatever happens to be in its context.

OpenAI's March 11 release of the Responses API and Agents SDK supplied more of the surrounding machinery, including tools and tracing. Tracing records the steps so developers can investigate where a workflow went wrong. These facilities reduced the amount of coordination code a team had to assemble itself. OpenAI's agent tools release.

They didn't settle what should happen when two orders have similar customer names, a lookup times out, or the delivery record contradicts the customer's account. Those are application decisions. Better tools let a model reach the data; the team still has to decide what the data permits it to do.

Computer use extended that idea to interfaces without convenient APIs. Anthropic had introduced its public beta in October 2024, before Operator's January release. The ability to read a screen and click through an old application opened a useful path into existing software. Operator's documented confirmation steps and limitations also showed why a successful demonstration was insufficient evidence for unattended operation. Anthropic's computer-use release, Operator system card.

Coding followed a similar path. Anthropic introduced Claude 3.7 Sonnet and a Claude Code research preview on February 24, then Claude Opus 4 and Sonnet 4 on May 22. Claude Code could inspect files, edit code, and run tests, bringing the feedback from those actions back into the task. February announcement, May announcement.

Tools such as Devin, SWE-agent, and Claude Code made the coding-agent category worth examining. My test for their usefulness is the same one I'd apply to a human-authored change: does the implementation satisfy the requirement, and what evidence would catch a mistake? Producing a patch is an accomplishment. Reviewing its assumptions remains engineering work.

Lower prices changed what was worth trying

R1's launch pricing gave a concrete example of the new economics: $0.55 per million uncached input tokens and $2.19 per million output tokens. Cached input had a separate $0.14 rate. These are historical launch prices, not current quotes or evidence of equal quality across models. DeepSeek's January announcement.

Take an illustrative request with 10,000 uncached input tokens and 2,000 billed output tokens. At those rates, the model charge is $0.00988, just under one cent. A million such requests cost $9,880 before retries, other services, or human review. Long reasoning outputs would change that calculation. Cheap per request and negligible at scale are different judgments.

Google also simplified Gemini 2.0 Flash pricing by removing the earlier distinction between short and long contexts. Its announcement explicitly tied possible savings to the mix of requests. That is a better way to think about falling inference prices than declaring that cost has stopped being a constraint. Google's pricing explanation.

For document analysis or continuous code review, cheaper calls can justify testing a workload that previously looked uneconomical. Whether it should run continuously depends on how often it produces a useful result. A cheap answer that needs repeated correction can cost more than a more expensive answer that passes review on the first attempt.

Downloadable models widened the deployment options

Meta released Llama 4 Scout and Maverick on April 5. Their mixture-of-experts design activates a subset of the model for each token, reducing the computation relative to using every parameter for every step. The full weights still have to live somewhere. An active-parameter count alone doesn't tell you the memory required to host the model. Meta's Llama 4 announcement.

Mistral's December 2 release added Mistral Large 3 and smaller Ministral 3 models under Apache 2.0. Together with DeepSeek and the broader model ecosystem, releases like these gave teams more choices about where inference ran and how they could adapt a model. That matters when data access, customization, or operating control determines the deployment. Mistral 3 announcement.

The following inventory captures the kinds of components a team could assemble by late 2025. Its "open-source" label is shorthand for an ecosystem: individual model versions have different licenses, hardware needs, and compatibility. It is a menu, not a tested stack or a claim that every listed model fits on a consumer GPU.

# The open-source stack by late 2025
Model weights:    Llama 4, DeepSeek R1, Mistral Large, Qwen 2.5
Inference:        vLLM, TGI, llama.cpp, Ollama
Fine-tuning:      Axolotl, Unsloth, TRL
Evaluation:       lm-eval-harness, HELM, custom evals
Orchestration:    LangGraph, CrewAI, AutoGen

Running existing weights, fine-tuning a smaller model, and training a frontier reasoning model are very different projects. A team with modest GPU resources could investigate the first two without having the resources for the third. Download access made that investigation possible; it didn't make the operational work disappear.

What I would carry into 2026

The releases support a practical conclusion: by the end of 2025, developers had more ways to build AI into an actual workflow. Reasoning models broadened the difficult tasks worth testing. Tool interfaces and coding agents connected generation to action and feedback. Lower prices and downloadable weights expanded the deployment choices.

I would put the next effort into proving that a particular workflow works. For the support example, that means testing ambiguous orders and failed lookups, validating proposed actions, and recording enough of each run to explain a wrong answer. A human checkpoint belongs where an error would be expensive to reverse. The evaluation should measure the whole task, including retries and review, because that is what the customer experiences and the business pays for.

A public benchmark helps choose candidates. A model's price helps estimate a budget. Neither tells you whether your system will update the right order. The achievement of 2025 was that more teams could attempt that complete system. The responsibility heading into 2026 was to establish where it could be trusted and give the remaining cases a dependable way back to a person.