AI Agents & the ReAct Loop

1 What Is an "Agent"?

By itself, Claude just turns text into more text (Guide 01). An agent is a loop around that. It calls Claude, reads what Claude says, optionally calls a tool via the MCP server, feeds the result back to Claude, and repeats — until Claude decides it has a final answer.

This is the ReAct pattern: Reasoning + Acting. The model reasons about what to do, acts by calling a tool, then reasons again based on the result.

Concrete trace — "What is the stock level for NF-SKU-001 and who supplies it?"

2 ReactAgent — The Basic Loop

for (int i = 0; i < _options.MaxIterations; i++)
{
    // 1. Build prompt from system instructions + full conversation history
    var prompt = BuildPrompt(request, history);

    // 2. Call Claude — get back a string
    string reply = await _llm.CompleteAsync(prompt, ct);
    history.Add(new AgentMessage { Role = "assistant", Content = reply });

    // 3. Did Claude say it has a final answer?
    var finalAnswer = ExtractTag(reply, "final_answer");
    if (!string.IsNullOrWhiteSpace(finalAnswer))
    {
        yield return new AgentStep { Type = AgentStepType.FinalAnswer, Content = finalAnswer };
        yield break;
    }

    // 4. Did Claude ask to call a tool?
    var toolCallXml = ExtractTag(reply, "tool_call");
    if (!string.IsNullOrWhiteSpace(toolCallXml))
    {
        var toolName = ExtractTag(toolCallXml, "name");
        // _mcp is IMcpServerService — in this project: RealMcpClientService
        var toolResult = await _mcp.InvokeAsync(toolName, ParseToolInput(inputJson));

        history.Add(new AgentMessage
        {
            Role    = "tool",
            Content = $"<tool_result><name>{toolName}</name><output>{resultText}</output></tool_result>"
        });
        continue;
    }
}

IAsyncEnumerable — streaming steps in real time

RunAsync returns IAsyncEnumerable<AgentStep>. This lets the SignalR hub push each step to the browser as it arrives — so users see "Thinking...", "Calling inventory_lookup", "Got result: 250 units", "Final answer" appearing live, not all at once after 10 seconds.

3 ParallelReactAgent — Multiple Tools at Once

When Claude needs two or more independent pieces of information, ParallelReactAgent lets it request multiple tools in a single <tool_calls> (plural) block, then runs them all concurrently with Task.WhenAll.

var tasks   = calls.Select(c => _mcp.InvokeAsync(c.Name, c.Input)).ToList();
var results = await Task.WhenAll(tasks);  // all MCP tool calls run in parallel

If each tool call takes 200ms, two sequential calls cost 400ms. With Task.WhenAll, the cost is still ~200ms.

4 PlanningAgent — Plan First, Then Execute

PlanningAgent forces Claude to produce a full plan first, then execute each step in order. It works in three phases:

5 MultiAgentOrchestrator — Routing to the Right Agent

From the web layer's perspective, there is only ever one thing to call: IMultiAgentOrchestrator.RunAsync(request). The orchestrator is a router: one entry point, multiple strategies behind it. It picks ReactAgent, ParallelReactAgent, or PlanningAgent based on AgentRunRequest.AgentType.

6 AgentStep — What the Agent Emits

public class AgentStep
{
    public AgentStepType Type       { get; set; }  // Thinking | ToolCall | ToolResult | FinalAnswer | Error
    public string        Content    { get; set; }
    public string?       ToolName   { get; set; }
    public string?       ToolInput  { get; set; }
    public string?       ToolOutput { get; set; }
    public bool          IsError    { get; set; }
}

7 Summary

• An agent is a loop: call LLM → parse output → call MCP tool → feed result back → repeat.
• ReactAgent: one tool at a time. Simple and reliable.
• ParallelReactAgent: multiple tools via Task.WhenAll. Faster for independent lookups.
• PlanningAgent: plan → execute steps → synthesize. Best for complex tasks.
• The conversation history is sent to Claude on every iteration. The LLM has no memory of its own.
• IAsyncEnumerable<AgentStep> streams progress to the UI in real time.
• _mcp.InvokeAsync() in this project routes to RealMcpClientService → McpServer subprocess → real MCP tool method.