Projects/ReAct Research Agent/Part 3

The ReAct Loop

Parse Thought/Action/Action Input, run search and open, cap steps, and finish with an answer object including citations.

This part is the runtime: parse ReAct text → tool → observation → repeat. You will keep a fake model that emits ReAct strings so the parser is real. A production LLM will emit the same shape if you prompt it that way (or you will use native tool calls and skip the poetry — still keep the parser tests).

The ReAct grammar (strict)

text

Thought: <one line>
Action: search|open|finish
Action Input: <string or JSON>

Rules you should enforce:

All three labels present, in order.
Action is an allowlisted name.
For search, Action Input is a query string.
For open, Action Input is a URL string.
For finish, Action Input is JSON: {"answer": "...", "citations": ["..."], "cannot_answer": false}.

If the model uses Final Answer: instead of finish, reject it. One protocol. Your weather project already taught you that kindness in parsers becomes ambiguity in production.

Fake policy for the happy path

For Who founded Acme Robotics?:

Thought: need to search.
Action search Acme Robotics founded.
Observation: hits include wiki/acme.
Thought: open the wiki.
Action open that URL.
Thought: fact is in the body.
Action finish with Ada Ortiz, 2014, citations [that url].

Implement this as a state machine keyed off opened and searched flags, not as a recorded script only — so a second question can work with the same function.

Live Pythonpython

import json
import re

WEB = {
    "https://wiki.example/acme": {
        "title": "Acme Robotics",
        "body": "Acme Robotics was founded by Ada Ortiz in 2014 in Lisbon.",
    },
    "https://news.example/ada": {
        "title": "Interview",
        "body": "Ortiz left in 2021. Current CEO is Kenji Ito.",
    },
}

def tokens(text):
    return set(re.findall(r"[a-z]{3,}", text.lower()))

def search(query):
    q = tokens(query)
    hits = []
    for url, page in WEB.items():
        score = len(q & tokens(page["title"] + " " + page["body"]))
        if score:
            hits.append({"url": url, "title": page["title"], "snippet": page["body"][:80], "score": score})
    hits.sort(key=lambda h: -h["score"])
    return {"hits": hits[:3]}

def open_url(url):
    page = WEB.get(url)
    return {"error": "not_found", "url": url} if not page else {"url": url, "title": page["title"], "body": page["body"]}

def parse_react(text):
    thought = re.search(r"Thought:\s*(.*)", text)
    action = re.search(r"Action:\s*(\w+)", text)
    inp = re.search(r"Action Input:\s*(.*)", text, re.S)
    if not (thought and action and inp):
        raise ValueError("react_shape")
    name = action.group(1).strip()
    raw = inp.group(1).strip()
    if name == "finish":
        args = json.loads(raw)
    elif name == "search":
        args = {"query": raw.strip().strip('"')}
    elif name == "open":
        args = {"url": raw.strip().strip('"')}
    else:
        raise ValueError("bad_action")
    return {"thought": thought.group(1).strip(), "tool": name, "args": args}

def fake_react(transcript):
    opened = [e["content"] for e in transcript if e.get("name") == "open" and "body" in e.get("content", {})]
    searched = any(e.get("name") == "search" for e in transcript)
    if not searched:
        return (
            "Thought: I should search the corpus.\n"
            "Action: search\n"
            "Action Input: Acme Robotics founded"
        )
    if not opened:
        hits = next(e["content"]["hits"] for e in reversed(transcript) if e.get("name") == "search")
        url = hits[0]["url"]
        return f"Thought: Open the top hit.\nAction: open\nAction Input: {url}"
    body = opened[0]["body"]
    finish = {
        "answer": body,
        "citations": [opened[0]["url"]],
        "cannot_answer": False,
    }
    return (
        "Thought: The page has the founder.\n"
        "Action: finish\n"
        f"Action Input: {json.dumps(finish)}"
    )

TOOLS = {
    "search": lambda **kw: search(kw["query"]),
    "open": lambda **kw: open_url(kw["url"]),
    "finish": lambda **kw: dict(kw),
}

def run_react(question, max_steps=6):
    transcript = [{"role": "user", "content": question}]
    opened_urls = set()
    for step in range(1, max_steps + 1):
        parsed = parse_react(fake_react(transcript))
        print(f"step {step} thought: {parsed['thought']}")
        result = TOOLS[parsed["tool"]](**parsed["args"])
        if parsed["tool"] == "open" and "url" in result and "error" not in result:
            opened_urls.add(result["url"])
        transcript.append({"role": "tool", "name": parsed["tool"], "content": result, "thought": parsed["thought"]})
        if parsed["tool"] == "finish":
            result = dict(result)
            result["opened_urls"] = sorted(opened_urls)
            return result
    return {"cannot_answer": True, "answer": "budget", "citations": [], "opened_urls": sorted(opened_urls)}

out = run_react("Who founded Acme Robotics?")
print("FINISH:", json.dumps(out, indent=2))

Output

Run to execute this in your browser. Nothing is sent to a server.

Step-by-step loop details

Prompt the policy with the question, tool docs, and ReAct format reminder.
Parse strictly. On failure, same parse-retry pattern as the weather agent.
Execute search / open / finish.
Append observation without the thought if you are token-poor; keep thoughts in a side trace.
On finish, do not trust citations yet — part 4 validates.
Hit max_steps → cannot-answer, not a guessed paragraph.

Max steps is a product feature

Research feels unbounded. It is not. Six tool calls is plenty for a 4-page web. If the model is still searching, it is stuck. Convert stuckness into abstention. Users prefer "I could not find this" to a confident wrong founder.

Thoughts in the transcript

If you send thoughts back into the next prompt, the model may imitate bad reasoning. Some teams strip thoughts from the next call and only keep actions+observations. Try both in part 5. For now, keep them for debugging in print.

Watch out:Never eval Action Input. JSON parse for finish; strings for search/open.

Exercise

Change the fake model so it tries to finish after search without open. Let the loop still run. In part 4 you will reject that finish for missing opens. Observe the bad output today so you know why the check exists.

Check your understanding

When max_steps is hit, what should the research agent do?

Guess from the model weights
Return a cannot-answer / budget failure, not a fabricated citation
Open every URL in WEB
Restart with a larger model

Fake Web Search and Open

Up next

Citations, Max Steps, and Cannot-Answer