We begin this tutorial by building a meta-reasoning agent that decides how to think before it thinks. Instead of applying the same reasoning process for every query, we design a system that evaluates complexity, chooses between fast heuristics, deep chain-of-thought reasoning, or tool-based computation, and then adapts its behaviour in real time. By examining each component, we understand how an intelligent agent can regulate its cognitive effort, balance speed and accuracy, and follow a strategy that aligns with the problem’s nature. By doing this, we experience the shift from reactive answering to strategic reasoning. Check out the FULL CODE NOTEBOOK.
import re
import time
import random
from typing import Dict, List, Tuple, Literal
from dataclasses import dataclass, field
@dataclass
class QueryAnalysis:
query: str
complexity: Literal["simple", "medium", "complex"]
strategy: Literal["fast", "cot", "tool"]
confidence: float
reasoning: str
execution_time: float = 0.0
success: bool = True
class MetaReasoningController:
def __init__(self):
self.query_history: List[QueryAnalysis] = []
self.patterns = {
'math': r'(\d+\s*[\+\-\*\/]\s*\d+)|calculate|compute|sum|product',
'search': r'current|latest|news|today|who is|what is.*now',
'creative': r'write|poem|story|joke|imagine',
'logical': r'if.*then|because|therefore|prove|explain why',
'simple_fact': r'^(what|who|when|where) (is|are|was|were)',
}
def analyze_query(self, query: str) -> QueryAnalysis:
query_lower = query.lower()
has_math = bool(re.search(self.patterns['math'], query_lower))
needs_search = bool(re.search(self.patterns['search'], query_lower))
is_creative = bool(re.search(self.patterns['creative'], query_lower))
is_logical = bool(re.search(self.patterns['logical'], query_lower))
is_simple = bool(re.search(self.patterns['simple_fact'], query_lower))
word_count = len(query.split())
has_multiple_parts="?" in query[:-1] or ';' in query
if has_math:
complexity = "medium"
strategy = "tool"
reasoning = "Math detected - using calculator tool for accuracy"
confidence = 0.9
elif needs_search:
complexity = "medium"
strategy = "tool"
reasoning = "Current/dynamic info - needs search tool"
confidence = 0.85
elif is_simple and word_count < 10:
complexity = "simple"
strategy = "fast"
reasoning = "Simple factual query - fast retrieval sufficient"
confidence = 0.95
elif is_logical or has_multiple_parts or word_count > 30:
complexity = "complex"
strategy = "cot"
reasoning = "Complex reasoning required - using chain-of-thought"
confidence = 0.8
elif is_creative:
complexity = "medium"
strategy = "cot"
reasoning = "Creative task - chain-of-thought for idea generation"
confidence = 0.75
else:
complexity = "medium"
strategy = "cot"
reasoning = "Unclear complexity - defaulting to chain-of-thought"
confidence = 0.6
return QueryAnalysis(query, complexity, strategy, confidence, reasoning)We set up the core structures that allow our agent to analyze incoming queries. We define how we classify complexity, detect patterns, and decide the reasoning strategy. As we build this foundation, we create the brain that determines how we think before we answer. Check out the FULL CODE NOTEBOOK.
class FastHeuristicEngine:
def __init__(self):
self.knowledge_base = {
'capital of france': 'Paris',
'capital of spain': 'Madrid',
'speed of light': '299,792,458 meters per second',
'boiling point of water': '100°C or 212°F at sea level',
}
def answer(self, query: str) -> str:
q = query.lower()
for k, v in self.knowledge_base.items():
if k in q:
return f"Answer: {v}"
if 'hello' in q or 'hi' in q:
return "Hello! How can I help you?"
return "Fast heuristic: No direct match found."
class ChainOfThoughtEngine:
def answer(self, query: str) -> str:
s = []
s.append("Step 1: Understanding the question")
s.append(f" → The query asks about: {query[:50]}...")
s.append("\nStep 2: Breaking down the problem")
if 'why' in query.lower():
s.append(" → This is a causal question requiring explanation")
s.append(" → Need to identify causes and effects")
elif 'how' in query.lower():
s.append(" → This is a procedural question")
s.append(" → Need to outline steps or mechanisms")
else:
s.append(" → Analyzing key concepts and relationships")
s.append("\nStep 3: Synthesizing answer")
s.append(" → Combining insights from reasoning steps")
s.append("\nStep 4: Final answer")
s.append(" → [Detailed response based on reasoning chain]")
return "\n".join(s)
class ToolExecutor:
def calculate(self, expression: str) -> float:
m = re.search(r'(\d+\.?\d*)\s*([\+\-\*\/])\s*(\d+\.?\d*)', expression)
if m:
a, op, b = m.groups()
a, b = float(a), float(b)
ops = {
'+': lambda x, y: x + y,
'-': lambda x, y: x - y,
'*': lambda x, y: x * y,
'/': lambda x, y: x / y if y != 0 else float('inf'),
}
return ops[op](a, b)
return None
def search(self, query: str) -> str:
return f"[Simulated search results for: {query}]"
def execute(self, query: str, tool_type: str) -> str:
if tool_type == "calculator":
r = self.calculate(query)
if r is not None:
return f"Calculator result: {r}"
return "Could not parse mathematical expression"
elif tool_type == "search":
return self.search(query)
return "Tool execution completed"We develop the engines that actually perform the thinking. We design a fast heuristic module for simple lookups, a chain-of-thought engine for deeper reasoning, and tool functions for computation or search. As we implement these components, we prepare the agent to switch flexibly between different modes of intelligence. Check out the FULL CODE NOTEBOOK.
class MetaReasoningAgent:
def __init__(self):
self.controller = MetaReasoningController()
self.fast_engine = FastHeuristicEngine()
self.cot_engine = ChainOfThoughtEngine()
self.tool_executor = ToolExecutor()
self.stats = {
'fast': {'count': 0, 'total_time': 0},
'cot': {'count': 0, 'total_time': 0},
'tool': {'count': 0, 'total_time': 0},
}
def process_query(self, query: str, verbose: bool = True) -> str:
if verbose:
print("\n" + "="*60)
print(f"QUERY: {query}")
print("="*60)
t0 = time.time()
analysis = self.controller.analyze_query(query)
if verbose:
print(f"\n META-REASONING:")
print(f" Complexity: {analysis.complexity}")
print(f" Strategy: {analysis.strategy.upper()}")
print(f" Confidence: {analysis.confidence:.2%}")
print(f" Reasoning: {analysis.reasoning}")
print(f"\n
EXECUTING {analysis.strategy.upper()} STRATEGY...\n")
if analysis.strategy == "fast":
resp = self.fast_engine.answer(query)
elif analysis.strategy == "cot":
resp = self.cot_engine.answer(query)
elif analysis.strategy == "tool":
if re.search(self.controller.patterns['math'], query.lower()):
resp = self.tool_executor.execute(query, "calculator")
else:
resp = self.tool_executor.execute(query, "search")
dt = time.time() - t0
analysis.execution_time = dt
self.stats[analysis.strategy]['count'] += 1
self.stats[analysis.strategy]['total_time'] += dt
self.controller.query_history.append(analysis)
if verbose:
print(resp)
print(f"\n
Execution time: {dt:.4f}s")
return resp
def show_stats(self):
print("\n" + "="*60)
print("AGENT PERFORMANCE STATISTICS")
print("="*60)
for s, d in self.stats.items():
if d['count'] > 0:
avg = d['total_time'] / d['count']
print(f"\n{s.upper()} Strategy:")
print(f" Queries processed: {d['count']}")
print(f" Average time: {avg:.4f}s")
print("\n" + "="*60)We bring all components together into a unified agent. We orchestrate the flow from meta-reasoning to execution, track performance, and observe how each strategy behaves. As we run this system, we see our agent deciding, reasoning, and adapting in real time. Check out the FULL CODE NOTEBOOK.
def run_tutorial():
print("""
META-REASONING AGENT TUTORIAL
"When Should I Think Hard vs Answer Fast?"
This agent demonstrates:
1. Fast vs deep vs tool-based reasoning
2. Choosing cognitive strategy
3. Adaptive intelligence
""")
agent = MetaReasoningAgent()
test_queries = [
"What is the capital of France?",
"Calculate 156 * 23",
"Why do birds migrate south for winter?",
"What is the latest news today?",
"Hello!",
"If all humans need oxygen and John is human, what can we conclude?",
]
for q in test_queries:
agent.process_query(q, verbose=True)
time.sleep(0.5)
agent.show_stats()
print("\nTutorial complete!")
print("• Meta-reasoning chooses how to think")
print("• Different queries need different strategies")
print("• Smart agents adapt reasoning dynamically\n")We built a demo runner to showcase the agent’s capabilities. We feed it diverse queries and watch how it selects its strategy and generates responses. As we interact with it, we experience the benefits of adaptive reasoning firsthand. Check out the FULL CODE NOTEBOOK.
if __name__ == "__main__":
run_tutorial()We initialize the entire tutorial with a simple main block. We run the demonstration and observe the full meta-reasoning pipeline in action. As we execute this, we complete the journey from design to a fully functioning adaptive agent.
In conclusion, we see how building a meta-reasoning agent allows us to move beyond fixed-pattern responses and toward adaptive intelligence. We observe how the agent analyzes each query, selects the most appropriate reasoning mode, and executes it efficiently while tracking its own performance. By designing and experimenting with these components, we gain practical insight into how advanced agents can self-regulate their thinking, optimize effort, and deliver better outcomes.
Check out the FULL CODE NOTEBOOK. Feel free to check out our GitHub Page for Tutorials, Codes and Notebooks. Also, feel free to follow us on Twitter and don’t forget to join our 100k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.
The post How to Build an Adaptive Meta-Reasoning Agent That Dynamically Chooses Between Fast, Deep, and Tool-Based Thinking Strategies appeared first on MarkTechPost.
Credit: Source link
