Advancing efficient reasoning across architectures, learning, and agent systems.
Making large reasoning models faster, cheaper, and more efficient.
Reasoning systems increasingly support mathematical problem solving, coding, scientific discovery, and multimodal and embodied decision-making. Their practical value depends on reasoning quality alongside the resources required to learn, execute, and verify solutions. Larger models, longer reasoning traces, and more search or test-time computation can improve capabilities while increasing latency, memory, energy, and deployment costs.
Looped Transformers and recurrent-depth models repeatedly apply shared computational blocks to refine hidden representations, allowing effective depth to vary without separate parameters for every iteration. Recent looped language models, including Ouro, explore latent reasoning and learned depth allocation. Parameter sharing, iterative refinement, and adaptive stopping are promising directions, but fewer parameters or generated tokens do not by themselves establish lower total computation or wall-clock latency.
These architectures complement efficient pretraining and post-training, reasoning-trace compression, reinforcement learning, model routing, adaptive budgets, search, and selective verification. Realizing their benefits requires systems support for dynamic computation, including scheduling, batching, memory reuse, and KV-cache management.
For agents, resource allocation extends to planning, retrieval, memory, tool use, and interaction with other agents and environments. Evaluation must cover complete execution trajectories, including failed attempts, verification, and recovery. Model-internal recurrence and system-level self-improvement are distinct mechanisms; the latter must also account for the costs of generating feedback, evaluating changes, and learning from experience.
The workshop asks how to design, train, and deploy reasoning systems that use computation effectively across internal model iterations and complete agent workflows. We will connect theory, architectures, learning algorithms, systems, agents, and applications, linking expressivity, depth generalization, and learning stability with hardware performance, task success, interpretability, and safety.
How can efficient reasoning make recursive self-improvement practical?
What evidence demonstrates improvement of a system's own models, tools, or learning procedures? How should feedback, evaluation, repeated optimization, and productive research decisions be costed, and how does this process differ from recurrent hidden-state updates within a model?
Which dimensions of reasoning efficiency matter most?
Consider tokens per problem; latency; compute or monetary cost per correct answer, including failures; memory and KV cache; adaptive allocation across tokens, iterations, search, and verification; training and data efficiency; faithful and monitorable reasoning; and parameter sharing relative to recurrent computation. Which trade-offs matter in each deployment setting?
Can models learn when to think, and how should we measure it?
Should benchmarks measure accuracy per dollar or a full quality–resource Pareto curve? Which training data, process feedback, and rewards teach difficulty awareness, avoid premature stopping and unnecessary computation, and help looped models decide whether another iteration is worthwhile?
How should efficiency be balanced with transparency?
As reasoning is compressed or moves into latent space, how can faithfulness, readability, and monitorability be maintained? What information must survive in traces, model states, and agent memory, and how can errors or unsafe behavior be detected when internal reasoning is less accessible?
What does efficient reasoning look like under tight budgets?
Under strict memory, latency, and power limits, when should a system constrain thinking, distill a smaller model, route hard cases to the cloud, or adapt recurrent depth? How can quality and reliability be preserved while accounting for actual hardware runtime and communication overhead?
What representations and architectures support efficient reasoning?
When should systems use natural-language traces, recurrent or latent computation, search, or executable tools? How do these choices affect supervision, verification, and generalization? When does shared recurrent depth provide useful refinement, and when does it amplify errors or become unstable?
How can agents minimize the total cost of successful task completion?
How should reasoning, planning, memory, retrieval, and tool use be coordinated over long horizons? Evaluation should include complete trajectories, verification, communication, failures, and retries, revealing when savings in individual calls are offset by repeated gathering, ineffective actions, or recovery.