Stable Agent Protocols and 18% Cheaper Loops

Featured

01 Prompt Optimization Can Break Agent Systems

An optimizer may improve an agent's writing while quietly changing message routing, output formats, or termination signals. One altered convention can break the entire pipeline.

This work treats multi-agent prompts as programs. Typed, verifiable objects hold the execution protocol. Natural language stays in the data flow, where the optimizer can safely modify it. Routing targets, field structures, and stopping conditions receive type and validity checks before execution.

The design achieved 100% protocol validity across synthetic reasoning, collaborative review generation, and insurance rating workflows. Task performance continued to improve. The abstract does not test runtime-added branches, live model selection, tool failures, or cross-service recovery.

Teams can separately validate task quality and protocol validity. They should also check routing, formatting, and termination signals independently. These checks follow from the paper's design but were not additional reported experiments.

Key takeaways:

• Keep routing, formatting, and termination contracts away from prompt optimizers.
• Store control flow in typed, verifiable program objects.
• Evaluate task performance and protocol validity as separate dimensions.

Source: Control-Data Flow Separation: Stable Prompt Optimization in Multi-Agent LLMs

02 Language Is Becoming Video's Control Layer

Video generators are starting to accept instructions during execution, much like game engines. H3-World combines character actions and camera movements into structured language commands.

The system aligns each command with the matching span of video latents. Temporal attention routing limits when each instruction applies, reducing interference between earlier and later actions.

H3-World reuses semantic representations from a pretrained 33B video model instead of adding a dedicated action module. Adaptation required 8,000 game samples, 10,000 LoRA steps, and only 0.199% trainable parameters.

That makes language a plausible shared control layer for interactive video. It does not establish reliable physical simulation. Object interaction, long-term consistency, and causal behavior still need broader testing.

Key takeaways:

• Test a language control layer before building a specialized action module from scratch.
• Temporal alignment turns instruction following into a continuously controllable experience.
• Evaluate character and camera control separately from physical reliability.

Source: H3-World: Turning Language Understanding into World Control

03 A Drone Can Arrive And Still Fail

Putting a general multimodal model inside a drone control loop tests more than visual understanding. Perception, decisions, repeated actions, and task completion must work together.

DroneCATS supports interchangeable models across approaching, tracking, out-of-view searching, and multi-drone command tasks. It requires neither fine-tuning nor function-calling interfaces.

Small open models sometimes entered the success zone more often than frontier models. Yet they failed by declaring arrival too early or never ending the task. In multi-drone scenarios, they also copied identical coordinates while ignoring different viewpoints.

Spatial competence alone does not make an autonomous system dependable. Teams should measure termination and protocol compliance, then use benchmarks to set autonomy limits and human takeover conditions.

Key takeaways:

• Treat termination decisions and protocol compliance as primary drone-agent metrics.
• Successful movement does not prove a small model is ready for autonomous edge deployment.
• Interchangeable-model benchmarks can define autonomy limits and human takeover points.

Source: Evaluating Multimodal LLMs as Generalist Vision-Language-Action Agents for Drone Control: Commanding, Approaching, Tracking and Searching

04 Acting Like A Student Is Not Simulation

A convincing student persona can create a dangerous illusion in educational testing. The model may accept tutoring without matching a specific student's mistakes, corrections, or ability limits.

StudentSim first trains across data from many students, then specializes on individual records. Its evaluation separates behavioral fidelity from appropriate updates after instruction.

On chess tasks, StudentSim scored 0.51 for behavioral fidelity and 0.91 for instructional responsiveness. GPT-5.4 scored 0.23 and 0.72, while Maia2 scored 0.45 and 0.27. Persona, ability calibration, and learning response are different capabilities.

A chess tutor trained with StudentSim as its reward model earned higher expert ratings for accuracy, teaching quality, and personalization. Evidence currently covers 60 students and three domains. Human studies remain necessary before simulated students can replace real participants.

Key takeaways:

• Measure ability and error calibration instead of trusting a fluent student persona.
• Separate behavioral fidelity from instructional responsiveness.
• Use simulated students to screen teaching strategies, not replace human validation.

Source: StudentSim: Training LLM-based Student Simulators

05 Do Looped Layers Win On Equal Compute?

Looped architectures reuse the same parameters across multiple processing passes. Earlier comparisons often fixed model size, leaving extra computation mixed with any architectural benefit.

SMELT matches compute per token, non-embedding parameter count, and KV-cache size. Only the middle half of the network runs twice. Sparse experts keep the overall budget controlled.

Across four model sizes reaching 54 billion parameters, SMELT reduced compute-optimal training FLOPs by 6.8%–18.0%. Gains were strongest for code, long samples, and prompts with more context examples.

During the second pass, attention shifted away from fixed positions toward content-related tokens. More models and full-paper evidence are needed before treating this as a general mechanism. For now, SMELT provides a reproducible, budget-matched recipe for testing looped layers.

Key takeaways:

• Match compute, parameter count, and KV-cache size when evaluating looped layers.
• Repeating shared middle layers saved 6.8%–18.0% of compute-optimal training FLOPs.
• Prioritize tests on code, long text, and prompts containing multiple examples.

Source: SMELT: Scaling Laws for Compute-Matched MoE Looped Transformers