AI Agents: ReAct, Tools and Memory Reference Guide

You are a careful research assistant. You have these tools:

- search(query: str) -> str          # web search; returns top-3 snippets
- fetch(url: str) -> str             # fetch full page text
- calc(expr: str) -> str             # safe arithmetic

Follow this loop EXACTLY. One step at a time, do NOT batch:

Thought: 
Action: ()
Observation: 

When you are ready to answer:

Thought: I have enough information.
Final Answer: 

Rules:
- If a tool fails twice, stop and explain.
- If unsure, call search before answering.
- Never invent URLs or dates.

# Minimal tool-calling loop — no framework, just the SDK.
import json
from anthropic import Anthropic

client = Anthropic()
TOOLS = [{
    "name": "get_weather",
    "description": "Return current weather for a city.",
    "input_schema": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"],
    },
}]

def get_weather(city: str) -> str:
    return f"{city}: 22 C, clear."

def run(user_msg: str, max_steps: int = 6) -> str:
    messages = [{"role": "user", "content": user_msg}]
    for _ in range(max_steps):
        resp = client.messages.create(
            model="claude-sonnet-4-6", max_tokens=1024,
            tools=TOOLS, messages=messages,
        )
        messages.append({"role": "assistant", "content": resp.content})

        if resp.stop_reason == "end_turn":
            return next(b.text for b in resp.content if b.type == "text")

        # Execute every tool call the model wants
        tool_results = []
        for b in resp.content:
            if b.type == "tool_use":
                out = {"get_weather": get_weather}[b.name](**b.input)
                tool_results.append({
                    "type": "tool_result", "tool_use_id": b.id, "content": out,
                })
        messages.append({"role": "user", "content": tool_results})
    raise RuntimeError("step budget exhausted")

# Plan-then-execute pattern — separate planner LLM call, then run the plan.
import json
from anthropic import Anthropic

client = Anthropic()

PLANNER_SYSTEM = """
Decompose the user's task into 3-6 atomic steps. Each step picks ONE tool from:
  search, fetch, calc, answer
Return JSON: {"steps": [{"id": 1, "tool": "search", "input": "..."}]}
Do not execute. Just plan.
""".strip()

def make_plan(task: str) -> list[dict]:
    resp = client.messages.create(
        model="claude-sonnet-4-6", max_tokens=600,
        system=PLANNER_SYSTEM,
        messages=[{"role": "user", "content": task}],
    )
    return json.loads(resp.content[0].text)["steps"]

def execute(plan: list[dict], tools: dict) -> dict:
    """Run each step; rewrite later steps if a step fails."""
    state = {}
    for step in plan:
        try:
            state[step["id"]] = tools[step["tool"]](step["input"])
        except Exception as e:
            return {"error": f"step {step['id']} failed: {e}"}
    return state

# A reflexion-style agent: act -> observe -> self-critique -> retry once.
from anthropic import Anthropic

client = Anthropic()

ACT_SYSTEM = "You are an agent. Reply with ONE tool call OR a final answer."
CRITIC_SYSTEM = (
    "You are a critic. Given the task, the agent's last answer, and the tool log, "
    "reply with either OK or REVISE: ."
)

def step(task, history, tools):
    resp = client.messages.create(
        model="claude-sonnet-4-6", max_tokens=600, tools=tools,
        system=ACT_SYSTEM,
        messages=[*history, {"role": "user", "content": task}],
    )
    return resp

def reflect(task, draft, log):
    crit = client.messages.create(
        model="claude-sonnet-4-6", max_tokens=200,
        system=CRITIC_SYSTEM,
        messages=[{"role": "user", "content":
            f"Task: {task}\nDraft: {draft}\nLog: {log}"}],
    )
    return crit.content[0].text

def run(task, tools, max_retries=1):
    log, draft = [], None
    for attempt in range(max_retries + 1):
        draft = step(task, log, tools).content[0].text
        verdict = reflect(task, draft, log)
        if verdict.startswith("OK"):
            return draft
        log.append({"role": "user", "content": f"Critic: {verdict}. Try again."})
    return draft  # best effort