Note obs. Diffusion LMs often settle on the right answer early, then waste compute refining after their beliefs have effectively converged. innov. A training-free decoding rule that watches a simple confidence-gap signal to stop iterating and commit, cutting steps by up to ~3.4× while preserving accuracy (near-full correctness at half steps on GSM8K/MMLU).

Note obs. Token-level masked diffusion LMs can't use KV caching and must learn combinatorial token dependencies, raising compute and hurting coherence vs AR decoding. innov. Slot-level plan-and-infill: diffusion picks weakly dependent fixed-length slots; an AR infiller decodes selected slots in parallel under a unified causal/KV-cache setup, reporting >18× speedup vs prior MDMs and ~2.33× vs strong ARMs while narrowing the accuracy gap.

Note obs. Standard RLHF rewards treat multi-constraint instructions as flat; partial failures are not propagated, so models learn weak adherence to ordered and conditional requirements. innov. Build LsrInstruct with explicit parallel/sequential/conditional constraint structures, and a structure-aware reward (avg aggregation, failure-penalty propagation, branch selection) that improves in- and out-of-domain instruction following and general reasoning.

Note obs. Common "sequence distillation" (SFT on teacher outputs) treats distillation as filtered imitation, underrepresenting the teacher's sequence distribution, mismatching it to student capacity, and adding exposure bias from teacher forcing vs AR inference. innov. Distribution-aligned sequence distillation with explicit teacher-student interaction; reports DASD-4B-Thinking as SOTA at its scale using ~448K samples, with model and dataset released.

Note obs. Static tool libraries are intrinsically incomplete in scientific domains, so long-tail tasks fail even when reasoning is competent. innov. A test-time loop that synthesizes, verifies, and iteratively evolves executable tools, evaluated on a benchmark that couples tasks with evolved tools.

Note obs. Personalization can entangle user-history signals with factual representations, causing answers to track prior context over objective truth. innov. An inference-time steering method that preserves personalization while suppressing factual distortion, plus a benchmark for joint factual and personalized QA.

Note obs. Discrete CoT increases length and bandwidth, but uncertainty is often localized to a small set of plausible next steps. innov. Sample K candidate tokens per step and merge their embeddings into one continuous multiplex token, enabling branch-and-merge reasoning optimized with on-policy RL.

Note obs. Code diffusion models often lag AR under matched budgets, in part due to unstable training and inefficient knowledge uptake. innov. Reuse an AR code pipeline but add block-diffusion continual pretraining with tailored warmup and noise scheduling to improve code benchmark performance.

Note obs. After reasoning distillation, it is unclear which parts of a student's reasoning are inherited from the teacher versus reverting to the base student. innov. A provenance-tracing analysis that compares teacher/base/distilled probabilities at the sentence/action level and uses the signal to guide principled data selection.

Note obs. Raw-text pretraining does not explicitly optimize linguistic competence, so grammatical generalizations emerge indirectly and slowly. innov. Transform text into structured language-learning tasks and mix them into pretraining to accelerate linguistic competence acquisition without specializing away from general tasks.

Note obs. External judges and text-based self-critique add compute and can correlate weakly with true correctness. innov. A small auxiliary predictor that reads hidden-state and attention traces from a frozen model to estimate correctness during generation with negligible overhead.

Note obs. Next-token-only training underutilizes supervision in the near future context and limits sample efficiency. innov. Multiple future-token prediction heads on a shared trunk, improving capability and enabling multi-token generation speedups at inference.

Note obs. Interpretability evidence suggests reasoning computation concentrates in a subset of layers, but standard decoding traverses the full stack once. innov. Train the model to iterate a selected mid-layer block as a recursive latent "thinking" loop, then decode back to tokens for test-time reasoning scaling.

Note obs. Bidirectional attention in diffusion LMs prevents standard KV caching, making inference dominated by repeated recomputation across denoising steps. innov. A block-wise approximate KV cache reuses activations across steps, plus a confidence-aware parallel decoding fix for dependency disruption; reports large end-to-end speedups on diffusion LM baselines under long-generation settings.

Note obs. Token-level CoT scales compute by emitting more text, which costs latency and can be bottlenecked by context length. innov. A recurrent-depth LM unrolls a shared block to arbitrary depth at test time, scaling latent compute without extra tokens; a 3.5B prototype shows reasoning gains up to a compute load comparable to ~50B params.

Note obs. Standard LLMs mostly learn to "think" after pretraining (prompting/CoT), so pretraining compute is underused for learned multi-step manipulation. innov. Looped Language Models add iterative latent computation plus an entropy-regularized depth allocator during pretraining; the Ouro 1.4B/2.6B models report performance comparable to up to ~12B baselines across many evals.

Note obs. One forward pass per token forces the model to commit early, while deeper deliberation typically requires emitting more tokens. innov. "Pondering" repeats forward passes within a token step by feeding back a probability-weighted embedding mixture; learned self-supervised during pretraining, and reports that pondering-enhanced small models can match much larger vanilla counterparts.

Note obs. Discrete CoT explores reasoning paths one token at a time, which limits branching and often inflates token budget. innov. Generate "soft" concept tokens as embedding mixtures (continuous-space reasoning) without extra training; reports pass@1 gains (up to ~2.48) while reducing token usage (up to ~22.4%) on math/coding benchmarks.

Note obs. Hard-token CoT constrains intermediate reasoning to discrete vocabulary and can be inefficient or brittle. innov. A lightweight assistant proposes soft-thought tokens that are projected into the base LLM’s representation space, improving reasoning with parameter-efficient tuning while leaving the base model unchanged.

Note obs. Continuous latent thoughts can be high-information, but a fixed latent trace limits exploration compared to multi-sample discrete CoT. innov. Perturb latent thoughts using specialized initial tokens and train for diversity (contrastive) so test-time scaling explores multiple soft-thought paths; reports stronger gains than SoftCoT baselines and compatibility with self-consistency.

Note obs. Diffusion LMs can parallelize but often lag in likelihood modeling and can be constrained to fixed-length generation setups. innov. Block diffusion models define an AR distribution over blocks and run diffusion within each block, enabling arbitrary-length generation plus KV caching and parallel sampling; reports strong diffusion-model language-modeling results.

Note obs. Diffusion decoding recomputes QKV for all tokens at each step, even though many token representations change slowly over denoising. innov. Delayed/conditioned cache reuse (dKV-Cache) with two variants: near-lossless decoding-oriented caching and a more aggressive greedy mode; reports ~2–10x inference speedups across general, math, and code benchmarks.

Note obs. Even with block diffusion, recomputing KV everywhere remains redundant because many tokens/layers exhibit limited change across steps. innov. A training-free dual adaptive caching framework selectively updates KV states for a subset of tokens per step and reuses the rest, aiming to preserve quality while substantially reducing redundant compute in diffusion decoding.

Note obs. KV states drift unevenly across layers and steps, yet diffusion decoders typically refresh everything uniformly. innov. Elastic-Cache uses an attention-aware drift test plus a depth-aware refresh schedule to recompute only where needed; reports substantial speedups on math/code tasks (including very large gains on long sequences) with negligible quality loss.

Note obs. Discrete diffusion for text can require hundreds to thousands of model evaluations, so parallelism does not automatically translate into low latency. innov. Few-Step Discrete Flow-Matching trains step-budget consistency so small step counts approximate long trajectories; reports that ~8 steps can match a 1024-step baseline perplexity for long generation, enabling very large sampling speedups.

Note obs. Fixed confidence-threshold heuristics for parallel decoding are input-agnostic and miss optimal speed/quality trade-offs. innov. Train a lightweight filter to predict whether a token is already final, enabling adaptive unmasking plus end-of-text prediction; reports up to ~22.6x speedup without performance drop (and higher with KV-cache) on the LLaDA benchmark.

Note obs. Prior parallel decoding prioritizes high-confidence tokens, but those tokens carry little information, slowing progress per round. innov. A bits-to-rounds principle links required rounds to total information and per-round budget, motivating Explore-Then-Exploit decoding that targets uncertain tokens to trigger cascades; empirically reduces rounds without quality loss.

Note obs. Many diffusion decoding strategies are reactive and do not use bidirectional context to enforce a global generation trajectory. innov. Plan-Verify-Fill builds a hierarchical skeleton via high-leverage anchors and uses quantitative verification to stop deliberation when marginal value drops; reports up to ~65% fewer function evaluations on LLaDA/Dream instruct models.

Note obs. Decoder-only LMs re-run early/middle layers for every next token even when those layers have already produced a representation sufficient to support short-range continuation. innov. Direct Multi-Token Decoding reuses late layers to emit multiple tokens per cycle, reducing full forward passes; a fine-tuned Qwen3-4B variant reports up to ~2x speedup with only minor performance loss.

Note obs. Self-evolving reasoning systems are often bottlenecked by needing large, curated task/label sets to bootstrap training signals. innov. A data-free/self-evolving setup that generates and learns from its own experiences to grow reasoning behavior; positioned as reducing dependence on curated tasks and enabling iterative capability growth without human-labeled corpora.

Note obs. Synthetic verifiable data pipelines often fail because verification artifacts are weak/trivial, so they do not reliably separate strong from weak solutions. innov. An evolutionary, task-agnostic framework that jointly synthesizes problems, candidate solutions, and executably-checkable verifiers, iteratively improving strategies via consistency-based evaluation; reports gains under verifiable-RL and distillation setups.

Note obs. Large instruction corpora can still be shallow (low complexity) or narrow (poor rare-domain coverage), so scaling sample count alone plateaus. innov. A framework combining hierarchical labeling, informative seed selection, evolutionary synthesis, and deficiency diagnosis to iteratively expand coverage and depth; produces a ~1.5M-instruction set and reports improved instruction-following on multiple models.

Note obs. When prompts contain many explicit requirements (often >10), instruction-following breaks down because evaluation and training data under-represent that regime. innov. Synthesize constraint-heavy examples from real prompts and add automatic verification (rule-based for quantitative constraints plus qualitative validation) to build RECAST-30K; fine-tuning yields improved complex instruction-following and supports reward construction.

Note obs. Scalar/pairwise reward models compress preferences too aggressively and miss multi-dimensional criteria that humans use in evaluation. innov. A large (prompt, rubric) collection plus contrastive rubric generation and noise filtering to train rubric-conditioned reward models; reports a ~6.8% gain over size-matched reward baselines with transfer to downstream policy performance.

Note obs. Traditional synthetic data generation creates generic text that doesn't match the specific distribution of downstream tasks, requiring massive filtering or domain adaptation that wastes compute and compromises quality. innov. A retrieval-augmented generation framework that crafts synthetic datasets by retrieving task-specific exemplars from a corpus and using them as seeds for targeted augmentation, producing training data that matches the exact task distribution without task-specific huma

Note obs. LLM inference on consumer GPUs is bottlenecked by memory bandwidth and capacity, requiring expensive multi-GPU setups or cloud APIs because hot-activated neurons (frequently used) and cold-activated neurons (rarely used) are treated identically in memory hierarchy. innov. A neuron-aware inference engine that predicts which neurons will activate (hot/cold classification) and keeps hot neurons in GPU memory while offloading cold neurons to CPU RAM, achieving 11× speedup on consumer GPUs with

Note obs. Running 40B+ parameter models on smartphones was considered impossible due to DRAM limitations (8GB vs 80GB+ models) and thermal constraints, requiring either tiny models or cloud connectivity that compromises privacy and latency. innov. Neuron-aware adaptive scheduling with asymmetric tensor partitioning across heterogeneous memory (NPU, LPDDR, flash/SD card) and dynamic sparse expert selection based on local correlation, enabling 3B-40B model inference on smartphones at 11 tokens/sec wit

Note obs. Small LLMs (1B-8B parameters) fail on novel reasoning tasks because they cannot update their understanding during inference; few-shot prompting only activates existing patterns rather than learning new operational rules, creating a hard ceiling on abstract reasoning like ARC visual puzzles. innov. Test-Time Training: during inference, use the few-shot examples as training data to perform actual gradient updates on a small subset of model parameters (LoRA), temporarily adapting the model to

Note obs. Fine-tuned adapters (LoRA) for different tasks/contexts interfere with each other when composed or switched dynamically, requiring separate forward passes or full model copies that multiply memory costs and prevent efficient multi-task serving. innov. Compositional adapters that can be added, subtracted, and combined arithmetically (A + B - C) while maintaining task fidelity, enabling dynamic context switching through vector arithmetic in adapter space without inference-time interference,

Note obs. RLVR training hits a wall when you run out of verifiable data, and most internet text (textbooks, articles) can't be used because there's no automatic way to check if the model's reasoning is correct. innov. A fill-in-the-middle multiple-choice formulation that converts any coherent text into verifiable RL tasks by masking critical reasoning steps and algorithmically generating plausible distractors, creating infinite training data from previously unusable corpora.

Note obs. Traditional RL requires ground-truth labels or external verifiers which are expensive or unavailable for many domains, and LLM-as-judge methods still require reference answers. innov. Using natural-language meta-questions (e.g., "Is this logically consistent?") answered by an evaluator model as the reward signal, enabling training in domains where correctness is ambiguous or expensive to verify, with performance matching label-based RL.

Note obs. Standard pretraining bakes in hallucinations and unsafe patterns that post-training can't fully fix, and pretraining data quality is fixed rather than dynamically improvable. innov. A pretraining paradigm where a post-trained model acts as real-time judge and rewriter, using RL to improve the next K tokens during pretraining itself, preventing bad patterns from becoming embedded rather than trying to fix them later.

Note obs. Removing entire documents to shape capabilities is blunt and destroys useful data, while existing unlearning methods are vulnerable to adversarial attacks. innov. Token-level filtering that masks specific tokens during backpropagation rather than removing documents, achieving precise capability shaping with 200× better efficiency than document filtering and 10× robustness to adversarial fine-tuning.

Note obs. RL post-training is computationally expensive but mostly just reshapes the base model's distribution rather than teaching new reasoning, and MCMC-based power sampling is theoretically sound but 10× too slow for practical use. innov. A training-free autoregressive approximation of power distribution sampling that uses future trajectory quality estimates to sharpen generation, matching GRPO performance with only 2.5-3.5× inference overhead instead of massive training costs.

Note obs. Traditional scaling assumes reasoning requires billions of parameters and general pretraining before specialization, leaving small models incapable of complex tasks like tool calling or code generation. innov. "Anti-curriculum" pretraining (pure reasoning/code data from scratch), parallel Mamba-Attention hybrids, and GRPO alignment enable 90M-600M models to match 7B baselines, proving extreme specialization and depth beat brute-force scaling.

Note obs. Training a 7B model requires 84GB VRAM (14B params + 14B grads + 56B optimizer states), making it impossible on single consumer GPUs despite models only being 14GB in memory. innov. Cut Cross-Entropy reduces vocabulary logits memory by 37× via online softmax, fused kernels eliminate intermediate allocations, and LoRA+ uses 16× different learning rates between A/B matrices, enabling full fine-tuning with 3.5× less memory and time than current SOTA (Unsloth).

Note obs. Small models fail at self-correction because they lack capacity to simultaneously critique outputs and maintain task understanding; existing methods assume frontier model capacity. innov. Separates task abstraction (what must be solved) from solution generation, using structured templates as intermediate representations; small models can use templates distilled by larger models to achieve reliable self-correction without external verifiers.

Note obs. RL from scalar rewards is unreasonably uninformative (single bit per rollout), while distillation requires expensive full demonstrations; text feedback is abundant in human-AI interaction but unused. innov. Better RLTF where models learn to internalize textual critiques during training to improve single-turn test performance, using either self-distillation (matching feedback-conditioned generations) or feedback modeling (auxiliary prediction), achieving dense susupervision w/o demo costs.

Note obs. Efficient inference can require post-hoc distillation/pruning of a full model; activation sharing in inference is hard with pretrained models w/o performance loss. innov. Progressive activation sharing in training expands these regions from deep to shallow layers; allows the model to adapt to shared reps; results in a family of efficient models (varying sharing percentages) from one training run, with continual pretraining transforming pretrained models into efficient variants w/o distil.

Note obs. Training large models requires expensive multi-GPU setups because systems persistently host model replicas and full computation graphs in limited GPU memory, despite terabytes of cheaper host RAM sitting idle. innov. A CPU-master/GPU-template execution model that streams layers from host RAM to GPU on-demand with double-buffered pipelining, eliminating persistent GPU-resident params and enabling 120B model training on single GPU while achieving 12× better throughput than SoTA offloading.

Note obs. Training search-integrated agents with RL fails because sparse trajectory rewards can't distinguish high-quality reasoning from lucky guesses, causing error propagation from early retrieval mistakes that cascade through the chain. innov. Actor-Refiner framework wherein Actor gives trajectories with tool calls and a Meta-Refiner performs "cut-and-regenerate" repairs on specific failed steps using a hybrid reward (outcome + information density of evidence), optimized to achieve 16% gains.

Note obs. Parallel reasoning (multiple CoT branches at once) wastes compute because branches evolve independently without coordination, leading to redundant trajectories and inability to know when consensus is reached. innov. A 2D probing interface that extracts intermediate answers from all parallel branches (creating a branch×depth matrix), enabling global divergence pruning and stability stopping—cutting redundant computation by 60%+ while maintaining accuracy through training-free onl. control.