One-Line Summary

A new method draws several tokens in parallel to cut response time in large language models, while papers spotlight causal inference pretraining, gradient-leak risks in split training, and a reliability layer for robot agents.

Research Papers

Uno: lossless parallel token generation with discrete diffusion

This paper proposes a way for a language model to write several tokens in parallel instead of one at a time, aiming to reduce response latency. The authors introduce diffusion-augmented large language models (LLMs) that keep an autoregressive (AR) model for quality but use discrete diffusion to sample multiple tokens at once from that same distribution; they call the resulting models Uno and provide a Ψ-Spec sampler to make the acceleration “lossless” and scalable at a fixed context length. ¹

Under the hood, Uno separates weights into autoregressive (AR) weights trained with standard next-token prediction (NTP) and lightweight diffusion weights trained to generate several tokens simultaneously. The diffusion weights are learned via a short Diffusion Distillation step that the authors describe as adding negligible overhead to existing training. ¹

Unlike speculative decoding, Uno needs no separate draft model; unlike prior diffusion LLMs, it aims to speed up generation without degrading the base model’s quality. In experiments, Uno achieves higher throughput than leading speculative-decoding methods at every evaluated batch size and up to 3× speedups over the base AR model, including at the device’s largest supported batch size; the authors also report code and checkpoints, and that an 8B Uno outperforms the 26B DiffusionGemma and the proprietary Mercury 2 across evaluated benchmarks in agentic tool use, coding, and long-context reasoning. ¹

What to watch: if parallel token draws hold up outside the lab, assistive tools and agents could respond faster without maintaining extra draft models. The paper says Uno can be trained from scratch or by augmenting open-weight AR models; reproduction and integration into common inference stacks will be the next tests. ¹

Causal foundation models: pretraining once, estimating effects in context

This tutorial-style paper brings the “pretrain once, adapt by prompts” idea to causal inference, where we estimate how a treatment changes an outcome. The authors define causal foundation models (CFMs): pretrained neural networks that can estimate quantities like the average treatment effect on entirely new datasets using in-context learning, with no further weight updates. ²

The paper walks through the necessary causal background and machine learning setup and includes example code and Jupyter notebooks. For practitioners, CFMs promise less bespoke pipeline work per study; the key questions are domain coverage, bias control, and how far in-context learning can generalize cause–effect estimation without fine-tuning. ²

Split-LLM training leaks data through zeroed gradients

This security case study shows how a two-node split training setup can leak which data rows are real through the gradient it returns. In the design, a Trusted Local Node (TLN) sends protected activations to an Untrusted Cloud Node (UCN) that returns outputs; the TLN holds the private loss and returns output gradients. Because decoy rows are ignored by the loss, their gradients are exactly zero — and that zero pattern reveals the real rows; across nine seeds, zeros identified 4,096 of 4,096 real rows on every frame under a pre-registered measurement protocol. ³

An attack on frame contents recovered about one extra token per hundred over a constant-guess baseline (+0.65 to +1.50 percentage points); shuffled-label controls recovered nothing. Row-wise clipping and noising of the returned gradient closed this specific leak for about 0.01 nats of held-out cross-entropy, but the authors note the system remains unsafe and several attack classes (including those accumulating observations across training steps) were not measured. ³

EmbodiedSkills: a check-verify loop for VLA robot agents

This framework adds a check-and-verify loop around a robot’s vision-language-action (VLA) policy so each skill is proposed, pre-checked for prerequisites, executed in bounded form, and then verified. A fixed executable-skill interface connects high-level selection, low-level VLA execution, and post-action verification, and it logs structured trajectories for supervision and optional online adaptation. ⁴

Instantiated with Qwen3-VL and OpenPI/pi0.5, EmbodiedSkills reports an average success rate of 86.20% across 50 RoboTwin 2.0 tasks and 97.40% across the four LIBERO suites; on four memory-dependent RMBench tasks, the same task-adapted execution reaches 12.5% average success. Because the interface is fixed, low-level VLA policies can be swapped or adapted without changing the overall agent loop. ⁴

Open Source & Repos

LiteLLM: a lightweight gateway to 100+ model APIs

LiteLLM is an open-source AI gateway with a Rust core and a Python Software Development Kit (SDK) that lets teams call over 100 large language model (LLM) Application Programming Interfaces (APIs) in an OpenAI-compatible format. It adds cost tracking, guardrails, load balancing, and logging, with connectors spanning Amazon Bedrock, Microsoft Azure, OpenAI, Anthropic, and Google Vertex AI. ⁵

Release v1.100.0 (Sep 6, 2026) highlights Docker image signature verification: all LiteLLM Docker images are signed with Cosign, using a key introduced in commit 0112e53. For production users, reproducible, signed images make audits and deployment checks more straightforward. ⁵

Why It Matters

Parallel token generation addresses the core latency bottleneck in autoregressive text models without adding a draft model, which — if independently confirmed — could lower inference costs and make assistants and agents feel more responsive. It also points to a broader pattern: rethinking decoding, not just scaling model size, to get practical wins. ¹

In parallel, security and reliability work reminds teams where to harden systems: gradient return paths in split training can leak row identity unless explicitly defended, and embodied agents benefit from a verifiable skill layer rather than raw end-to-end predictions. On the methods side, bringing foundation-model habits to causal inference could reduce per-project glue work if in-context generalization proves robust. ³