AI Engineer Portal

Your personal operating system for career transition.

Private mode

Exercise

Implement a ReAct reasoning loop

Implement a ReAct Reasoning Loop

The ReAct (Reasoning + Acting) pattern is the most widely used agent loop in production. The model alternates between thinking (reasoning about what to do next), acting (calling a tool), and observing (reading the tool result) until it can produce a final answer.

What you are building

Create a react_loop function that:

Takes a user question and a dict of available tools.
Sends the question to a (simulated) LLM that returns structured steps.
Parses each step as either a Thought, a Tool Call, or a Final Answer.
Executes tool calls and feeds observations back into the next iteration.
Terminates when the model produces a Final Answer or an iteration cap is reached.
Returns a structured trace of all reasoning steps plus the final answer.

Why this matters

Understanding the ReAct loop from scratch means you can debug agent stalls (infinite loops), optimize token usage (trimming intermediate context), and add features like step-level logging or human-in-the-loop approval. Every agent framework wraps this pattern; knowing the internals makes you dangerous.

Constraints

Simulate the LLM with a provided mock_llm callable so the exercise is self-contained.
The iteration cap should default to 10 and be configurable.
Each trace entry should include: step number, type (thought/action/observation/answer), and content.
If the cap is reached without a final answer, return the trace with a timeout indicator.

Agents / intermediate / Step 2 of 8

Practice stage

Agent architecture patterns

Hint

Focus on explicit control surfaces — function schemas, state machines, and structured outputs. Agents are most useful when the task requires dynamic tool selection or multi-step reasoning. Start with the simplest pattern (single tool call) before reaching for ReAct loops.

Next drill

Add retry and fallback logic to tool calls

Success criteria

- Tools return structured, typed responses
- Agent completes the task within a bounded number of steps
- All tool calls include error handling and retries
- Memory/state management prevents unbounded context growth

Review checklist

- Tool schemas validate inputs and handle errors gracefully
- Agent loop has explicit termination conditions
- State is serializable and inspectable between steps
- Cost and token usage are tracked per invocation
- Fallback behavior exists for tool call failures

from __future__ import annotations

from dataclasses import dataclass, field
from typing import Any, Callable

@dataclass
class TraceEntry:
    """One step in the ReAct trace."""
    step: int
    entry_type: str  # "thought", "action", "observation", "answer"
    content: str

@dataclass
class ReactResult:
    """Final output of a ReAct loop run."""
    answer: str | None
    timed_out: bool
    trace: list[TraceEntry] = field(default_factory=list)

def react_loop(
    question: str,
    tools: dict[str, Callable[..., str]],
    llm: Callable[[list[dict]], dict],
    max_iterations: int = 10,
) -> ReactResult:
    """
    Run a ReAct loop: Thought -> Action -> Observation -> ... -> Answer.

Args:
        question: The user's question to answer.
        tools: Mapping of tool name -> callable that returns a string result.
        llm: A callable that takes conversation messages and returns a dict
             with keys 'type' ('thought', 'action', 'answer') and 'content'.
             For 'action' type, also includes 'tool_name' and 'tool_args'.
        max_iterations: Safety cap on loop iterations.

Returns:
        ReactResult with the answer, timeout flag, and full trace.
    """
    trace: list[TraceEntry] = []
    step = 0

# TODO: Build initial messages list with the question
    # TODO: Loop up to max_iterations:
    #   1. Call llm(messages) to get next step
    #   2. If thought -> record it, add to messages, continue
    #   3. If action -> execute tool, record action + observation
    #   4. If answer -> record it, return ReactResult
    # TODO: If loop exhausts, return ReactResult with timed_out=True

raise NotImplementedError

Practice

Generate a variation

Generate a new exercise variation to deepen understanding or practice a related concept.

Attempt history

Recent submissions

Before you submit, decide what a strong answer should make obvious to the reviewer.

No attempts yet.