DeepSeek open-sources DeepInfer, Cloudflare backs a Rust TypeScript, and JetBrains measures what agents are really asked to do

DeepSeek put its production inference engine on GitHub on Monday morning. By Tuesday the Hacker News thread had 364 points and the vLLM team had published a matched-configuration comparison. DeepInfer is the stack serving V4.1-Flash: distributed inference, speculative decoding, structured output, NVIDIA and Huawei Ascend backends, Apache 2.0, built initially on vLLM with credit to SGLang and TensorRT-LLM. The engineering report alongside it is the more consequential document. DeepSeek reports 155 trillion tokens a day from one cluster, a 96% input-cache hit rate, 400 ms average time to first token, and 230 tokens per second of generation, 300 for coding. AINews ran the cluster math: at off-peak prices of $0.15 and $0.60 per million input and output tokens, that is about $38 of revenue per accelerator-hour against an all-in cost of $5 to $8, an inference margin above 80% and an 81-day payback. Two caveats carry the weight. The KV-cache manager and load balancer, the components most tied to that margin, are not in the release because they remain coupled to internal infrastructure. And vLLM reported decode throughput within 6% of DeepInfer’s published GB200 numbers under a matched config, which undercuts the idea that DeepSeek’s serving efficiency is out of reach for existing open engines. The architecture notes still earn a read on their own. Prefill is scheduled on estimated attention compute rather than request length. Prefix caches live in shared storage, so routing needs no cache affinity. Decode balances on both running-request count and accumulated KV length, popular MoE experts are replicated across devices, and the disclosed Blackwell layout uses no tensor parallelism. Separately on HN, a Stork AI post noted Alibaba raised output prices on its hosted DeepSeek V4 Flash 0731 by 230%. The model’s price and the first party’s price are different numbers.

Cloudflare and VoidZero are backing tsrs, a Rust port of the TypeScript compiler started by Max Schwenk of Owner.com, incubated under the Oxc toolchain and built with the TypeScript team rather than around it. Boshen Chen’s post is explicit that this is not a fork. The TypeScript team keeps full control of the language, and the port tracks the original implementation strictly, including decisions that took years of prototyping upstream. Early benchmarks, run in the same configuration as upstream and agreed with the TypeScript team, show tsrs up to 8x faster than TypeScript 7.0 with about 70% less memory at the same worker count. TypeScript 7.1 beta is itself up to 2.5x faster than 7.0, and some of those optimizations were upstreamed from tsrs. The case for Rust over the existing Go port is WebAssembly. A Go binary carries its garbage collector into Wasm, while Rust’s memory model lets a Wasm guest and host share memory directly, which is what makes a full type checker viable inside a Worker or a browser tab. The post also answers why now: frontier models can do large ports in days, and the team has already watched slopforks appear alongside faithful ports. Maintenance borrows the Vinext process, where an agent reviews upstream diffs each morning and the upstream test suite reruns against the port each night. Theo Browne’s tsc-rs is being merged in, and npm install tsrs gets you the experimental release.

PyTorch Conference opened with two hyperscalers shipping native PyTorch for non-NVIDIA silicon within an hour of each other. Google published TorchTPU integrated into TorchTitan alongside new vLLM and SGLang inference engines on TPU, and AWS moved TorchNeuron, native PyTorch support for Trainium, into public beta. Read together with DeepInfer’s Ascend backend, the day’s theme is that the serving and training layers people already use are being made to run on whatever accelerator the cloud happens to own. AINews adds one independent data point: Inferact reports 391 tokens per second per user for Kimi K3 on TPU v7 using open-source megakernels in vLLM TorchTPU.

JetBrains Research analyzed 4,782 coding-agent sessions from engineers working in JetBrains IDEs and compared them with SWE-Bench Pro. The paper, accepted to the Evaluation of Interactive Agents workshop at NeurIPS 2026, finds that bug fixes and new features make up less than half of what developers ask an agent to do; the rest is explaining the codebase, planning, review, refactoring, and running commands. SWE-Bench Pro, labeled by the same Gemma 4-31B classifier, is 93.8% features and bug fixes, delivered as one polished message. Half of real sessions are a single message too, but a third run to three or more. Their fix is SWE-TaskFlow, which keeps the repository, environment, and tests of an existing benchmark and regenerates only the user messages: each issue becomes three ordered requests the agent sees one at a time, with repository questions interleaved, each shipped with a reference answer and an executable proof script. Running GPT-5.6 Luna, GPT-5.6 Terra, GPT-5.4 Mini, and Gemini 3.7 Flash on 700 tasks, splitting the issue made every model 2.0 to 2.6x more expensive per task while resolve rates moved only 0 to 5 points. A control that pastes the three rewritten parts into one message lands next to the single-message baseline, so the cost comes from sequential delivery, not rewording. The dataset is on Hugging Face with 12 configurations.

Mistral launched Voxtral 3, a speech stack covering batch and streaming transcription, multilingual text-to-speech, and a voice-agent SDK with tool calling, available through the API or on customer infrastructure. The HN thread reached 119 points. Artificial Analysis places Voxtral Small Transcribe 3 third on its leaderboard at 2.1% word error rate.

Amazon Bedrock now supports structured outputs for all Claude models on both the bedrock-runtime and bedrock-mantle endpoints. Whether you call Claude through boto3 or through the Messages API, responses can be constrained to a defined JSON schema without the parse-and-retry loop most Bedrock integrations have carried until now.

On r/LLMDevs, a developer audited 73 agent trajectories and found 74% carried measurable waste; one agent spent 35% of its total I/O re-verifying its own work. The tool, chewme-audit, is an MIT-licensed CLI that reads Langfuse, LangSmith, JSONL, and Claude Code transcripts and categorizes wasted tokens by cause. The JetBrains cost finding above suggests where some of that waste comes from: requirements that arrive in pieces make agents re-check what they already did.

Kent Beck draws a line between toil and struggle. Reformatting a 2013 essay whose markup had been stripped is toil; he handed it to a model and got nothing from doing it by hand. Spending three hours on a discrete-math proof on the train from Eugene to Seattle as a freshman was struggle, and the rush of finishing it changed what he believed he could attempt. His position: if the only thing you get out of coding is code, the distinction is irrelevant and cheaper is better. If the people involved matter, how you got there sets up what you can do next. He wants the model to take the toil and leave him the struggle.

Feed note: the code-intel-copilot mirror_status endpoint reports a last sync of 2026-09-01, while the item data it serves runs through 06:57 UTC today. The status metadata disagrees with the data; this issue is built from the data.