Q1. What is ReAct prompting and how does it combine reasoning and acting?

ReAct (Reasoning + Acting) is a prompting framework that interleaves reasoning steps (thoughts) with actions (tool calls or environment interactions).
Instead of generating only text, the model can output thought-action-observation loops.
For example, a ReAct prompt for a question-answering task might have the model think: "I need to look up the population of France", then act: "Search(France population)", then observe the result, then think again.
This allows the LLM to interact with external tools (search engines, calculators, APIs) and update its reasoning based on new information.
ReAct significantly improves performance on tasks requiring dynamic information gathering, such as web navigation, fact verification, and task-oriented dialogue.

Q2. How does ReAct differ from standard Chain of Thought (CoT) prompting?

Standard CoT produces a static chain of reasoning without interacting with the external world. It relies entirely on the model's internal knowledge.
ReAct augments CoT with actions that can fetch new information or execute operations.
Example: CoT would reason from memory: "Paris is the capital of France, so..."; ReAct would search the web to verify current population.
ReAct is more powerful for tasks requiring up-to-date or external data, but it requires the model to generate structured action commands and process observations.
ReAct also reduces hallucinations because the model can ground its reasoning in observed facts.

Q3. What are the typical components of a ReAct prompt?

A ReAct prompt usually includes:
• A system instruction explaining the thought-action-observation format.
• Examples (few-shot) of valid reasoning loops.
• A set of available actions (e.g., Search[query], Calculate[expression], Finish[answer]).
• The current question or task.
The model is expected to generate interleaved tokens like "Thought: I need to find X. Action: Search[X]. Observation: The result is Y. Thought: Now I can answer. Action: Finish[Y]."
The environment (or a wrapper script) parses the action, executes it, and appends the observation. This cycle continues until the model outputs Finish.

Q4. Give a concrete example of a ReAct prompt for a multi‑step question.

Question: "What is the capital of the country that hosted the 2016 Summer Olympics?"
ReAct prompt: "You are an assistant with access to a Search tool. Use Thought/Action/Observation loops. Available actions: Search[query], Finish[answer]. Example: Question: Who directed the movie Inception? Thought: I need to find the director. Action: Search[Inception director]. Observation: Christopher Nolan. Action: Finish[Christopher Nolan]."
Then the model generates: "Thought: First I need to find the country that hosted the 2016 Olympics. Action: Search[2016 Summer Olympics host country]. Observation: Brazil. Thought: Now I need the capital of Brazil. Action: Search[capital of Brazil]. Observation: Brasília. Action: Finish[Brasília]."
This demonstrates dynamic lookup.

Q5. What are the challenges and limitations of ReAct prompting?

Challenges include:
• The model must reliably output structured actions; small models may fail.
• Increased token usage due to multiple turns.
• Need for a controlled environment to execute actions safely (e.g., no arbitrary code execution).
• The model may get stuck in loops or produce invalid actions.
• Observation length can blow up context window.
• Tool design matters – actions must be expressive enough.
Despite these, ReAct is widely used in agent frameworks like LangChain and AutoGPT.
Mitigations include action validation, timeout limits, and using more capable models (GPT-4, Claude 3).