A deck I was sent recently described an AI agent for database administration. Clean diagrams, tool call loop, confidence threshold, human escalation. The slides were good. The pattern was ReAct, published by Yao et al. in October 2022. The deck just did not say that.
This is the part of the AI hype cycle I find exhausting. A known academic pattern gets a new name, a vendor logo, and a use case, and suddenly it is an innovation. The DBA example in those slides was a fine illustration. The pattern itself was older than most of the companies selling it as cutting edge.
What ReAct Actually Is
ReAct stands for Reasoning + Acting. It is a loop. The LLM produces a thought about what to do next, picks an action from a tool whitelist, the action runs, the result comes back as an observation, and that observation feeds into the next thought. Rinse and repeat until the model decides the task is done.
Thought: I need to check if the orders table is locked.
Action: run_sql("SELECT pid FROM pg_locks WHERE relation = 'orders'::regclass")
Observation: [{"pid": 3421}]
Thought: There is a lock held by pid 3421. I should check what query is running.
Action: run_sql("SELECT query FROM pg_stat_activity WHERE pid = 3421")
Observation: [{"query": "UPDATE orders SET ... WHERE created_at < ..."}]
Thought: Long-running update. I should escalate before killing it.
Action: notify_slack("DBA: long UPDATE on orders, pid 3421, need decision")
Observation: Message delivered to #oncall
Thought: Done. Writeback the incident.That is it. The whole pattern. Everything else in the slides, the triggers, the tool whitelist, the confidence-based escape hatch, is scaffolding around that loop. Important scaffolding, but scaffolding.
Why the Repackaging Works
The reason ReAct keeps getting rediscovered is that the original paper was academic. Prompt examples, a few benchmark tasks, no production war stories. Vendors and consultants take that academic kernel, wrap it in a domain (DBA, security ops, customer support, internal IT), add their toolbox, and ship it as a product.
I am not against that. Turning a paper into a usable product is real work. The problem is when the domain wrapper is sold as the innovation, and you end up paying for a ReAct loop wrapped around a tool whitelist your team could have built in a week.
What Entry-Level Agent Presentations Usually Omit
If you are watching a pitch or a talk about agents and they cover only the loop, the tools, and the escape hatch, here is what I push them on. These are the parts that separate a working demo from an agent that survives in production.
Memory Is Usually Missing
The loop has a scratchpad. That scratchpad is the short-term memory of the session. Fine. But what happens tomorrow when a similar incident hits? If the agent does not read from and write to a persistent store, it is reactive, not learning. Most intro decks skip this entirely. I have a separate post on memory architecture because it is not one thing, it is five layers.
Context Grows Every Iteration
Every thought, action, and observation goes back into the prompt for the next iteration. Ten loops in and you are paying for a prompt with ten thoughts, ten tool calls, and ten observations. Twenty loops in, you hit the ceiling of your context window or your budget. The decks never show the token cost per run. Ask for it.
Evaluation Is Hand-Waved
Non-deterministic systems need evaluation harnesses. How do you know a change to the system prompt did not regress behavior on a set of known incidents? If the pitch does not have a golden-set replay or a way to compare decisions across versions, it is a prototype dressed as a product.
How to Evaluate an Agent Pitch Without Being That Person
I am not suggesting you walk into every vendor meeting yelling about the Yao paper. The pattern is useful, the productization has real value, and grumpy developers saying "this is just ReAct" are the reason people stop inviting us to meetings. But there are four questions that expose whether the team selling you the agent knows what they are doing.
- What happens to the context on loop 20? If they do not have a summarization or truncation strategy, the agent dies or burns money in long sessions.
- Where does memory live? Session-only is fine for simple agents. For anything operational, I want to see a long-term store and a sync path into it.
- How do you prevent a confidently wrong action? Whitelist plus dry-run plus confidence threshold is a minimum. Without it, the agent will do something you cannot undo.
- How do you evaluate changes? A system prompt change is a behavior change. Without a regression harness you are shipping by vibes.
The pattern is from 2022. The hype is from last Tuesday. Evaluate the implementation, not the brochure.
What This Actually Means for You
If you are evaluating an agent product, you now know the baseline. If you are building one, you now know where the interesting problems are. The loop is not the hard part. The hard parts are memory, evaluation, cost control, and recovery from bad decisions. Anyone who tells you otherwise is selling you the scaffolding and calling it the house.
References
- ReAct: Synergizing Reasoning and Acting in Language Models, Yao et al., 2022: https://arxiv.org/abs/2210.03629
- Prompt Engineering Guide, ReAct section: https://www.promptingguide.ai/techniques/react
- LangGraph agent concepts: https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/