From Prototype to Production: Hardening the Regex-Based Parser

The agent_loop() implementation from the previous subtopic genuinely works — you now have a fully functional ReAct loop without needing any external orchestration framework like LangChain or CrewAI. But it's worth being explicit about its limitations before treating it as production-ready, because this course is candid about exactly where this demo-grade implementation would need to be hardened.

The core issue: this implementation uses regex matching and hardcoded conditionals to parse the agent's free-text output and route it to the correct tool. That approach works well for a tightly controlled setup like this demo, where the model reliably follows the exact 'Action: tool_name: argument' format the system prompt asked for. But it's brittle in the face of real-world variation: if the agent slightly deviates from the expected format — adds extra whitespace, uses different casing, or mislabels an action — the regex can simply fail to match, and the whole loop breaks down with no graceful recovery.

There's a second, related assumption baked into the simple version: it assumes the agent will never call a tool that doesn't exist, and that all tools will succeed silently without raising an exception. Neither assumption holds up under real usage — models do sometimes hallucinate tool names that were never defined, and real tools (API calls, database queries, file operations) fail for all sorts of legitimate reasons (timeouts, bad input, rate limits).

In a production-grade system, the recommended direction is to move away from free-text parsing entirely and toward more robust parsing — structured prompts that request JSON output, or a provider's native function-calling / tool-calling API, both of which give you a reliably-typed action and argument instead of a string you have to regex out of a paragraph. On top of that, real error handling for unknown tools and tool-execution failures — retries, fallback messages, or escalation to a human — is what actually closes the gap between 'a working demo' and 'an agent you'd trust with real user traffic.'

# Structured-output alternative to regex parsing — using function
# calling instead of free-text "Action: tool: arg" lines.
from openai import OpenAI
import json

client = OpenAI()

tool_schemas = [{
    "type": "function",
    "function": {
        "name": "lookup_population",
        "description": "Look up a country's population",
        "parameters": {
            "type": "object",
            "properties": {"country": {"type": "string"}},
            "required": ["country"],
        },
    },
}]

def robust_agent_step(messages: list[dict]) -> dict:
    resp = client.chat.completions.create(
        model="gpt-4.1", messages=messages, tools=tool_schemas,
    )
    choice = resp.choices[0].message
    if choice.tool_calls:
        call = choice.tool_calls[0]
        # No regex needed — name and arguments are already structured
        return {
            "tool": call.function.name,
            "args": json.loads(call.function.arguments),  # reliably-typed, not string-parsed
        }
    return {"final_answer": choice.content}