ReAct vs native tool calling: why we stopped regex-parsing the model

If you want to sound like you understand agents one layer deeper, know how tool calling used to work — because the shift from the old way to native tool calling explains why agents suddenly got reliable around 2023.

The old way: ReAct and regex

The original ReAct pattern (Reasoning + Acting) got tool use out of a plain text model by prompting it to follow a strict format — think, then act — and then parsing that text. The model would emit something like 'Thought: I need the weather. Action: get_weather. Action Input: Paris.', and your code would regex out the action name and input, run the tool, paste the result back as 'Observation:', and loop.

It worked, and it was clever, but it was brittle in exactly the way string-parsing an LLM is always brittle:

• The model would drift from the format — an extra sentence, a missing colon, markdown around the action — and the regex would fail.
• Arguments were free text, so anything structured (a JSON object, a list) had to be coaxed and re-parsed, and often malformed.
• Every framework invented its own format and parser, so nothing was portable.

The fix: native structured tool calling

Providers then trained models to emit tool calls as structured data through a dedicated API field, and to accept tool schemas the same way (the anatomy post shows the payload). The model no longer writes 'Action:' text for you to scrape — it returns a JSON object with a tool name, typed arguments, and an id, guaranteed to be structured. Your code parses it deterministically instead of hoping a regex holds.

That one change removed a whole category of failure. Arguments became reliably structured, the format stopped drifting, and because the major providers converged on the same shape, tool calling became portable across models. Frameworks like LangGraph build their agent loop directly on this native output.

Why it still matters to know

Two reasons. First, you'll still meet models or setups without native tool calling, and then you're back to prompt-and-parse — worth recognising. Second, it's the clearest example of a recurring lesson in LLM engineering: don't parse the model's prose when you can make the model emit structure. Native tool calling is structured output (see that post) applied to actions, and the same principle — constrain, don't scrape — shows up everywhere reliability matters.

ReAct proved an LLM could use tools by writing text you parse. Native tool calling proved it's far more reliable to have the model emit structure you don't have to parse at all.