Open-Source AI Is Closing the GPT-5 Gap. But How Fast?

If you build agents for a living, you probably noticed two things this year. Frontier closed models keep getting better on paper. At the same time, more developers say the models they pay for feel worse in day-to-day use, while a smaller open model handles the boring 80% of their workload just fine.

So, how close are open-source models to GPT-class performance? Pretty close, although the answer depends heavily on the task. On broad reasoning and coding benchmarks, the distance is now only a few points. The proprietary frontier still wins on the hardest problems, multimodal breadth, and long-running agent tasks.

What “GPT-5-Class” Means in 2026

“GPT-5-class” is a moving target. GPT-5 launched on August 7, 2025. Since then, OpenAI alone has shipped 5.1, 5.2, 5.4, 5.5, codenamed “Spud,” in April 2026, and 5.6.

On Artificial Analysis, the original GPT-5 (high) is now marked deprecated and scores below the current median. The model did not get worse. The benchmark became harder, and the rest of the field moved ahead.

When someone asks whether open models have “caught GPT-5,” a better question is whether they have caught the current top proprietary reasoning tier. That tier now consists of a small group of models rather than one GPT version. Keep this in mind whenever a release claims to beat a specific model because the comparison may already be stale by the next quarter.

How Big Is the Gap?

Every lab reports the benchmarks where its models perform best, so measuring the gap gets messy. One reasonable approach is to use a neutral composite index.

The Artificial Analysis Intelligence Index combines nine difficult evaluations, including Humanity’s Last Exam (HLE), GPQA Diamond, Terminal-Bench, and long-context reasoning.

The best open-weight models trail the leading proprietary model by about six points. That sounds close, but the average hides some large differences between tasks.

⚠️ One caution before trusting any single number: Most open-model benchmark results are vendor-reported rather than independently verified, according to an August 2026 analysis from Morph. None of the SWE-bench Verified entries it tracked at the time were listed as independently verified. Treat “we beat GPT-5.x” claims in release announcements as something to test on your own data, not as a concrete fact.

Where Open Models Already Win

The retrieval layer and other narrow tasks are the easiest parts of an agent stack to move away from expensive frontier APIs.

Embeddings and reranking are the clearest examples. The Qwen3 embedding family shipped under Apache 2.0 with a 32,768-token context window, and its 8B model entered the MTEB multilingual leaderboard at number one.

Qwen3-Embedding-0.6B costs about $0.011 per million tokens to serve, which is tiny compared with many hosted alternatives. For retrieval-augmented generation (RAG), self-hosting the retrieval layer is already a practical option rather than an experiment.

Generation for narrow tasks is another good case. Alibaba’s Qwen3.8–27B, also released under Apache 2.0, scores 52 on the Artificial Analysis Intelligence Index. It quantizes to roughly 14 to 17 GB and can run on a single 24 GB GPU.

That is enough for classification, extraction, routing, and routine drafting without paying a per-token API bill for every request.

When the frontier is still the better choice: Use the frontier model when a task needs the best available reasoning and open alternatives fail your evaluation. Saving money on inference does not help if task success drops enough to create more work elsewhere. Measure the results first. Superlinked’s guide to what small open-source models can handle is a useful starting point.

Free to Download Is Not Free to Run

The open models competing near the frontier are enormous. Their weights may be free to download, but the GPUs are definitely not. We wish.

Many of the leading open models are mixture-of-experts (MoE) systems, and their weights still need to sit in GPU memory. Running the largest ones requires a cluster, not a gaming laptop.

These are approximate 4-bit footprints based on public deployment notes. You also need headroom for the KV cache, which grows with context length. The Kimi K3 estimate comes from a 2026 self-hosting cost breakdown.

The real comparison is not a free open model versus an expensive API. It is a per-token API bill versus GPU costs plus the engineering and operational work required to keep inference running.

Whether self-hosting makes financial sense mostly comes down to utilization. A GPU sitting idle is expensive hardware doing nothing. Superlinked’s analysis of whether you should self-host inference is a good starting point for working through that decision.

Route by Task, Not by Model

A production agent may perform several different jobs in one run:

• Embed a query
• Retrieve and rerank documents
• Extract fields
• Draft a response
• Handle the occasional difficult reasoning step

These jobs have very different capability requirements. Sending every step through one frontier API creates a large bill for work that a much smaller model could handle.

A more practical setup is to route each task to the right model.

This keeps high-volume routine work on cheaper infrastructure while saving frontier tokens for the steps where the stronger model changes the outcome. Superlinked’s practical guide to choosing models for agents goes deeper into this type of routing setup.

YOLOing It Yourself

Let’s say you have completed the evaluation and found that open models clear the bar for retrieval, extraction, and routine generation. The next problem is running all those encoders, rerankers, extractors, and generators without maintaining a separate serving setup for each one.

That is what SIE, the Superlinked Inference Engine, is designed to handle. SIE is an open-source inference engine that provides one endpoint for more than 100 open models covering embeddings, sparse retrieval, reranking, extraction, OCR, and text generation. It can run on your own hardware or through Superlinked Cloud.

There are two things SIE does not do:

• It does not make an open model smarter. SIE serves the model you choose, but it does not close the capability gap measured in this article. If a task needs a frontier model, SIE will not change that.
• It is not automatically cheaper. When traffic is low or inconsistent, a hosted API may still cost less. SIE makes more financial sense when the GPUs stay busy.

If that sounds close to your setup, the quickstart is the fastest way to test it. The SIE versus OpenAI breakdown also explains the hybrid approach: self-host the routine work and keep a frontier API available for the hardest 10%.