Signal

The Problem

Medical imaging spans wildly different formats: flat 2D images like chest X-rays and pathology slides, and volumetric 3D scans like CTs and MRIs. Current medical AI models typically handle this diversity in one of two unsatisfying ways. The "2D-centric" approach treats everything as flat images by sampling slices from 3D volumes, which "inevitably sacrifices critical 3D structural information" [§1]. The "3D-centric" approach bolts on a separate 3D encoder but requires "extensive and complex alignment procedures" [§1].

Beyond the architecture problem, there's an evaluation problem. The standard way to judge AI-generated radiology reports — comparing generated text against a reference report using metrics like BLEU or BERTScore — is "fundamentally flawed" [§1]. Real radiologists don't write comprehensive reports in a vacuum; they interpret images guided by a patient's clinical context, focusing on specific anatomical regions. Current metrics also can't distinguish between a report that's accurate but incomplete versus one that's complete but hallucinates findings — a critical distinction in medicine [§1].

What They Did

ClinFusion tackles both problems with two main contributions: a new vision encoder architecture and a new evaluation framework.

**The vision architecture** replaces the typical single-encoder design with a compositional system. Think of it like assembling a diagnostic team rather than relying on one generalist. A foundational vision transformer (the generalist) provides a well-aligned base representation. Then an ensemble of specialist 2D encoders — each trained on different types of medical images — progressively enriches that base representation through what the authors call Cascade Spatial-Aware Locality (CaSL) Fusion [§1].

CaSL Fusion works in a cascaded, not parallel, fashion. Rather than averaging outputs from multiple encoders simultaneously (as prior work like Cambrian-1 does [§1]), each specialist encoder feeds its features into the next stage, progressively refining the representation while preserving the foundational encoder's alignment with the language model. For 3D data like CT scans, a dedicated 3D encoder is incorporated through "2D-anchored depth-aware CaSL Fusion," where the already-aligned 2D features serve as an anchor to guide the integration of 3D spatial information [§1].

**The evaluation framework** has two parts. First, MedIF-Bench tests whether medical AI models can follow complex clinical instructions — a capability that domain-specific fine-tuning often degrades, yet is "a prerequisite for any meaningful downstream evaluation and clinical deployment" [§1]. Second, a Region-of-Interest (RoI)-grounded evaluation method for report generation conditions on patient-specific clinical context (like which anatomical areas are clinically relevant) and uses an LLM judge to decompose each report into matched, missed, and hallucinated findings [§1]. This gives a factualness-driven breakdown rather than a single similarity score.

The system also includes an agentic tool-use layer that can invoke external specialist models for tasks like organ segmentation and retrieve current medical literature for citation-grounded answers [§1].

The Results

ClinFusion outperforms leading open-source medical MLLMs (including Hulu-Med and Lingshu) on 20 out of 24 benchmarks spanning visual question answering, report generation, instruction following, and text-only medical tasks [Abstract]. Against proprietary models, it demonstrates stronger multimodal capabilities than GPT-5.2 and Gemini-3-Flash on 13 out of 16 benchmarks [Abstract].

The most clinically meaningful validation comes from a blinded evaluation: six board-certified radiologists independently ranked reports from ClinFusion, Gemini-3-Flash, and Hulu-Med across 300 clinical cases covering CT and X-ray modalities. ClinFusion produced the highest-ranked reports across factual accuracy, completeness, and clinical utility [§1].

The evaluation framework itself was also validated: the RoI-grounded metric achieved "the strongest correlation with expert judgment among all eleven automatic evaluation metrics examined" [§1]. This is a notable finding on its own — it suggests that existing standard metrics for report generation are substantially misaligned with what radiologists actually care about.

Several limitations deserve attention. The benchmarks, while extensive at 24 tasks, represent controlled evaluation settings. Real clinical workflows involve mixed imaging protocols, incomplete patient histories, and edge cases that structured benchmarks don't capture. The radiologist evaluation, while blinded, covered 300 cases across only CT and X-ray modalities [§1] — pathology, fundus imaging, and MRI were not included in this expert validation. The agentic tool-use system, while showing "consistent improvements in both text-only and multimodal clinical scenarios" [§1], adds complexity and latency that the paper does not characterize for deployment contexts. And the system's performance against proprietary models was measured on 16 multimodal benchmarks, meaning it underperformed on 3 of them — the paper does not detail where it falls short.

Why It Matters

For builders working on medical AI systems, the cascaded encoder design offers a concrete architectural lesson: composing specialist encoders in sequence, anchored by a well-aligned foundation model, outperforms both monolithic encoders and parallel aggregation approaches. The code and models are publicly available on GitHub and HuggingFace [Abstract], making this directly testable.

For decision-makers evaluating medical AI capabilities — whether in hospital IT, regulatory bodies, or health-tech companies — the evaluation findings may matter more than the model itself. The demonstration that standard automated metrics poorly correlate with radiologist judgment [§1] should prompt skepticism toward any medical AI system evaluated solely on BLEU, ROUGE, or BERTScore. The RoI-grounded evaluation methodology, which decomposes reports into matched, missed, and hallucinated findings, provides a more trustworthy signal for procurement and validation decisions. If your organization is assessing AI-generated radiology reports, adopting factualness-driven decomposition metrics — rather than text-similarity scores — is actionable today.

The Problem

Answering questions about long videos is hard because the relevant evidence — a specific gesture, a brief dialogue, a momentary event — may occupy only a few seconds of a multi-minute clip. Modern vision-language models (VLMs) tackle this by invoking tools: temporal grounding modules that crop the video to relevant segments, iterative search loops that refine which frames to inspect, and chain-of-thought reasoning that walks through evidence step by step [Abstract].

The problem is that these tool-augmented pipelines treat every question the same way. A question like "What color is the car in the video?" gets the same expensive multi-step treatment as "At what point does the speaker contradict their earlier claim?" This wastes computation on easy questions and, worse, can introduce errors — grounding mistakes or irrelevant evidence that accumulates during iterative refinement [Introduction]. Most benchmarks contain a mix of difficulties, and many questions can be answered from global video semantics alone [Introduction].

What's missing is a decision layer that asks: does this question actually need the heavy pipeline?

What They Did

CADER (Confidence-Aware Dynamic Evidence Reasoning) adds exactly that decision layer, and it requires no additional training [Abstract]. The system works in two stages.

**Stage 1: Fast global pass.** The VLM (Qwen3-VL-8B-Instruct) receives frames sampled at 1 fps from the full video and produces an answer along with logits — the raw numerical scores the model assigns to each candidate answer option [§Stage 1]. CADER then computes a "logit margin": the gap between the model's top two answer probabilities after temperature-scaled softmax normalization [Eq. 2-3]. Think of it as measuring how decisive the model is — if it assigns 98% probability to one answer and 1% to the runner-up, the margin is large and the model is confident. If the margin exceeds a threshold (τ = 0.97), the answer is returned immediately with no further processing [§Stage 1]. Crucially, this confidence score comes from the same forward pass that produces the answer, so it costs nothing extra [§Stage 1].

**Stage 2: Tool-augmented refinement (only for uncertain cases).** When the margin is below threshold, CADER activates a multi-step pipeline. First, the VLM performs temporal grounding — identifying a candidate time window [t₁, t₂] likely to contain the answer [Figure 2]. The video is cropped to that window, and a lightweight VLM scorer evaluates whether the cropped segment actually contains question-relevant content [§Stage 2]. If the score is low, the system enters a reflection loop: it proposes a new time window and tries again.

The most distinctive component is Relevance-Guided Resampling (RGR). As the system accumulates relevance scores across segments, it converts those scores into a segment-wise frame-rate map — sampling more densely from high-relevance regions and sparsely from regions already verified as irrelevant [§Related Work, Tool-Augmented and Agentic VLMs]. This means the search history shapes what the model sees next through the visual input itself, not just through text prompts. The effect is a closed loop: crop, verify, adjust sampling density, repeat — progressively zeroing in on the evidence that matters [§Overview].

The Results

On Video-MME (long subset), CADER improved the Qwen3-VL-8B-Instruct backbone from 72.0% to 74.3% accuracy [Table — referenced in Abstract and experiments]. The more striking finding involves a controlled experiment: when applied to Qwen3-VL-SFT — a model fine-tuned only with tool-free chain-of-thought data, with no tool-use annotations whatsoever — CADER achieved competitive performance against specialized tool-augmented frameworks like LongVT that require explicit tool-use training [Abstract]. This suggests the inference-time routing and refinement can partially substitute for expensive tool-use supervision.

The confidence threshold determines how many samples skip Stage 2. The authors report that the logit-margin signal reliably separates easy from hard cases, with high-confidence samples exiting early [§Stage 1]. The reliability of this routing signal is examined in their adaptive routing analysis [§Stage 1].

**Limitations are real.** The framework is evaluated only on multiple-choice VideoQA benchmarks, where logit margins over discrete options are well-defined [§Stage 1]. Open-ended generation — "describe what happens" — would require a different confidence signal entirely. The backbone is a single 8B-parameter model; behavior at other scales is untested. The iterative Stage 2 loop adds latency for hard cases, and the paper does not report wall-clock timing comparisons against uniform pipelines. Finally, the threshold τ = 0.97 is empirically chosen [§Stage 1], and its sensitivity across domains and question types is not fully characterized.

Why It Matters

For builders working on video-AI systems: the core pattern here — measure confidence, then decide whether to invoke expensive tools — is immediately testable. The logit-margin signal requires no architectural changes and no retraining; it piggybacks on the model's existing forward pass [§Stage 1]. If you're running a VLM pipeline where tool calls dominate cost, even a crude version of this routing could reduce unnecessary computation.

For decision-makers evaluating video-understanding capabilities: this work demonstrates that training-free inference strategies can close part of the gap with systems that require specialized tool-use training [Abstract]. That matters for cost and maintenance — retraining agentic models every time the base VLM updates is expensive, and CADER sidesteps that entirely [Introduction]. The caveat is that this has been validated only on structured benchmarks with multiple-choice questions, not on the messy, open-ended queries typical of production video search or surveillance analysis.

The Problem

Open-source large language models have been getting better at reasoning and tool use, but they've been stuck at roughly the same size — most recent releases cluster around or just above 1 trillion parameters [§1]. Meanwhile, the strongest proprietary systems from OpenAI and Anthropic keep scaling both model size and test-time computation, widening the gap. As the paper puts it: "as increasingly sophisticated reasoning and agentic reinforcement learning methods are applied to pre-trained foundations of similar scale, open-source progress risks converging while the gap to the strongest proprietary systems widens" [§1].

The challenge is twofold. First, training a model at multi-trillion-parameter scale requires solving hard infrastructure problems — memory management, communication overhead, and numerical stability all get worse as models grow. Second, frontier performance increasingly demands not just a strong base model but also reinforcement learning over long, multi-step tasks (coding across entire repositories, browsing the web, executing multi-tool workflows) that can stretch to millions of tokens. Building both simultaneously is what Kimi K3 attempts.

What They Did

Kimi K3 is a Mixture-of-Experts (MoE) model — a design where only a fraction of the model's total parameters activate for any given input token, keeping compute costs manageable despite the model's enormous size. It has 2.8 trillion total parameters but activates 104 billion per token, routing each token to 16 of 896 specialized expert sub-networks [Abstract].

The architecture introduces three key mechanisms for scaling information flow. First, **Kimi Delta Attention (KDA)** handles long sequences efficiently by processing tokens in chunks using a recurrence-based approach rather than the quadratic-cost attention used in standard transformers. Think of it as a conveyor belt that processes tokens in batches, carrying forward a compressed summary of what came before rather than re-reading the entire history. Three KDA layers alternate with one full global attention layer (called Gated MLA) in each block, giving a 3:1 ratio [§2.1].

Second, **Attention Residuals** let each layer selectively pull information from any earlier layer's output — not just the immediately preceding one. This is like giving each floor of a building direct elevator access to every floor below it, rather than requiring information to travel one floor at a time through stairs [§2.2].

Third, **Stable LatentMoE** scales the expert count to 896 while keeping training stable through normalization techniques and a balancing mechanism called Quantile Balancing [§2.3, Abstract]. Together with refined training data, these architectural changes yield "an approximately 2.5× improvement in overall scaling efficiency over Kimi K2" [Abstract].

For post-training, the team ran reinforcement learning across coding, agentic, and general reasoning tasks at multiple reasoning-effort levels, then merged the resulting specialized capabilities into a single model through multi-teacher distillation [§1]. Training environments included software engineering, web development, professional knowledge work, and autonomous execution tasks — often spanning "hundreds or thousands of tool calls and millions of accumulated context tokens" [§1].

The Results

Kimi K3 leads or ties on several benchmarks in the reported suite [Figure 1]. On SWE-Marathon, a long-horizon coding benchmark, it scores 86.6% versus 81.2% for the next-best model (Opus 4.8). On BrowseComp, a web browsing evaluation, it scores 77.8% versus 77.6% for GPT-5.6 Sol. On Terminal-Bench 2.1, it scores 73.0% versus Fable 5's 70.0%. On AutomationBench, it leads at 30.8% versus GPT-5.6 Sol's 29.7%.

However, the paper is explicit that "its overall performance still trails the most powerful proprietary models, namely Claude Fable 5 and GPT-5.6 Sol" [Abstract]. On the GDPval-AA v2 Elo ranking (from Artificial Analysis), Fable 5 scores 1747, GPT-5.6 Sol scores 1736, and Kimi K3 scores 1686 [Figure 1]. On DeepSWE, GPT-5.6 Sol leads at 93.5% versus Kimi K3's 89.9% [Figure 1].

Several limitations deserve attention. The benchmark suite is the team's own selection; independent evaluations may tell a different story. The model's 1-million-token context window and 2.8T parameter count create substantial serving costs — the paper describes specialized infrastructure for deployment including "cache- and budget-aware fleet scheduling" [§1], suggesting this is not trivial to self-host. The paper also notes that all Fable 5 results include "potential fallbacks" and GPT-5.6 Sol results include "potential cyberguards" [Figure 1], meaning the comparison conditions aren't perfectly controlled.

Why It Matters

For builders, the release of full model weights at this scale [Abstract] means you can fine-tune, inspect, and deploy a frontier-class model without API dependency. If your workloads involve long-horizon coding or agentic tasks — areas where Kimi K3 leads several benchmarks — this is worth evaluating against your current proprietary API setup.

For decision-makers weighing build-versus-buy for AI capabilities, this release changes the calculus. The performance gap between the best open model and the best proprietary models has narrowed to the point where Kimi K3 outperforms most proprietary options and trails only the top two [Abstract]. The infrastructure requirements for serving a 2.8T-parameter model remain significant, but organizations with the compute budget now have a credible open alternative at the frontier.

The Problem

Agentic search — where a language model interleaves multi-step reasoning with web retrieval to answer complex questions — is typically trained with reinforcement learning that only checks whether the final answer is correct. This provides extremely sparse feedback: a long trajectory of search queries, reasoning steps, and evidence synthesis gets reduced to a single binary reward [§2.1].

Knowledge distillation from a stronger teacher model can provide denser, step-by-step guidance. But when the teacher is a proprietary model like GPT-5.5 or Claude, two problems arise. First, traditional distillation requires matching the teacher's and student's token-level probability distributions — impossible when the teacher's internal probabilities are hidden and the two models use different tokenizers [§1]. Second, the obvious fallback of simply having the student imitate the teacher's natural language reasoning traces transfers surface-level stylistic quirks rather than actual reasoning competence, causing "style drift" and hallucinations that degrade performance [§1, Figure 1].

What They Did

MAPD addresses this with a two-phase approach: offline protocol synthesis, then online training [§3].

**Offline: Converting teacher behavior into structured protocols.** A multi-agent system powered by a proprietary model (Claude-Opus-4.6, GPT-5.5, or Gemini-3.1-Pro) processes each training question through three stages [§3.2]. First, a Decomposer agent breaks the question into sub-queries and searches for evidence. If the initial search fails, a Repair agent reformulates queries and tries again. Finally, a Protocol Synthesizer converts the entire exploration trace into a compact JSON protocol containing five fields: the task type (e.g., single-hop vs. multi-hop), an ordered reasoning plan, extracted grounding facts, partial findings from failed searches, and an answer verification flag [§3.1, Example 1].

The key insight is that this JSON protocol strips away the proprietary model's verbose writing style and formatting quirks while preserving the cognitive strategy — think of it as extracting a recipe's steps and ingredients while discarding the chef's personal narration style.

**Online: Training with privileged information.** During training, the student model (Qwen3-1.7B or Qwen3-4B) runs two forward passes on each input. The "privileged" branch sees the question plus the JSON protocol; the "student" branch sees only the question. Because both branches use the same model weights, their token probability distributions can be directly compared — the student branch learns to match the privileged branch's distribution via KL divergence, without needing any cross-tokenizer alignment [§2.3, §3.3]. This self-distillation signal is combined with a standard GRPO reinforcement learning objective that rewards correct final answers [§3.3]. Critically, the proprietary model and multi-agent system are used only offline; they add zero cost at inference time [§1].

The Results

Across seven QA benchmarks (including HotpotQA, 2WikiMultiHopQA, Bamboogle, and others), MAPD achieves average success rates of 39.4% on Qwen3-1.7B and 44.4% on Qwen3-4B [Abstract]. On Qwen3-4B, MAPD outperforms the RL-only GRPO baseline (40.3%) and the standard OPSD self-distillation approach (41.9%) [Table 1]. The gains are particularly pronounced on multi-hop reasoning tasks: on 2WikiMultiHopQA, MAPD with Qwen3-4B reaches 55.0% compared to 47.5% for GRPO [Table 1].

The framework generalizes across proprietary teachers. Using Claude-Opus-4.6, GPT-5.5, or Gemini-3.1-Pro as the protocol source all yield improvements over baselines, without retuning the pipeline [Abstract, §1]. This cross-teacher robustness matters because it means organizations aren't locked into a single proprietary provider.

MAPD also mitigates two failure modes common in trajectory-based distillation. Compared to approaches that imitate raw natural language traces, MAPD reduces style drift — where the student adopts the teacher's verbose patterns — and verbosity degeneration, where outputs grow unnecessarily long [Abstract].

Several limitations deserve attention. The evaluation uses only two student model sizes (1.7B and 4B parameters); whether the approach scales to larger open-source models or diminishes in value as student capability increases is untested. The seven benchmarks are all question-answering tasks with exact-match evaluation [§2.1] — real-world agentic search involves messier queries and partial-credit answers. The multi-agent protocol synthesis pipeline requires running a proprietary model on every training example, which shifts cost from inference to data preparation without eliminating proprietary model dependence entirely.

Why It Matters

For builders training open-source agentic search systems: MAPD offers a concrete alternative to RL-only training. The structured protocol approach is model-agnostic on the teacher side and adds no inference overhead [§1]. The code is open-sourced, making it testable today. If you're already running GRPO on agentic search tasks, the protocol-conditioned self-distillation branch is a modular addition worth benchmarking on your own data.

For decision-makers evaluating build-vs-buy for AI search capabilities: this work demonstrates a path to transferring proprietary model reasoning into open-source models you control, reducing ongoing API costs at inference time. The trade-off is upfront data preparation cost — you still need proprietary API access to generate the training protocols. The cross-teacher generalization result [Abstract] reduces vendor lock-in risk, since you can swap proprietary providers without rebuilding the pipeline.

The Problem

Deep reinforcement learning agents can learn impressive control policies, but their neural networks are opaque. In safety-critical domains — robotics, automotive, aerospace — this opacity is a regulatory and trust problem. Standards like ISO 26262 for functional safety require that engineers can audit and verify control logic [§I]. A neural network with two 256-neuron hidden layers doesn't lend itself to that kind of inspection.

The challenge is converting a high-performing but opaque policy into something a human can read — without destroying the performance that made the policy worth using in the first place. Prior work by Bastani et al. showed this is possible in principle using decision trees, but naive approaches suffer from covariate shift: small errors compound as the student policy drifts into states the teacher never demonstrated [§II-D].

What They Did

The researchers used the classic Inverted Pendulum balancing task as their testbed [§III-A]. The setup: a cart with a pole on top, where the agent applies continuous torque between -3 and +3 to keep the pole upright. The task is "solved" when the pole stays balanced for 1,000 consecutive timesteps [§III-A].

**Step 1: Train the teacher.** They trained a Twin Delayed DDPG (TD3) agent — an actor-critic algorithm that uses two critic networks to avoid overestimating action values. The actor network has two hidden layers of 256 neurons each with ReLU activations and a Tanh output scaled to the torque range [§III-B]. Training used the CleanRL framework with a learning rate of 3×10⁻⁴ [§III-D].

**Step 2: Collect a robust dataset.** Rather than just recording the teacher's normal behavior, they injected Gaussian noise into the teacher's actions during data collection — a technique they call "Noisy Oracle Rollouts" [§III-C]. This deliberately pushes the system toward near-failure states and records how the expert recovers. The result is a dataset that captures emergency control logic that would be absent from clean demonstrations. They also emphasized data from the initial transient states of episodes to handle early instability [§III-C].

**Step 3: Engineer a physics-aware feature.** Standard decision trees split data along single feature axes, which makes it hard to learn the coupled relationship between a pole's angle and its angular velocity. To address this, they created a composite feature called "Pole Urgency" that combines the pole angle (θ) with a derivative gain applied to angular velocity: P_urgency = θ + Kd · θ̇ [§III-C]. Think of it as a single number that answers "how urgently does this pole need correction?" — combining where the pole is with where it's heading. This mimics a classical Proportional-Derivative controller and lets the tree approximate diagonal decision boundaries using axis-aligned splits [§III-C].

**Step 4: Distill into a decision tree.** They trained a scikit-learn Decision Tree Regressor with a maximum depth of 7, chosen to balance complexity against human readability [§III-E]. The entire control policy becomes a set of nested IF-THEN rules that can be visualized and inspected.

The Results

The distilled decision tree achieved performance equivalent to the expert TD3 teacher [Abstract]. On the Inverted Pendulum benchmark, this means maintaining balance for the full 1,000-timestep episode — the task's success threshold [§III-A].

But equivalent reward doesn't mean equivalent behavior. The transition from continuous to discrete control fundamentally changes the actuation dynamics. The tree's finite set of leaf nodes quantizes the continuous action space, introducing a quantization error defined as eq(s) = πT(s) − πS(s) [§II-D]. In practice, this means the tree can't output the precise torque the teacher would — it snaps to the nearest value its structure allows.

This quantization induces Bang-Bang control behavior: the system oscillates around the equilibrium point with high-frequency switching between discrete torque values, settling into a stable bimodal limit cycle [Abstract, §II-D]. The authors confirm that Bounded-Input Bounded-Output (BIBO) stability is maintained [Abstract], but they explicitly flag that this high-frequency actuation chattering would cause mechanical wear on physical hardware [§II-D].

The limitations are significant. This is a single benchmark — a 4-dimensional state space with one continuous action dimension [§III-A]. The paper does not test on higher-dimensional or multi-actuator systems. The Pole Urgency feature was hand-engineered using domain knowledge specific to pendulum dynamics [§III-C]; it's unclear how this approach generalizes to tasks where the relevant physics aren't as well understood. The paper also does not implement the full VIPER algorithm with its Q-value-weighted loss [§II-D]; the distillation uses standard behavioral cloning augmented with noisy rollouts rather than the theoretically grounded iterative approach.

Why It Matters

For builders working on RL systems that need to pass safety audits, this paper demonstrates a concrete recipe: noisy data collection plus physics-informed feature engineering can make shallow decision trees viable surrogates for deep controllers — at least on simple tasks. The Pole Urgency feature pattern is worth testing: if you have domain knowledge about which state variables are coupled, encoding that coupling as a composite feature may let you keep tree depth manageable.

For decision-makers evaluating whether RL can meet regulatory requirements in their domain, the key takeaway is that interpretability and performance aren't necessarily in conflict — but the control dynamics change. A distilled tree that matches reward scores may still behave differently enough to require separate mechanical and stability validation. Any deployment path would need to address the Bang-Bang actuation problem, particularly for systems where actuator wear or vibration matters.