SMaRT (Select, Mix, and ReinvenT): A Framework for Fusing Prompting Strategies

STEP 1 (Stage I — Initial Solutions): Run the task with N different strategies → N solutions from the LLM

Strategy 1 (Direct): Solution_1
Strategy 2 (CoT): Solution_2  
Strategy 3 (Step-Back): Solution_3
...

STEP 2 (Stage II — Fusion): All solutions + the task → Fusion prompt → Final solution

Input: [Task] + [Solution_1, Solution_2, Solution_3, ...]
Output: Synthesized solution (could be: picking one, mixing several, or something new)

The steps need separate requests. Stage I can run in parallel. Stage II is one request after Stage I finishes.

⚠️ The method works best on multi-faceted tasksthat need deep analysis and several constraints handled at once. It's not for simple factual questions ("capital of France") — a Direct prompt is enough there.

Task: You're opening a coffee shop in a residential neighborhood of Chicago. Budget: $150k. You need to decide: lease or buy the space, what menu, how much staff, how to win your first customers. Factor in: a neighborhood of young families, a school and a daycare nearby, and a competing Starbucks 1,500 feet away.

Prompt (Stage I — 3 strategies):

Request 1:

Task: [description above]

Solve the task directly; give concrete recommendations for each point.

Request 2:

Task: [description above]

Use Chain-of-Thought: work through the task step by step. First analyze the audience, then finances, then operations, then marketing. Explain your reasoning at each step.

Request 3:

Task: [description above]

Take a step back (Step-Back): what are the core principles of a successful neighborhood coffee shop in a residential area? State 3-5 principles, then apply them to this task.

Prompt (Stage II — Fusion):

I have a coffee shop launch task and three different solutions from you.

TASK: [description]

SOLUTION 1 (Direct): [paste answer]
SOLUTION 2 (CoT): [paste answer]  
SOLUTION 3 (Step-Back): [paste answer]

Analyze each solution:
- Which parts of each solution are best justified and correct?
- Where are the errors, contradictions, or missing information?
- Which solutions complement each other?

Create a final solution that:
1. Uses the strengths of each approach
2. Fixes the errors you found
3. Adds new elements if no solution covers a critical aspect

Response format:
1. **Review Solutions:** a brief analysis of each solution (2-3 sentences per solution)
2. **Final Strategy:** the final coffee shop launch strategy with a rationale for each decision

Result:

The model will show an analysis of the three solutions: it'll point out that Direct gave concrete budget numbers but ignored the audience, CoT worked through finances and staffing step by step but overestimated renovation costs, and Step-Back surfaced the principles "family-friendly atmosphere" and "easy access for parents with strollers" but gave no operational details.

The final solution will mix components: the budget math from Direct, the hiring logic from CoT, plus a kids' corner and easy entrance from Step-Back. It may also create a new element, for example: "None of the solutions mentioned partnering with the school for teachers' morning orders — I'll add a 'Teacher's Breakfast' deal with 20% off before 9:00."

An LLM can't keep every aspect of a complex task in focus at once. When you give it one strategy, the model focuses on what that strategy demands. Direct → specifics and actions. CoT → step-by-step decomposition. Step-Back → abstract principles. Each strategy creates its own frame for seeing the task, and the model optimizes the solution inside that frame while losing the other dimensions.

LLMs are excellent at analyzing and synthesizing text. That's their strength — they can read several candidate solutions, spot patterns and contradictions, and pull out what works in each approach. When you give the model all the solutions at once, it sees the full picture: "Ah, Direct missed X here, but CoT thought about it. But CoT got Y wrong, which Direct calculated correctly."

The fusion prompt turns a limitation into an advantage. Instead of picking "the one right" strategy (which doesn't exist for complex tasks), the method makes the model use each strategy as an exploration tool. Then the model works as an editor-synthesizer: it takes the best from each draft and assembles the final version. The key trick is giving the model the role of critic and integrator, not just generator.

Prompt control levers:

• Number of strategies (2-5) → more strategies = more calls but wider coverage; fewer = cheaper but may miss important aspects
• Types of strategies → match them to the task: for math (CoT + PAL + P2C), for planning (Direct + CoT + Step-Back), for creative work (different roles)
• Fusion instructions → you can dial up critique ("find the ERRORS in each") or creativity ("create something new if all solutions are weak")
• Output format → specify "analysis first, then solution" or "final solution only, no explanation" depending on how much transparency you need

Stage I (run N times with different strategies):

Task: {task_description}

{strategy_instruction}

Where {strategy_instruction} can be:

• "Solve the task directly, give a concrete answer"
• "Use Chain-of-Thought: break it into steps, explain each one"
• "Take a step back: what principles does this type of task require? Apply them"
• "Write a solution plan, then carry it out"
• (or any other strategy that suits your task)

Stage II (one request with the Stage I results):

I have a task and several solutions from you using different approaches.

TASK: {task_description}

SOLUTION 1 ({strategy_name_1}): 
{solution_text_1}

SOLUTION 2 ({strategy_name_2}):
{solution_text_2}

SOLUTION 3 ({strategy_name_3}):
{solution_text_3}

Analyze each solution:
- Which parts of each solution are best justified?
- Where are the errors or gaps?
- Which solutions complement each other?

Create a final solution that:
1. Picks the best components from each solution
2. Fixes the errors you found
3. Adds new elements if the existing solutions don't cover important aspects

Response structure:
**Review Solutions:** [analysis of each solution — what's good, what's bad]
**Final Solution:** [the final solution with a rationale for the chosen components]

What to fill in:

• {task_description} — the full task description with all constraints and context
• {strategy_name_N} — the strategy's name for clarity (Direct, CoT, Step-Back, etc.)
• {solution_text_N} — the LLM's full Stage I answer for the corresponding strategy

🚀 Quick start — paste into a chat:

Here is a SMaRT (Select, Mix, and ReinvenT) template. Adapt it to my task: [describe your task]. 
Ask me questions to figure out which strategies to use in Stage I and how to word the fusion instructions in Stage II.

[paste the template above]

The LLM will ask which strategies suit your task and help you word the fusion prompt — because SMaRT only works well with complementary strategies that look at the problem from different angles. It will take the two-stage structure from the template and adapt it to your specific task.

⚠️ Cost: It takes N+1 LLM calls (N for the base strategies + 1 for fusion). That's pricier than a single prompt but more efficient than Reflexion (which makes 15+ attempts) or rerunning one strategy many times.

⚠️ Overcomplicating simple tasks: On simple questions ("what's 2+2", "capital of Germany") the added complexity isn't worth it. Use SMaRT for multi-faceted tasks with several constraints or evaluation criteria.

⚠️ No feedback loop: Unlike Reflexion, SMaRT has no mechanism for checking whether a solution is correct and iterating again. If the final solution contains an error, the method won't catch it. It works well when at least one of the base strategies produces the right component.

⚠️ Depends on the choice of strategies: The quality of the final solution depends heavily on how well the base strategies complement each other. Three similar strategies (e.g. different flavors of CoT) won't help. You need a diversity of approaches: concrete + abstract, step-by-step + holistic, and so on.

The team tested SMaRT on four types of tasks, gradually making the scenarios harder. They started with mathematical reasoning (GSM8K — 1319 grade-school-level problems) using three strategies: CoT for step-by-step logic, PAL for generating Python code that does the calculations, and P2C for planning the solution before coding. SMaRT with GPT-4 hit 95.5% accuracy, beating the best base strategy, PAL (94.7%), and LLM-as-a-Judge (88.9%).

Then they stepped up to sequential decision-making in ALFWorld (a virtual apartment with six task types: find, heat, cool, and clean objects). Here SMaRT first showed it could fix errors in the base plans — under one strategy the agent searched for a book in the wrong room; under another it found it correctly but botched the action. Fusion combined the correct search path from the first strategy with the correct execution from the second. Result: 96.27% success versus 88.81% for CoT and even 84.33% for Reflexion (which makes up to 15 attempts versus 3-4 for SMaRT).

The most interesting part was real-world planning — TravelPlanner (1000 episodes of multi-day trips with 13 constraints: budget, dates, cities, restaurants, attractions, lodging). This is where it became clear why SMaRT works: each base strategy handled 2-3 of the 13 constraints well but failed the rest. Direct was great at the budget (macro pass rate 70.92%) but poor at choosing the route. CoT was the opposite — a logical route (macro 78.95%) but over budget. Step-Back saw the big picture of the cities but forgot details like breakfasts. SMaRT assembled the final plan from parts of different strategies: the budget from Direct, the route from CoT, the overall logic from Step-Back. It added what was missing (breakfast on day three, which wasn't in any base plan). Final score: 37.1% of plans passed all 13 constraints versus 34.3% for the best base strategy.

Why did the results come out this way? The researchers found a pattern: in 46.54% of cases SMaRT's final plan included components shared by all three base strategies (meaning a consensus). Another 41% came from one or two strategies (selective integration). And 12.5% of components were entirely new — SMaRT came up with things all the base strategies had missed. That confirmed the hypothesis: the LLM doesn't just choose, it recombines and fills in.

They also tested a hybrid setup: the small Gemma-2-9B generates the base plans and the big Gemini-1.5 does the fusion. LLM-as-a-Judge with Gemini got 10.56% on final plans. SMaRT with the same Gemini doing fusion but using Gemma's plans got 22.78% — almost twice as good. The takeaway: you can save money on the base strategiesby using cheap models and keeping the expensive one for the fusion stage only.

System:
You are a helpful assistant that can identify the correct answer to the math problem. There are
three solutions to the same math problem. I have not yet verified that these solutions are correct.
(A) solution uses natural language to answer the question, while the other (B), (C) uses Python
program to answer it. (B) directly attempts to answer the problem with coding the solution,
while (C) will plan first and then write a code to answer it. You can carefully cross and mix
various processes of solving the math problem from each solution to make an optimal solution
to the problem, referring to the process you think is correct, and, if the provided solution is
wrong, modify and improve that part. Before creating your own new solution steps, carefully
review each of the steps in (A), (B), and (C), noting which parts are correct and, if any of the
steps are incorrect, why they are incorrect, and then create your own new solution steps. Your
answer must contains problem solving process and the final answer of problem in python code.

# Efficiency Constraints
- Time Complexity: The solution should efficiently solve the problem within the smallest
possible time complexity, ideally minimizing loops or recursive calls. The expected complexity
is either constant O(1), linear O(n), or logarithmic O(logn), depending on the nature of the
problem. - Space Complexity: The solution should use minimal memory, optimizing for O(1)
space complexity where feasible. Data structures and variables should not consume excessive
space, especially in large input cases.

# Clarity and Correctness Constraints
- Correctness: The solution must accurately and consistently provide the correct answer for all
possible valid inputs. Edge cases, such as extreme values or unusual inputs, should be handled
appropriately to ensure that the solution is reliable in all scenarios. Comprehensive testing
should be conducted to verify the correctness. - Readability: The solution should be clearly
structured and easily understandable. Variable names, comments, and logical sections should
be well-defined, ensuring that other programmers can easily follow and maintain the code.

# Answer Formatting Constraints
- Review solutions: This Section should starts with 'Review Solutions: '. Each solution is a
process of organizing your thought process before creating the final solution. Please explain
in detail which of the steps in each solution are good to reference and which are incorrect
thought processes and should be revised and used. Always talk about this review process before
creating your final response.

- Answer Formatting: The final answer should begin with 'Processes: ', followed by an
explanation that may include natural language, Python code, or LaTeX syntax. Afterward,
'Final Answer: ' must present only the correct python code solution. Python code solutions
must use Markdown Python code blocks (between ```python and ```). This ensures a clear and
consistent format for responses. If you generate more then one python function after Final
Answer, entrypoint of solution function's name must be 'def solution'.

- No Natural Language Information After Final Answer: 'Final Answer:' must present only
the correct python code solution. DO NOT GENERATE ANY SENTENCES AFTER Final
Answer python code.

User:
Problem: {QUESTION}
(A)
{COT_SOLUTION}
(B)
{PAL_SOLUTION}
(C)
{P2C_SOLUTION}

Context: This is the fusion prompt for math problems from the paper. The model gets three solutions (natural language via CoT, direct coding via PAL, plan + code via P2C) and has to critically analyze each one, find errors, pick the correct parts, and synthesize a final solution as Python code. The prompt includes strict constraints on efficiency (O(1)/O(n) complexity), correctness (handling edge cases), and response structure (mandatory sections Review Solutions → Processes → Final Answer).

💡 Adaptation for evaluating ideas/decisions:

Use SMaRT not to generate a solution but to evaluate it from every angle. Stage I: ask the model to assess the idea from three positions — the optimist (what could work), the pessimist (where the risks are), the realist (concrete numbers and resources). Stage II: fusion produces a balanced assessment that weighs all three perspectives.

TASK: Evaluate my business idea: {description}

Stage I (3 requests):

1. "Evaluate this idea as an optimist. What's the best-case scenario? Where are the hidden opportunities?"

2. "Evaluate this idea as a pessimist. What are the risks? Where could it fail? What hasn't been considered?"

3. "Evaluate this idea as a realist. Concrete numbers: resources, timelines, success metrics."

Stage II (fusion):
"I have three assessments of my idea. Create a final assessment:
- Where did the optimist overestimate?
- Where is the pessimist overly critical?
- Which of the realist's numbers are best justified?

Give a final verdict: is the idea worth pursuing, and with what adjustments?"

🔧 Technique: Explicit agent roles → sharper critique

In the original, the base strategies are impersonal (Direct, CoT, Step-Back). Swap them for specific roles with distinct personalities — this pushes the model to play the roles harder and produce more varied solutions.

Stage I instead of abstract strategies:

1. "You are a seasoned CFO at a large company. Solve the task with a focus on finances and ROI."

2. "You are a startup's creative director. Solve the task with a focus on innovation and UX."

3. "You are the COO. Solve the task with a focus on feasibility and processes."

Stage II stays the same, but now fusion analyzes the positions of three departments.

This works because specific roles activate different patterns in the model's training data . The "CFO" thinks about the budget, the "creative director" about user experience, the "COO" about logistics. Abstract "Direct" and "CoT" don't give that kind of clear specialization.

💡 Combining SMaRT + Chain-of-Verification:

After the fusion stage, add one more step — verifying the final solution. Ask the model to find weak spots in its own synthesized answer and fix them.

Stage I: [base strategies]
Stage II: [fusion → Solution_Final]
Stage III (verification):

"Here is the final solution after fusion: {Solution_Final}

Review it critically:
1. Which claims might be wrong?
2. Where are the logical inconsistencies?
3. What from the task context hasn't been accounted for?

Create an improved version, Solution_Final_v2, fixing the problems you found."

This adds a third level of reflection: first different strategies (breadth), then fusion (depth), then verification (accuracy). It suits critical tasks where mistakes are costly.

SMaRT: Select, Mix, and ReinvenT — A Strategy Fusion Framework for LLM-Driven Reasoning and Planning

Key concepts from the paper:

• LLM-as-a-Judge framework (the model as a judge of finished solutions)
• Self-Consistency (aggregating multiple runs of one strategy)
• Reflexion (iterative improvement through feedback loops)
• Tree-of-Thoughts, Graph-of-Thoughts (branching reasoning)
• Inference-time scaling (improvement at inference time without retraining)

Authors: Nikhil Verma, Manasa Bharadwaj, Wonjun Jang, Harmanpreet Singh, Yixiao Wang, Homa Fashandi, Chul Lee
Organization: LG Electronics