DeepSeek Open-Sources Inference Framework, MiniMax M3.1 Flash Cuts Costs by 70% | AI Daily

This Issue's Highlights: The Dual Race for Inference Efficiency and Cost

The October 21 AI Daily rounds up six noteworthy stories, and the throughline is clear: on one side, DeepSeek^Ad has open-sourced its inference framework DeepInfer; on the other, MiniMax has driven the cost of coding and multi-step agent tasks down to 30% of what it was with M3.1 Flash. Both stories point to the same proposition—as model capabilities converge, engineering efficiency and unit cost at the inference layer are becoming the new competitive focus.

This issue also covers OpenAI's low-resource programming language benchmark, VoxChannel's voice toolkit, Mercury's diffusion-based text generation model, and GitHub Copilot's model retirement adjustments. Let's break each one down.

DeepSeek Open-Sources DeepInfer: What's Open Is the Offline Inference Core

On October 20, DeepSeek open-sourced its inference framework DeepInfer, providing optimized operators, multi-GPU parallelism, and asynchronous scheduling for V4.1 Flash under the Apache 2.0 license.

It's important to understand the boundaries of this open-sourcing. According to official documentation, what's primarily being opened is the offline inference core—the full online serving pipeline still requires you to build out the caching layer and load balancing yourself. In other words, this isn't a ready-to-deploy product you can download and immediately put into production. The Apache 2.0 license grants freedom for commercial use and modification, but the last mile of engineering implementation is still on the user.

This choice actually follows the usual logic of open-sourcing inference frameworks: operator optimization and multi-GPU scheduling are the parts with the most universal value and the clearest demonstration of engineering expertise, while components like caching, rate limiting, and elastic scaling are tightly bound to specific business shapes and hard to make into universally applicable open-source pieces. For teams planning to build their own inference services, DeepInfer's value lies in saving you from reinventing low-level operators and parallel scheduling—not in providing an out-of-the-box inference platform.

The difference between offline inference and online serving: Offline inference means the model processes data in batches without real-time request constraints, focusing on throughput and resource utilization—typical scenarios include batch generation and dataset labeling. Online serving requires low latency, high concurrency, and elastic scaling, and needs to additionally handle request queuing, cache hits, and rate limiting with graceful degradation. The operator optimization and multi-GPU parallelism that DeepInfer opens up mainly solve computational efficiency problems, while KV cache management, session persistence, and load balancing in the online pipeline belong to the service orchestration layer and are tightly bound to specific business needs—which is why vendors typically choose not to open-source them. Teams building their own services need to construct the serving layer on top of the open-source core; common approaches include integrating vLLM's scheduler, using Redis for caching, and implementing elastic scaling through Kubernetes.

What the Apache 2.0 license actually means: This license allows users to freely use, modify, and distribute the software, including for commercial purposes and in closed-source derivatives, requiring only that copyright notices and license text be retained, and explicitly providing no warranty. For inference frameworks, this means enterprises can integrate it into their own products without having to open-source their own code, reducing legal risk. Note, however, that the license does not cover patent grants (though it includes a patent retaliation clause), and modified distributions must still include the license.

MiniMax M3.1 Flash: The Costs and Prerequisites Behind the 70% Cost Reduction

On October 19, MiniMax launched M3.1 Flash, targeting coding and multi-step agent tasks, with the company claiming inference speed nearly three times faster and costs reduced by 70%.

The pricing is straightforward: $0.15 per million input tokens and $0.6 per million output tokens. This price point is quite aggressive for coding and agent scenarios—especially since multi-step agent tasks often involve numerous round-trip calls where token consumption can easily spiral out of control, and the drop in unit cost gets amplified by the number of calls.

However, there are two caveats to note. First, the weights have yet to be released—only the API form is currently available. Second, "nearly three times faster" and "70% cost reduction" are the vendor's own claims; actual performance will vary with task type, context length, and concurrency. For cost-sensitive teams, it's advisable to run a round of comparative testing with real business traffic before deciding whether to migrate primary workloads.

Token pricing and the cost amplification effect in multi-step agents: LLM APIs typically price input and output tokens separately—input refers to the context provided by the user (such as prompts, conversation history, and tool return results), while output refers to the content generated by the model. In multi-step agent tasks, the model needs to repeatedly call tools, read results, and generate the next step, causing context to accumulate continuously, with input token consumption growing approximately linearly with the number of steps. Therefore, a 70% drop in unit token price gets amplified by the number of calls in multi-round-trip scenarios—the actual cost reduction may be even more significant, but it also depends more heavily on task complexity and context management strategies (such as whether caching is enabled or history is trimmed). Teams evaluating should simulate the token consumption distribution of real workflows rather than just looking at unit price.

The difference between weight release and API form: Weight release means model parameters are downloadable, supporting local deployment, fine-tuning, and private deployment—suitable for data-sensitive scenarios or those requiring deep customization. The API form only provides cloud-based calls, where users can't control the underlying model but save on operational costs. MiniMax currently offers only the API, suggesting it may be prioritizing service stability and commercial returns; weights may be released later under an open license, but the timing is undetermined. For cost-sensitive teams that need private deployment, they'll need to wait for weight release or consider alternatives.

OpenAI's Low-Resource Language Benchmark: What Does an 87.4% Pass Rate Mean?

On October 19, OpenAI published test results for low-resource programming languages: GPT-6 Astra achieved an average pass rate of 87.4% across 20 languages for database construction tasks, with notable progress in migration from SoL to SoBow as well.

These numbers are worth noting, but should be read with restraint. This is a vendor-built benchmark, the test task is the relatively contained scenario of "building a database," and pass rates don't equal production readiness. The real pain points of low-resource languages often lie not in syntax generation but in the ecosystem—package management, build toolchains, version compatibility of obscure libraries—things that benchmark sets struggle to fully cover.

Actual business migration still requires human review and comprehensive testing. A more pragmatic approach is to treat such models as "first-draft generators": have them quickly produce a runnable skeleton in an obscure language, then have an engineer familiar with that language review the edge cases. An 87.4% pass rate shows the starting point is already much higher than a year ago, but there's still a gap before you can "hand it to the model and forget about it."

VoxChannel 3: The Three-Piece Voice Toolkit

VoxChannel launched on October 20, offering three categories of capabilities: transcription, voice generation, and voice agent toolkits, with the standout feature being the ability to call business tools while listening, plus batch transcription covering over 50 languages.

On pricing, the mini version costs $0.0035 per minute, currently available through API calls, with private deployment requiring contacting the vendor.

"Calling business tools while listening" is the more interesting part of this toolkit—it pushes voice agents from a pure conversation layer into a tool orchestration layer, making it suitable for ticket-type scenarios like customer service and work order processing that require real-time data lookups and actions during calls. Batch transcription across 50+ languages leans more toward post-processing needs, such as meeting notes and content archiving.

At $0.0035 per minute, the pricing is friendly for large-volume transcription tasks, but the actual cost of voice agents depends on the number of tool calls and session duration—evaluation should model these two factors separately rather than just looking at the transcription unit price.

Mercury 3: Diffusion-Based Text Generation with Million-Token Context

Mercury launched on October 19, adopting a diffusion-based text generation approach, with context extended to 1 million tokens, targeting real-time customer service and web agent scenarios.

The vendor's standard input/output pricing is $0.2 and $0.7 per million tokens, while noting that actual speed still varies by task.

The difference between diffusion-based text generation and traditional autoregressive decoding lies in the generation mechanism itself—theoretically offering different trade-off spaces in parallelism and latency characteristics, but publicly comparable data for this approach is still limited. A 1-million-token context is essential for web agents and long-document customer service, but the quality of effective information retrieval under long contexts, along with the resulting inference overhead, are both items that must be tested in practice during selection. The vendor's own note that "speed varies by task" also indicates that performance isn't constant.

The mechanistic difference between diffusion-based text generation and autoregressive decoding: Traditional large models (like the GPT series) use autoregressive decoding, generating token by token, with each token depending on the preceding text—inherently serial, with latency growing linearly with length. Diffusion-based text generation borrows from diffusion models in image generation, recovering text from noise through iterative denoising, theoretically allowing parallel generation of multiple tokens to reduce latency, but requiring multiple iterations with potentially greater computational cost. The two approaches have different trade-offs in parallelism, latency characteristics, and generation quality: autoregressive models are more mature in long-text coherence, while diffusion models have potential in parallel generation and controllability, though publicly comparable data is limited. Mercury's choice of this approach aims to explore differentiation in low-latency scenarios like real-time customer service, but actual performance needs empirical verification.

The challenge of effective information retrieval with million-token context: Extending the context window to 1 million tokens means the model can process ultra-long documents at once (like an entire book or a full year of meeting notes), but the quality of effective information retrieval under long contexts doesn't improve linearly. Models may face the "lost in the middle" problem—degraded recall for information in the middle of long contexts—while inference overhead grows with context length, driving up latency and cost. Practical applications need to combine retrieval-augmented generation (RAG) or segmented processing strategies rather than relying solely on long context.

GitHub Copilot Retires 6 Legacy Models: An Entry-Point Adjustment

On October 19, GitHub retired 6 legacy models across most Copilot entry points, including GPT 5.5 and Gemini 3.7 Flash, offering alternatives such as Soul Luna.

What needs to be distinguished is the scope of impact: this is only a model adjustment on the Copilot product side—it doesn't mean these models are discontinued across all platforms. Enterprise accounts may also need administrators to manually enable model policies, otherwise some replacement models may not be visible.

For development teams relying on Copilot, the practical impact lies in workflow stability—if the team has prompts or review standards based on specific models, output style and edge-case behavior may change after the model switch, making a round of regression validation worthwhile after the transition.

Three Trend Lines

Looking at these six stories together, three lines emerge.

Inference efficiency is becoming the main battleground. DeepSeek opens up optimized operators and multi-GPU scheduling, MiniMax attacks coding and agent scenarios with both speed and cost reductions, and Mercury switches approaches at the generation mechanism level—all essentially working at the inference layer. As the gap in model capabilities narrows, the gap in engineering efficiency becomes easier to quantify and compare on price.

There's still a gap between vendor benchmarks and production readiness. OpenAI's 87.4% pass rate, MiniMax's 70% cost reduction, and Mercury's million-token context are all numbers under vendor-defined terms. These numbers provide valuable reference starting points, but actual business migration still requires human review and comprehensive testing—this is especially evident in low-resource languages and agent tasks.

The division of labor between open source and managed services is becoming clearer. DeepInfer opening its offline core and VoxChannel requiring vendor contact for private deployment show that vendors increasingly understand which components are suitable for open-sourcing to build an ecosystem and which are better kept in managed services. Users need to judge based on their own engineering capabilities: build on the open-source core themselves, or use APIs to save time.

That's all for this issue.

One-line Summary

DeepSeek open-sources its offline inference core, MiniMax enters coding and agent scenarios with a cost advantage, and inference efficiency becomes the competitive focus.

Paragraph Summary

The October 21 AI Daily focuses on the race for inference efficiency and cost. DeepSeek open-sources the DeepInfer inference framework, opening the offline core but requiring users to build online serving themselves; MiniMax releases M3.1 Flash, targeting coding and multi-step agents with 3x speed and 70% cost reduction, though weights are pending release. OpenAI reports GPT-6 Astra achieving an average 87.4% pass rate for database construction in low-resource languages—a vendor self-assessment, with production migration still requiring human review. VoxChannel 3 offers voice transcription, generation, and agent toolkits, supporting business tool calls while listening. Mercury 3 adopts diffusion-based text generation with context extended to 1 million tokens. GitHub Copilot retires 6 legacy models—a product-side adjustment only. Three trends emerge overall: inference efficiency becomes the main battleground, a gap remains between vendor benchmarks and production readiness, and the division of labor between open source and managed services is becoming clearer.