TLDR: A new framework called CODA (Conductor-driven Architecture) improves the reasoning capabilities of smaller LLMs by intelligently orchestrating their inference process. It uses adaptive planning, iterative self-refinement, self-reflection, and verification to enable medium-sized open-source models to outperform much larger models on complex tasks like math and coding, demonstrating a path towards co-designing AI models and their reasoning frameworks for greater efficiency and performance.
Large Language Models (LLMs) are becoming incredibly adept at solving complex problems in areas like mathematics, software development, and strategic games. This progress is often driven by two main approaches: training models to have “internal” reasoning capabilities (the “Engine”) and using external frameworks that break down tasks into manageable steps (the “Conductor”). While combining these two approaches holds great promise, it also brings challenges like inefficiency and scalability issues.
One major challenge is “effort duplication,” where both the external framework and the internal model try to perform high-level reasoning, leading to wasted computational resources. Another common problem is “weak instruction following,” where powerful reasoning models struggle to perfectly adhere to complex instructions, causing the process to deviate and consume excess resources. These issues make it difficult to deploy robust and capable reasoning systems widely.
To address these obstacles, researchers have introduced the Conductor-driven Architecture (CODA), an adaptive framework designed to actively orchestrate the reasoning Engine. This innovative approach significantly boosts model capabilities, allowing medium-sized models to achieve state-of-the-art results that surpass models many times their size across demanding tasks in scientific reasoning, math, and code generation. This development offers a clear and efficient pathway toward the next generation of powerful AI systems that deliver top-tier performance while operating within practical memory budgets.
How CODA Works
CODA operates through several key components working in harmony. It begins with an adaptive planner that evaluates a given problem and can devise multiple distinct execution paths to find a solution. These plans are then passed to an executor, which attempts to solve the problem. A critical feature of the executor is iterative self-refinement. Here, the system can analyze feedback from its own solution attempts—such as the output from a code execution—and adjust its approach, even reformulating the problem if necessary.
The executor phase generates several possible solutions, which are then moved to a self-reflection phase. This stage synthesizes insights from multiple attempts and encourages “cross-pollination” of ideas by identifying and resolving inconsistencies across different executions. The final step in this orchestration is verification, which can employ various methods like majority vote or using an LLM as a judge, depending on the problem context.
This dynamic approach allows CODA to allocate more computational resources to more difficult problems by invoking multiple stages of problem reformulation and self-refinement, while simpler queries can pass through without engaging all pipeline stages. This “right-tool-for-the-job” strategy enables the framework to utilize a variety of external tools as needed, including Python interpreters and code compilation and verification tools.
Impressive Performance Gains
The effectiveness of CODA is evident in its ability to propel strong open-source models to the top of performance leaderboards, often outperforming much larger commercial models. For instance, applying CODA to the Qwen3 family of models allowed Qwen3 32B to surpass larger models like DeepSeek R1 and Qwen3 235B, and even leading closed-source reasoning systems such as OpenAI O3-mini. The framework also boosted recently released GPT-OSS models to top tiers on various benchmarks, demonstrating the broad applicability of this approach.
Understanding CODA’s Components
A systematic evaluation of CODA’s core components—planning, self-reflection, and cross-solution verification—reveals their individual importance in achieving high performance across diverse reasoning tasks. The analysis highlights the critical interaction between CODA’s strategy and the nature of the task, emphasizing the Conductor’s role in maximizing the reasoning Engine’s capabilities.
The utility of the planning component varies by task; it offers significant benefits for scientific reasoning benchmarks but has a more limited direct impact on coding performance. This suggests that models specifically trained to utilize an explicit planning phase could better leverage this component in the future.
Self-reflection consistently provides a strong accuracy advantage across all evaluated models and tasks. This benefit likely comes from the model’s inherent ability to critique and refine its own work, as well as the framework’s process of combining insights from multiple execution attempts to produce a superior final output.
The verification step presents a significant opportunity for future enhancements. There is a noticeable gap between CODA’s final performance and the theoretical maximum achievable, indicating that a more accurate verifier could unlock substantial gains. This points to a promising direction for co-design: explicitly training the reasoning Engine to act as a verifier, perhaps through reinforcement learning, to more effectively guide test-time computation.
Dynamic Problem Reformulation
CODA employs dynamic problem reformulation, adapting its strategy based on the problem’s complexity and the specific strengths of the Engine model. This ensures the system selects the most efficient and reliable path to a solution.
One aspect of this is adaptive path selection. Models often have implicit preferences for solving problems in particular ways; for example, some mathematical problems are better suited for direct textual reasoning (“mental math”), while others are more reliably solved through code generation and execution. CODA captures this insight by exploring multiple solution paths and prioritizing the one most likely to succeed for that specific model. This adaptive approach has shown solid gains, boosting the performance of Qwen3 models on AIME math benchmarks.
Another crucial element is iterative refinement with rich feedback. In complex tasks like code generation, a model’s initial attempt might not be perfect. When CODA executes generated code, it captures feedback such as interpreter error messages or incorrect output. The problem is then reformulated and presented back to the model, including the original prompt, this rich feedback, and an instruction to correct previous mistakes. This iterative loop, where the task is progressively clarified based on execution results, leads to significant improvements in code generation accuracy.
Also Read:
- New Framework Assesses Language Models’ Ability to Integrate Knowledge
- Efficient AI Reasoning: A Study on Length Control and Quantization for Safety and Skill
The Future of Co-Designed AI
This research demonstrates that intelligent orchestration offers a parameter-efficient route to elite performance. By propelling medium-sized open-source models like Qwen3 32B and GPT-OSS to the top of competitive leaderboards, outperforming models many times their size, these findings highlight a future where LLMs and their reasoning frameworks are co-designed. Instead of relying on rigid, fixed templates, orchestration should be dynamically guided by model capabilities and problem complexity. The next frontier involves moving beyond monolithic reasoning engines to create models equipped with a toolkit of capabilities—such as planning, task decomposition, verification, and reflection—transforming the conductor from a mere prompter into a true director of computational thought. You can read the full paper here: The Conductor and the Engine: A Path Towards Co-Designed Reasoning.
