Agent Architectures: ReAct, Plan-and-Execute, Reflexion, LATS

Question: What is the elevation of the birthplace of the inventor of the telephone?

Thought 1: I need to find out who invented the telephone.
Action 1: Search[inventor of the telephone]
Observation 1: Alexander Graham Bell is credited with inventing the telephone.

Thought 2: Now I need to find where Alexander Graham Bell was born.
Action 2: Search[Alexander Graham Bell birthplace]
Observation 2: Alexander Graham Bell was born in Edinburgh, Scotland.

Thought 3: Now I need to find the elevation of Edinburgh, Scotland.
Action 3: Search[elevation of Edinburgh Scotland]
Observation 3: Edinburgh has an average elevation of about 47 meters (154 feet).

Thought 4: I have all the information I need.
Action 4: Finish[47 meters (154 feet)]

"""
Minimal ReAct agent implemented from scratch.

No LangChain, no LangGraph, no frameworks — just the OpenAI API
and Python. This implementation demonstrates the core ReAct pattern.
"""

import json
import re
from openai import OpenAI

client = OpenAI()

# --- Tool Implementations ---

def search(query: str) -> str:
    """Simulated search tool."""
    # In production, use a real search API
    knowledge = {
        "python creator": "Python was created by Guido van Rossum, first released in 1991.",
        "guido van rossum": "Guido van Rossum is a Dutch programmer, born in Haarlem, Netherlands, on January 31, 1956.",
        "haarlem netherlands": "Haarlem is a city in the Netherlands, capital of North Holland province. Population approximately 162,000.",
        "haarlem elevation": "Haarlem sits at an elevation of approximately 1 meter above sea level, in the low-lying Netherlands.",
        "eiffel tower height": "The Eiffel Tower is 330 meters tall (including antenna) or 300 meters to the roof.",
        "transformer paper": "The Transformer was introduced in 'Attention Is All You Need' by Vaswani et al. (2017) at NeurIPS.",
        "react paper": "ReAct was published by Yao et al. (2023) at ICLR. It synergizes reasoning and acting in LLMs.",
    }

    query_lower = query.lower()
    for key, value in knowledge.items():
        if key in query_lower:
            return value

    return f"No results found for: {query}"


def calculator(expression: str) -> str:
    """Safe calculator."""
    import math
    allowed = {"__builtins__": {}, "math": math, "abs": abs, "round": round,
               "sqrt": math.sqrt, "pi": math.pi, "e": math.e}
    try:
        result = eval(expression, allowed)
        return str(result)
    except Exception as e:
        return f"Error: {e}"


def finish(answer: str) -> str:
    """Signal that the agent has reached a final answer."""
    return answer


TOOLS = {
    "Search": search,
    "Calculator": calculator,
    "Finish": finish,
}


# --- The ReAct Prompt ---

REACT_SYSTEM_PROMPT = """You are a helpful assistant that answers questions using a Thought-Action-Observation loop.

You have access to the following tools:
- Search[query]: Search for information. Input is a search query string.
- Calculator[expression]: Calculate a mathematical expression. Input is a Python math expression.
- Finish[answer]: Return the final answer. Use this when you have enough information.

You MUST follow this EXACT format for each step:

Thought: <your reasoning about what to do next>
Action: <ToolName>[<input>]

Then you will receive:
Observation: <result of the action>

Important rules:
1. Always start with a Thought before taking an Action.
2. Each response should contain exactly ONE Thought and ONE Action.
3. Use Search when you need factual information.
4. Use Calculator when you need precise computations.
5. Use Finish[answer] when you have enough information to answer the question.
6. If a search returns unhelpful results, try rephrasing the query.
7. Do not make up information — always search for facts you are unsure about.
"""


# --- The ReAct Agent ---

class ReActAgent:
    """A minimal ReAct agent."""

    def __init__(self, model: str = "gpt-4o", max_steps: int = 10, verbose: bool = True):
        self.model = model
        self.max_steps = max_steps
        self.verbose = verbose

    def run(self, question: str) -> str:
        """Run the ReAct loop to answer a question."""

        messages = [
            {"role": "system", "content": REACT_SYSTEM_PROMPT},
            {"role": "user", "content": f"Question: {question}"},
        ]

        trajectory = []  # For logging

        for step in range(self.max_steps):
            if self.verbose:
                print(f"\n{'='*50}")
                print(f"Step {step + 1}")
                print(f"{'='*50}")

            # Get the next thought and action from the LLM
            response = client.chat.completions.create(
                model=self.model,
                messages=messages,
                temperature=0.0,
                max_tokens=500,
            )

            assistant_text = response.choices[0].message.content
            messages.append({"role": "assistant", "content": assistant_text})

            if self.verbose:
                print(assistant_text)

            # Parse the action
            action_match = re.search(r'Action:\s*(\w+)\[(.+?)\]', assistant_text)

            if not action_match:
                # The model did not follow the format — try to extract an answer
                if self.verbose:
                    print("  [Warning: Could not parse action, attempting recovery]")

                # Check if there is a Finish action without proper formatting
                finish_match = re.search(r'(?:answer|final answer)[:\s]+(.+)', assistant_text, re.IGNORECASE)
                if finish_match:
                    return finish_match.group(1).strip()

                # Ask the model to reformulate
                messages.append({
                    "role": "user",
                    "content": "Please follow the required format: Thought: <reasoning>\nAction: <ToolName>[<input>]"
                })
                continue

            tool_name = action_match.group(1)
            tool_input = action_match.group(2)

            # Check if this is the Finish action
            if tool_name == "Finish":
                trajectory.append({
                    "step": step + 1,
                    "thought": assistant_text.split("Action:")[0].strip(),
                    "action": f"Finish[{tool_input}]",
                    "observation": "DONE",
                })
                if self.verbose:
                    print(f"\nObservation: Final answer reached.")
                return tool_input

            # Execute the tool
            if tool_name in TOOLS:
                observation = TOOLS[tool_name](tool_input)
            else:
                observation = f"Error: Unknown tool '{tool_name}'. Available tools: {list(TOOLS.keys())}"

            if self.verbose:
                print(f"\nObservation: {observation}")

            # Record the trajectory
            trajectory.append({
                "step": step + 1,
                "thought": assistant_text.split("Action:")[0].strip(),
                "action": f"{tool_name}[{tool_input}]",
                "observation": observation,
            })

            # Feed the observation back
            messages.append({
                "role": "user",
                "content": f"Observation: {observation}"
            })

        return "Agent reached maximum steps without finding an answer."


# --- Usage ---
if __name__ == "__main__":
    agent = ReActAgent(verbose=True)

    # Example 1: Multi-hop question requiring multiple searches
    print("\n" + "=" * 70)
    print("QUESTION 1: Multi-hop factual question")
    print("=" * 70)
    answer = agent.run(
        "What is the elevation of the birthplace of the creator of Python?"
    )
    print(f"\nFINAL ANSWER: {answer}")

    # Example 2: Question requiring search + calculation
    print("\n" + "=" * 70)
    print("QUESTION 2: Search + calculation")
    print("=" * 70)
    answer = agent.run(
        "How many Eiffel Towers stacked on top of each other would it take to reach the cruising altitude of a commercial airplane (35,000 feet)?"
    )
    print(f"\nFINAL ANSWER: {answer}")

"""
Plan-and-Execute agent architecture.

Separates high-level planning from step-by-step execution.
"""

import json
from openai import OpenAI

client = OpenAI()


def create_plan(question: str) -> list[str]:
    """Use the LLM to create a plan for answering the question."""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a planning agent. Given a question, create a "
                    "step-by-step plan to answer it. Each step should be a "
                    "clear, actionable instruction.\n\n"
                    "Available tools:\n"
                    "- Search the web for information\n"
                    "- Calculate mathematical expressions\n"
                    "- Read files from the workspace\n\n"
                    "Return the plan as a JSON array of strings, where each "
                    "string is one step. Return ONLY the JSON array."
                )
            },
            {"role": "user", "content": f"Question: {question}"}
        ],
        response_format={"type": "json_object"},
        temperature=0.0,
    )

    result = json.loads(response.choices[0].message.content)
    # Handle both {"steps": [...]} and {"plan": [...]} formats
    if isinstance(result, dict):
        steps = result.get("steps") or result.get("plan") or list(result.values())[0]
    else:
        steps = result
    return steps


def execute_step(step: str, context: str, tools: list[dict]) -> str:
    """Execute a single step of the plan, using tools as needed."""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are an execution agent. Complete the given step "
                    "using the available tools. Provide the result clearly.\n\n"
                    f"Context from previous steps:\n{context}"
                )
            },
            {"role": "user", "content": f"Execute this step: {step}"}
        ],
        tools=tools,
        tool_choice="auto",
        temperature=0.0,
    )
    return response.choices[0].message.content or "[Tool call made]"


def should_replan(original_plan: list[str], completed_steps: list[dict], remaining_steps: list[str]) -> tuple[bool, list[str]]:
    """Check if the plan needs adjustment based on execution results."""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a replanning agent. Given the original plan and "
                    "the results of completed steps, determine if the remaining "
                    "steps need to be adjusted.\n\n"
                    "Respond with a JSON object:\n"
                    '{"needs_replan": true/false, "new_remaining_steps": [...]}\n\n'
                    "Only set needs_replan to true if the results significantly "
                    "deviate from what was expected."
                )
            },
            {
                "role": "user",
                "content": json.dumps({
                    "original_plan": original_plan,
                    "completed": completed_steps,
                    "remaining": remaining_steps,
                })
            }
        ],
        response_format={"type": "json_object"},
        temperature=0.0,
    )

    result = json.loads(response.choices[0].message.content)
    return result.get("needs_replan", False), result.get("new_remaining_steps", remaining_steps)


def plan_and_execute(question: str, tools: list[dict], verbose: bool = True) -> str:
    """Run the Plan-and-Execute agent."""

    # Phase 1: Create the plan
    if verbose:
        print("PHASE 1: PLANNING")
        print("-" * 40)

    plan = create_plan(question)

    if verbose:
        for i, step in enumerate(plan):
            print(f"  Step {i+1}: {step}")

    # Phase 2: Execute each step
    if verbose:
        print(f"\nPHASE 2: EXECUTION")
        print("-" * 40)

    completed = []
    remaining = list(plan)
    context = ""

    while remaining:
        current_step = remaining.pop(0)
        step_num = len(completed) + 1

        if verbose:
            print(f"\n  Executing Step {step_num}: {current_step}")

        result = execute_step(current_step, context, tools)

        if verbose:
            print(f"  Result: {result[:200]}...")

        completed.append({"step": current_step, "result": result})
        context += f"\nStep {step_num}: {current_step}\nResult: {result}\n"

        # Check if replanning is needed (every 2 steps)
        if remaining and len(completed) % 2 == 0:
            needs_replan, new_remaining = should_replan(plan, completed, remaining)
            if needs_replan:
                if verbose:
                    print(f"\n  [REPLANNING] Adjusting remaining steps")
                    for i, step in enumerate(new_remaining):
                        print(f"    New Step {len(completed)+i+1}: {step}")
                remaining = new_remaining

    # Phase 3: Synthesize the final answer
    if verbose:
        print(f"\nPHASE 3: SYNTHESIS")
        print("-" * 40)

    synthesis = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": "Synthesize the results of the completed steps into a clear, complete answer to the original question."
            },
            {
                "role": "user",
                "content": f"Question: {question}\n\nCompleted steps and results:\n{context}"
            }
        ],
        temperature=0.0,
    )

    return synthesis.choices[0].message.content

"""
Reflexion agent: learns from failures through self-reflection.
"""

import json
from openai import OpenAI

client = OpenAI()


class ReflexionAgent:
    """An agent that improves through verbal self-reflection."""

    def __init__(self, model: str = "gpt-4o", max_attempts: int = 3):
        self.model = model
        self.max_attempts = max_attempts
        self.reflections = []  # Persistent memory of past reflections

    def attempt(self, task: str, attempt_num: int) -> str:
        """Make one attempt at the task."""

        reflection_context = ""
        if self.reflections:
            reflection_context = "\n\nLessons from previous attempts:\n"
            for i, ref in enumerate(self.reflections):
                reflection_context += f"\nAttempt {i+1} reflection:\n{ref}\n"

        response = client.chat.completions.create(
            model=self.model,
            messages=[
                {
                    "role": "system",
                    "content": (
                        "You are a problem-solving agent. Solve the given task carefully. "
                        "Think step by step.\n"
                        f"{reflection_context}"
                        "\nIf there are lessons from previous attempts, "
                        "make sure to incorporate them into your approach."
                    )
                },
                {"role": "user", "content": task}
            ],
            temperature=0.0 if attempt_num == 0 else 0.3,  # More exploration on retries
        )

        return response.choices[0].message.content

    def evaluate(self, task: str, response: str) -> tuple[bool, str]:
        """Evaluate whether the response correctly addresses the task."""
        eval_response = client.chat.completions.create(
            model=self.model,
            messages=[
                {
                    "role": "system",
                    "content": (
                        "You are a strict evaluator. Assess whether the response "
                        "correctly and completely answers the task. "
                        "Respond with JSON: {\"correct\": true/false, \"feedback\": \"explanation\"}"
                    )
                },
                {
                    "role": "user",
                    "content": f"Task: {task}\n\nResponse:\n{response}"
                }
            ],
            response_format={"type": "json_object"},
            temperature=0.0,
        )

        result = json.loads(eval_response.choices[0].message.content)
        return result.get("correct", False), result.get("feedback", "")

    def reflect(self, task: str, response: str, feedback: str) -> str:
        """Generate a reflection on what went wrong and how to improve."""
        reflection_response = client.chat.completions.create(
            model=self.model,
            messages=[
                {
                    "role": "system",
                    "content": (
                        "You are a self-reflection agent. Analyze the failed attempt "
                        "and provide specific, actionable insights for improvement.\n\n"
                        "Your reflection should:\n"
                        "1. Identify the specific error or gap.\n"
                        "2. Explain WHY the error occurred.\n"
                        "3. Provide a concrete strategy for the next attempt.\n"
                        "Be concise but specific."
                    )
                },
                {
                    "role": "user",
                    "content": (
                        f"Task: {task}\n\n"
                        f"My response:\n{response}\n\n"
                        f"Evaluation feedback: {feedback}"
                    )
                }
            ],
            temperature=0.0,
        )

        return reflection_response.choices[0].message.content

    def run(self, task: str, verbose: bool = True) -> str:
        """Run the Reflexion loop."""

        for attempt_num in range(self.max_attempts):
            if verbose:
                print(f"\n{'='*50}")
                print(f"ATTEMPT {attempt_num + 1}")
                print(f"{'='*50}")

            # Step 1: Make an attempt
            response = self.attempt(task, attempt_num)
            if verbose:
                print(f"\nResponse:\n{response[:500]}...")

            # Step 2: Evaluate
            correct, feedback = self.evaluate(task, response)
            if verbose:
                print(f"\nEvaluation: {'PASS' if correct else 'FAIL'}")
                print(f"Feedback: {feedback}")

            if correct:
                if verbose:
                    print(f"\nTask completed successfully on attempt {attempt_num + 1}!")
                return response

            # Step 3: Reflect (only if failed and more attempts remain)
            if attempt_num < self.max_attempts - 1:
                reflection = self.reflect(task, response, feedback)
                self.reflections.append(reflection)
                if verbose:
                    print(f"\nReflection:\n{reflection}")

        if verbose:
            print(f"\nMax attempts ({self.max_attempts}) reached.")
        return response  # Return the last attempt


# Usage
if __name__ == "__main__":
    agent = ReflexionAgent(max_attempts=3)

    task = """
    Write a Python function that takes a list of integers and returns
    the longest increasing subsequence. The function should handle
    edge cases: empty list, single element, all same elements,
    and already sorted list. Include type hints and a docstring.
    """

    result = agent.run(task)
    print(f"\nFinal result:\n{result}")

"""
Simplified LATS-inspired agent.

This is a conceptual implementation showing the key ideas.
A full LATS implementation requires more infrastructure
(proper tree data structures, UCB1 selection, etc.).
"""

import json
import math
from dataclasses import dataclass, field
from openai import OpenAI

client = OpenAI()


@dataclass
class Node:
    """A node in the search tree."""
    state: str                    # Description of current state
    action: str = ""              # Action that led to this state
    observation: str = ""         # Result of the action
    value: float = 0.0            # Estimated value of this node
    visits: int = 0               # Number of times this node was visited
    children: list = field(default_factory=list)
    parent: object = None         # Parent node
    depth: int = 0
    is_terminal: bool = False

    def ucb1(self, exploration_weight: float = 1.4) -> float:
        """Upper Confidence Bound for tree selection."""
        if self.visits == 0:
            return float('inf')  # Unexplored nodes have highest priority
        exploitation = self.value / self.visits
        exploration = exploration_weight * math.sqrt(
            math.log(self.parent.visits) / self.visits
        )
        return exploitation + exploration


class LATSAgent:
    """Language Agent Tree Search."""

    def __init__(self, model: str = "gpt-4o", max_iterations: int = 10,
                 max_depth: int = 5, n_children: int = 3):
        self.model = model
        self.max_iterations = max_iterations
        self.max_depth = max_depth
        self.n_children = n_children

    def generate_actions(self, node: Node, task: str) -> list[str]:
        """Generate possible next actions from the current state."""
        response = client.chat.completions.create(
            model=self.model,
            messages=[
                {
                    "role": "system",
                    "content": (
                        f"You are solving: {task}\n\n"
                        f"Current state: {node.state}\n\n"
                        f"Generate exactly {self.n_children} different possible next actions. "
                        f"Each should be a distinct approach. "
                        f"Return as JSON: {{\"actions\": [\"action1\", \"action2\", ...]}}"
                    )
                },
                {"role": "user", "content": "What are the possible next actions?"}
            ],
            response_format={"type": "json_object"},
            temperature=0.8,
        )

        result = json.loads(response.choices[0].message.content)
        return result.get("actions", [])[:self.n_children]

    def evaluate_state(self, node: Node, task: str) -> float:
        """Evaluate how promising the current state is (0-1)."""
        response = client.chat.completions.create(
            model=self.model,
            messages=[
                {
                    "role": "system",
                    "content": (
                        "Evaluate how close this state is to solving the task. "
                        "Return JSON: {\"score\": 0.0-1.0, \"is_solution\": true/false, \"reasoning\": \"...\"}"
                    )
                },
                {
                    "role": "user",
                    "content": f"Task: {task}\n\nCurrent state:\n{node.state}"
                }
            ],
            response_format={"type": "json_object"},
            temperature=0.0,
        )

        result = json.loads(response.choices[0].message.content)
        node.is_terminal = result.get("is_solution", False)
        return result.get("score", 0.5)

    def select(self, root: Node) -> Node:
        """Select the most promising leaf node using UCB1."""
        node = root
        while node.children:
            # Select child with highest UCB1 score
            node = max(node.children, key=lambda c: c.ucb1())
        return node

    def backpropagate(self, node: Node, value: float):
        """Update value estimates up the tree."""
        current = node
        while current is not None:
            current.visits += 1
            current.value += value
            current = current.parent

    def run(self, task: str, verbose: bool = True) -> str:
        """Run LATS to solve a task."""

        # Initialize the root
        root = Node(state=f"Task: {task}\nNo actions taken yet.", visits=1)

        best_solution = None
        best_score = 0.0

        for iteration in range(self.max_iterations):
            if verbose:
                print(f"\n--- LATS Iteration {iteration + 1} ---")

            # 1. SELECT: Choose the most promising leaf
            leaf = self.select(root)

            if leaf.depth >= self.max_depth:
                if verbose:
                    print(f"  Max depth reached at this branch.")
                self.backpropagate(leaf, 0.0)
                continue

            # 2. EXPAND: Generate child actions
            actions = self.generate_actions(leaf, task)
            if verbose:
                print(f"  Generated {len(actions)} actions")

            for action in actions:
                new_state = f"{leaf.state}\n\nAction: {action}\n"
                child = Node(
                    state=new_state,
                    action=action,
                    parent=leaf,
                    depth=leaf.depth + 1,
                )
                leaf.children.append(child)

            # 3. EVALUATE: Score each new child
            for child in leaf.children:
                score = self.evaluate_state(child, task)
                child.value = score

                if verbose:
                    print(f"  Action: {child.action[:60]}... Score: {score:.2f}"
                          f"{' [SOLUTION]' if child.is_terminal else ''}")

                # Track the best solution
                if child.is_terminal and score > best_score:
                    best_solution = child
                    best_score = score

                # 4. BACKPROPAGATE
                self.backpropagate(child, score)

            # Early termination if we found a good solution
            if best_solution and best_score > 0.9:
                if verbose:
                    print(f"\n  Found high-quality solution (score: {best_score:.2f})")
                break

        if best_solution:
            return best_solution.state
        else:
            # Return the highest-valued path
            best_leaf = self.select(root)
            return best_leaf.state

"""
Conceptual LangGraph-style implementation.
(Simplified for educational purposes — actual LangGraph API may differ.)
"""

# LangGraph models agents as state machines with nodes and edges

# Node: A function that processes state and returns updated state
# Edge: A conditional routing function that determines the next node

from typing import TypedDict, Literal

class AgentState(TypedDict):
    """The state that flows through the graph."""
    messages: list[dict]
    plan: list[str]
    current_step: int
    results: list[str]
    status: str  # "planning", "executing", "reflecting", "done"


def planner_node(state: AgentState) -> AgentState:
    """Generate a plan based on the user's query."""
    # ... LLM call to create plan ...
    state["plan"] = ["step 1", "step 2", "step 3"]
    state["status"] = "executing"
    state["current_step"] = 0
    return state


def executor_node(state: AgentState) -> AgentState:
    """Execute the current step of the plan."""
    step = state["plan"][state["current_step"]]
    # ... Execute step with tools ...
    result = f"Result of: {step}"
    state["results"].append(result)
    state["current_step"] += 1
    return state


def reflector_node(state: AgentState) -> AgentState:
    """Reflect on results and decide whether to continue or replan."""
    # ... LLM evaluates progress ...
    if state["current_step"] >= len(state["plan"]):
        state["status"] = "done"
    return state


def router(state: AgentState) -> Literal["executor", "reflector", "done"]:
    """Route to the next node based on current state."""
    if state["status"] == "done":
        return "done"
    elif state["current_step"] < len(state["plan"]):
        return "executor"
    else:
        return "reflector"


# The graph structure:
#
#   START → planner → executor ◄──┐
#                  │               │
#                  └──▶ reflector ─┘
#                         │
#                         └──▶ END (when done)

"""
LangGraph ReAct implementation (conceptual).

This shows how LangGraph maps the ReAct pattern onto a graph structure.
"""

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
from operator import add

class AgentState(TypedDict):
    messages: list[dict]
    tool_calls: list[dict]
    tool_results: Annotated[list[str], add]  # Accumulates across steps

def call_model(state: AgentState) -> AgentState:
    """Node: Call the LLM with current messages."""
    # ... LLM call that may produce tool calls or a final answer ...
    return {"messages": state["messages"] + [response]}

def execute_tools(state: AgentState) -> AgentState:
    """Node: Execute any pending tool calls."""
    # ... Execute tools, append results to messages ...
    return {"tool_results": [result]}

def should_continue(state: AgentState) -> str:
    """Edge: Decide whether to continue or finish."""
    last_message = state["messages"][-1]
    if last_message.get("tool_calls"):
        return "tools"      # Go to execute_tools node
    return "end"            # Go to END

# Build the graph
graph = StateGraph(AgentState)
graph.add_node("agent", call_model)
graph.add_node("tools", execute_tools)
graph.set_entry_point("agent")
graph.add_conditional_edges("agent", should_continue, {"tools": "tools", "end": END})
graph.add_edge("tools", "agent")  # After tools, always go back to agent

app = graph.compile()

"""
OpenAI Agents SDK: Multi-agent handoff pattern (conceptual).

A triage agent delegates to specialized agents based on the user's request.
"""

from agents import Agent, Runner

# Specialized agents
coding_agent = Agent(
    name="Coding Assistant",
    instructions="You are an expert Python developer. Help with code questions.",
    tools=[execute_code, read_file, write_file],
)

research_agent = Agent(
    name="Research Assistant",
    instructions="You are a research assistant. Search for and synthesize information.",
    tools=[web_search, arxiv_search, summarize],
)

# Triage agent that routes to specialists
triage_agent = Agent(
    name="Triage Agent",
    instructions=(
        "You are a triage agent. Determine whether the user needs help with "
        "coding or research, then hand off to the appropriate specialist."
    ),
    handoffs=[coding_agent, research_agent],
)

# Run the agent system
result = Runner.run_sync(triage_agent, "Help me implement a binary search tree in Python")
# The triage agent hands off to coding_agent, which handles the request

"""
CrewAI: Role-based agent team (conceptual).

A research crew with complementary roles.
"""

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find and analyze the latest papers on agentic AI architectures",
    backstory="You are a senior NLP researcher with 10 years of experience.",
    tools=[arxiv_search, semantic_scholar_search],
)

writer = Agent(
    role="Technical Writer",
    goal="Synthesize research findings into a clear, structured report",
    backstory="You are a technical writer who specializes in making complex AI topics accessible.",
    tools=[],
)

# Tasks
research_task = Task(
    description="Find the 5 most influential papers on agent architectures published in 2024-2025.",
    expected_output="A list of papers with summaries and key contributions.",
    agent=researcher,
)

writing_task = Task(
    description="Write a 2-page summary of the research findings.",
    expected_output="A structured report in Markdown format.",
    agent=writer,
)

# The crew runs tasks sequentially: researcher first, then writer
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
)

result = crew.kickoff()

"""
Hybrid: ReAct agent with Reflexion-style self-correction.

Uses ReAct for step-by-step execution, but adds a reflection
step if the agent detects it is going in circles or making errors.
"""

class HybridAgent:
    def __init__(self):
        self.react_steps = []
        self.reflections = []
        self.failed_actions = set()

    def run(self, task: str, max_react_steps: int = 10, max_retries: int = 3) -> str:
        for retry in range(max_retries):
            # Run ReAct
            result = self._react_loop(task, max_react_steps)

            # Evaluate
            success, feedback = self._evaluate(task, result)

            if success:
                return result

            # Reflect and retry
            reflection = self._reflect(task, result, feedback)
            self.reflections.append(reflection)
            self.react_steps = []  # Reset for next attempt

        return result  # Return best effort

User: "Fix the failing test in test_auth.py"

OBSERVE: Read the test file to understand what is being tested.
  → read_file("test_auth.py")
  → Found: test_login_valid_credentials is failing

THINK: The test expects a 200 status code but gets 401.
This suggests the authentication logic has a bug.
I should look at the auth module.

ACT: Read the authentication module.
  → read_file("auth/login.py")

OBSERVE: The login function checks password but has a typo:
  Line 42: if password = stored_hash:  (assignment, not comparison!)

THINK: Found the bug — single = instead of ==.
I need to fix this and verify the test passes.

ACT: Edit the file.
  → edit_file("auth/login.py", line=42, new="    if password == stored_hash:")

OBSERVE: File saved successfully.

THINK: Now I should run the test to verify the fix works.

ACT: Run the test.
  → execute("python -m pytest test_auth.py::test_login_valid_credentials -v")

OBSERVE: test_login_valid_credentials PASSED (1 passed in 0.3s)

THINK: The test passes now. The fix is correct. I should also run
the full test suite to make sure I did not break anything.

ACT: Run all tests.
  → execute("python -m pytest test_auth.py -v")

OBSERVE: All 12 tests passed.

THINK: All tests pass. The fix is complete.

RESPOND: "Fixed the bug in auth/login.py line 42: changed single = (assignment)
to == (comparison) in the password check. All 12 tests pass."