Enhancing LLM Problem Solving via Tutor-Student Multi-Agent Interaction

1. Problem Statement

Large Language Models (LLMs) have demonstrated significant capabilities in code generation but often struggle with complex algorithmic problems, particularly at smaller model scales. Existing approaches to improve performance include:

• Sampling methods: (e.g., Self-Consistency) which are computationally expensive due to linear scaling with sample size.
• Iterative refinement: (e.g., Self-Refine) where a single model critiques its own output, often failing to detect its own errors due to a lack of perspective shift.
• Multi-Agent Systems: (e.g., Multi-Agent Debate, MARS) which often rely on symmetric interactions or parallel consensus mechanisms, leading to high token consumption and potential convergence to suboptimal solutions.

The authors identify a gap: current multi-agent systems rarely incorporate principles from human developmental science, specifically the efficacy of role-differentiated interaction (tutor vs. student) and scaffolding. They hypothesize that structuring an LLM's interaction into asymmetric roles (generator vs. evaluator) can unlock synergistic problem-solving abilities without requiring stronger models or heterogeneous ensembles.

2. Methodology: The PETITE Framework

The authors propose PETITE (Peer Tutoring Inspired Token-Efficient), a multi-agent framework instantiated in the autonomous code generation domain.

• Architecture:

  • Single Base Model: Both agents are instantiated from the same LLM (Qwen2.5-Coder-7B-Instruct) but assigned distinct system prompts and roles.
  • Student Agent (Coder): Responsible for generating and iteratively refining code solutions based on the problem description and feedback.
  • Tutor Agent (Helper): Responsible for evaluating the student's code, identifying errors (logical, syntactic, edge cases), and providing structured, actionable feedback. Crucially, the tutor does not have access to ground-truth answers.

• Interaction Loop:

  1. The Student generates an initial solution.
  2. The Tutor evaluates the solution and provides feedback.
  3. If the Tutor determines the solution is correct, the process terminates.
  4. If incorrect, the feedback is appended to the context, and the Student refines the solution for the next iteration.

• Key Innovations:

  • Asymmetric Role Separation: Mimics peer tutoring where the "evaluator" role engages analytical reasoning distinct from the "generator" role, helping the model detect errors it would miss when self-critiquing.
  • Adaptive Early Stopping: The process terminates immediately when the Tutor issues a "Decision: Correct." This avoids unnecessary token consumption on easy problems and prevents performance degradation caused by over-refining correct solutions.
  • Serial Scaffolding: Unlike parallel review systems (like MARS), PETITE uses a serial loop, reducing token overhead and avoiding consensus-driven drift.

3. Experimental Setup

• Benchmark: A subset of 100 problems from the APPS benchmark, covering three difficulty levels: Introductory (14%), Interview (62%), and Competition (24%).
• Base Model: Qwen2.5-Coder-7B-Instruct (4-bit quantized).
• Baselines: The framework was compared against:
  • Self-Consistency (5 and 10 samples).
  • Self-Refine (1 and 2 iterations).
  • Multi-Agent Debate (MAD).
  • Multi-Agent Review System (MARS).
• Metrics: Success Rate (percentage of test cases passed), Improvement (gain over initial solution), Token Consumption, and Efficiency Ratio (Success/Token).

4. Key Results

• Performance vs. Efficiency:

  • PETITE (2 iterations) achieved the highest success rate (31.62%), outperforming all baselines including MARS (30.06%) and Self-Refine (27.59%).
  • Token Efficiency: PETITE was significantly more efficient. It consumed ~5,277 tokens on average, compared to 7,320 for MARS, 15,286 for Self-Refine (2), and 23,631 for Multi-Agent Debate.
  • Efficiency Ratio: PETITE achieved an efficiency ratio of 5.99, nearly double that of MARS (4.11) and significantly higher than debate-based methods (1.23).

• Performance by Difficulty:

  • PETITE showed particular strength on Interview-level problems (30.77% success), where the iterative tutor-student feedback loop provided the most value.
  • On Introductory problems, PETITE required minimal refinement, leveraging the early-stopping mechanism to save tokens (3,078 tokens vs. 5,525 for MARS).

• Observations:

  • Increasing iterations beyond two yielded diminishing returns or increased costs without proportional accuracy gains.
  • Self-Consistency showed diminishing returns as sample count increased, while Self-Refine often degraded performance with more iterations.

5. Key Contributions

1. Developmentally Grounded Framework: Introduced PETITE, a multi-agent system that applies peer tutoring and scaffolding theories to LLM interactions, demonstrating that role differentiation enhances performance even with identical model weights.
2. Token-Efficient Asymmetry: Proved that an asymmetric, serial tutor-student interaction is more resource-efficient than symmetric debate or parallel review architectures.
3. Adaptive Termination: Developed a ground-truth-free early stopping mechanism based on the tutor's evaluation, allowing dynamic allocation of computational resources based on problem difficulty.
4. Empirical Validation: Demonstrated on the APPS benchmark that structured interaction can achieve state-of-the-art accuracy with significantly lower computational costs.

6. Significance and Conclusion

The paper argues that interaction structure is as critical as model capacity in multi-agent systems. By grounding LLM design in principles of human cognitive development (specifically the Zone of Proximal Development and peer tutoring), PETITE achieves a "synergistic effect" where the whole is greater than the sum of its parts.

The study suggests that future LLM systems should move away from engineering heuristics (like brute-force sampling or complex consensus) toward principled interaction designs that separate generative and evaluative cognitive processes. This approach offers a scalable, resource-efficient path to improving LLM problem-solving without requiring larger models or external supervision.

Limitations & Future Work:
The authors note that the system relies on the reliability of the single-model tutor (risk of premature termination if the tutor is wrong) and the lack of perspective diversity compared to heterogeneous ensembles. Future work may explore heterogeneous agent configurations (different models for tutor/student) and improved stopping criteria using confidence estimation.