Open-Source Models Are Catching Up to Frontier

The subhead on the inference pricing page says "open-source models catching up with frontier at a fraction of the cost, with zero egress to storage and inference," and this article exists to check that sentence. What follows turns it into arithmetic: what the intelligence scores say, what Telnyx's published benchmarks show against other providers, and what a realistic month of tokens costs at list rates on Telnyx inference.

How close are open-source models to frontier models now?

Open-source models now sit within one point of the proprietary frontier on aggregate intelligence scores. GLM-5.3, the open-weight flagship from Z.ai, scores 60 on the Artificial Analysis Intelligence Index, comparable to Kimi K3 and one point behind GPT-5.6 Sol at 61. Price is where the gap opens wide, and the cost section below runs that math with published rates.

The details matter more than the headline number. GLM-5.3, released in August 2026, ships under the GLM-5.3 License, while its faster sibling GLM-5.3 Flash ships under MIT. Flash was trained from scratch rather than distilled from the flagship: it is a 320-billion-parameter mixture-of-experts with 18 billion active parameters, and it scores 57 on the same index.

Proprietary labs still define the absolute ceiling, and GPT-5.6 Sol's 61 puts that ceiling one point above GLM-5.3 on the index. Most production teams ask a different question: which model covers the workload in front of it at a price the product can carry. On that question the open-weight field has an answer at every tier, and Kimi K3 on Telnyx marks the multimodal, 1M-context end of the range.

What the published provider benchmarks show

Once intelligence scores cluster this tightly, the serving layer decides what you actually get from the same open-weight model. Time to first token (TTFT) determines whether an interface feels responsive, and end-to-end response time (E2E) determines throughput. Telnyx publishes both metrics against named competitors: the GLM-5.2 provider benchmark measures E2E and TTFT for GLM-5.2 against Together AI, Fireworks, and Baseten, with the methodology on the page.

The GLM-5.3 provider benchmark covers the flagship: on 60 prompts shared across Telnyx, Baseten, Together AI, and Fireworks, Telnyx posted the lowest median completed-response time in five of six workloads and the lowest observed p95 in all six, with Together AI ahead on first-answer time in four and the small-sample caveats published alongside. The MiniMax-M3 benchmark makes the same comparison and lands on numbers worth quoting, because Telnyx served MiniMax-M3 12% faster than Together AI and 21% faster than Fireworks. There are GLM-5.3 Flash benchmarks published as well. If you compare providers yourself, keep TTFT and E2E separate, because a provider can win one and lose the other.

The cost math for open-source inference at list rates

Open-weight models sit within a point of the frontier on intelligence scores, and for the same monthly workload the open-weight flagship runs at roughly a quarter of the frontier rate. The pricing page calculator supplies the example workload: 150 million fresh input tokens, 350 million cached input tokens, and 60 million output tokens in a month, the shape of an application with long system prompts and repeated context. On GLM-5.3 that month costs $511.50 at list rates. On GPT-5.6 Sol, one index point ahead, the same month costs about $1,940 at OpenAI's published list rates. The full rate table lives on the pricing page, and GET /v2/public/pricing exposes the same table machine-readably for scripted comparisons.

If your application repeats context across requests, the cached input column moves the monthly bill more than the headline input rate does, and on the flagship cached input lists at 81% below the fresh rate. Model selection inside the open tier often swings the bill more than the provider comparison does, because the same month of tokens spans more than 20x across the rate card.

The price gap is structural rather than promotional, because the per-token price tracks the actual cost of running the model on GPU infrastructure Telnyx owns rather than rents, and the next section covers why that ownership keeps open-source inference cheap. Once you have a month of your own tokens priced both ways, the deeper planning patterns live in the scaling AI costs resource.

Why GPU ownership keeps open-source inference cheap

The rates hold for a structural reason: Telnyx hosts these models on GPU infrastructure it owns rather than rented capacity, so there is no cloud provider markup in the per-token price. The question worth asking any inference provider is who owns the silicon your tokens run on, because every rented layer between the hardware and the invoice adds a margin you pay. The GPU network writeup covers the infrastructure side of that story.

Ownership is also why the pricing behaves like a cost schedule rather than a market response. A provider renting capacity reprices when its supplier reprices, and the discount you were promised disappears into the new rate. Hardware you own has a cost curve you can plan against, and the per-token price can track the actual cost of running the model plus one margin rather than stacking a second one on top.

Ownership changes the data path too, with one nuance stated precisely: the chat completions endpoint does not store request or response data, while the responses endpoint does store conversations, with the region controls documented in the data residency guide. That endpoint-level specificity beats a blanket zero-retention promise, which is why Telnyx documents exactly which endpoint stores what.

The zero-egress half of the pricing page subhead refers to storage, where transfers between Telnyx Cloud Storage and inference carry no egress line item. Storage transfer fees are the classic hidden line in AI infrastructure bills, and the egress cost comparison walks the S3-versus-Telnyx math.

For agentic workloads the same ownership runs past the model layer. Functions execute application logic on the same stack, and stateful actors maintain agent memory without crossing a provider boundary, so the inference call, the tool execution, and the state read stay on one network. For platform teams shipping agents inside their own products, that single stack is the difference between one integration and several.

Switching to open-source inference is a base URL swap

None of the math above is actionable if testing it requires a migration project. Telnyx's inference API is OpenAI-compatible, so the request format, response format, and SDKs your code already uses keep working unchanged. The OpenAI compatibility docs reduce the switch to its mechanics: swap the base URL in your existing client and change the model name.

That two-line change is what makes the cost math above cheap to test against your own traffic. Point a staging environment at Telnyx, replay real requests, and read the difference off your bill rather than off a blog post.

The scores and the rate table carry the argument this far, and your own traffic settles the rest. Compare the published rates against your current bill, then pull your credentials from the Telnyx portal and run the comparison on real traffic.