Who Named This ReAct? I'd Like to Speak to the Manager.

This week I started the Agentic Engineer Nanodegree through AWS AI & ML Scholars, the next step in what has become my increasingly formal attempt to understand the things I started building before I knew enough to understand all of them.

Somewhere in the coursework, ReAct appeared.

Record scratch.

ReAct?

There was an immediate sense of déjà vu, although not for the reason the curriculum intended.

I know React. At this point I've built enough React frontends that the word belongs to the ordinary furniture of my still-young development vocabulary. Beyond the Docket used React with Vite and TypeScript. RealDoor quite literally labels the browser layer of its architecture "React UI." Several of my Next.js projects are built from React components.

I'm still early enough in this building journey that I regularly encounter concepts for the first time, but React wasn't one of them. React and I had been formally acquainted.

Frontend React itself has had considerably longer to establish its claim to the name. According to the official React history, Facebook open-sourced it on May 29, 2013.

So when a course on agentic engineering presented something called ReAct—capital A, entirely different neighborhood—I wasn't thinking about a 2022 research paper or the history of agent reasoning patterns.

I was thinking:

Wait. React?

Except apparently not that React.

Who named this ReAct? I'd like to speak to the manager.

Then came the explanation.

ReAct combines reasoning and acting. A language model can reason about what it should do, take an action in an external environment, observe what happened, and use that information to continue reasoning about the task.

Reason. Act. Observe. Repeat.

Okay. Fine. The name makes sense.

I absolutely had to keep looking for the manager anyway.

The trail led to the research behind ReAct: Synergizing Reasoning and Acting in Language Models, where Shunyu Yao and his collaborators explored what happens when reasoning and acting—capabilities that had largely been studied separately—are combined.

So this wasn't somebody in the React ecosystem deciding that capitalization could carry the entire burden of technical differentiation.

I withdraw approximately 40 percent of my complaint, maybe.

But while I was reading about ReAct, the déjà vu didn't go away. There was something familiar about the loop, not the name, and eventually I realized why.

The realization sent me back to Verity Lex.

That's where the joke became considerably more embarrassing.

Apparently, I Had Already Met ReAct

I built Verity Lex during OpenAI Build Week because I wanted to turn the usual government technology sales question around: before asking what AI a court should adopt, what if we asked whether the institution was ready for AI in the first place?

I've written about that build and the question behind it before, so I won't retell that story here. What matters for this one is how Verity Lex goes looking for the evidence.

Court websites aren't neat databases waiting for my application to query the right row. A policy might be a PDF. It might be a webpage. It might be buried under administration or linked from a page whose title tells you almost nothing. One document might reveal language that changes what should be searched for next.

So I needed the model to look at what it found and decide what to do next. It searches, observes what comes back, reasons about what that result means, chooses another action, and continues until it has enough evidence or reaches the boundaries I gave it.

If that sounds familiar, congratulations. You apparently knew what ReAct was before I did.

The architecture in my own Verity Lex repository describes the controller as a model-directed ReAct loop:

reason → act → observe → repeat

There it was.

Not metaphorically. Not "well, if you squint, this is sort of agentic."

I had built it.

More precisely, I had designed an application whose discovery architecture used it, worked with AI coding tools to implement it, documented the architecture, tested the application and deployed it.

I just didn't understand that this behavior belonged to a formal pattern with a name and a research lineage.

And because Verity Lex is itself a Next.js application, there was an additional indignity waiting for me: I had managed to put React and ReAct in the same project before I understood that one had been helping render my interface while the other was helping determine what my agent should do next.

Apparently I had already spoken to the manager.

She was... moi.

How Do You Build Something You Don't Know?

This is where I felt sheepish.

There is an important distinction here, because I don't want to rewrite my own history into a story where I asked an AI to "make me an agent" and went to lunch while it assembled something I couldn't describe.

Verity Lex had a PRD. It had architecture. I made deliberate decisions about what the model could control and, more importantly, what it could not.

The model could direct discovery because adaptability was at the forefront of the build. It could not determine the final readiness score because reproducibility was the backbone of the analysis.

I understood the behavior I wanted.

What I didn't have was the formal vocabulary and lineage for part of the architecture I had specified. That distinction matters to me, although I'm still deciding how much comfort I should take from it.

My path into software has happened at a peculiar moment. I didn't arrive through a computer science or engineering program where someone handed me foundational papers in chronological order. I arrived through questions, hackathons and AI coding assistants. Claude, ChatGPT and Gemini became part of how I could turn an idea into something executable long before I had enough technical knowledge to know the name of every pattern appearing underneath it.

Apparently, somewhere along the way, I crossed through an academic idea without realizing I had entered the neighborhood.

Ahem. I'm looking at you, Attention Is All You Need.

At least that one became famous enough that even a new AI-assisted developer eventually hears about it.

ReAct and I had apparently been working together without being formally introduced.

The Chicken, the Egg, and My Software Education

Before the AWS coursework, my mental model of an AI agent was mostly behavioral: agents go out and do things.

Useful, but incomplete.

Encountering ReAct through formal study gave me a way to look inside the "doing."

The original ReAct work describes reasoning traces and task-specific actions operating in an interleaved way: reasoning helps the model develop and update its plan, while actions let it interact with external sources and gather new information.

Suddenly I had better language for what I had already asked Verity Lex to do.

The model wasn't simply being released onto a court website with a tiny briefcase and an assignment. Its actions were part of a loop. The available tools constrained what it could do. The controller constrained how long it could continue. Observations changed what happened next. And my architecture drew a hard line between the part where model judgment was useful—discovery—and the part where I wanted deterministic behavior—scoring.

The code hadn't changed.

My understanding of my own code had.

And this is where my embarrassment runs into the chicken-and-egg problem.

I don't think that understanding would have happened, at least not now, without formal learning.

The AWS AI & ML Scholars program is explicitly designed to move learners from foundational AI education into deeper technical study. In 2026, AWS sponsored 100,000 learners in the Challenge phase, with the top 4,500 advancing to fully funded Udacity Nanodegrees. The Agent Developer track goes directly into reasoning patterns, RAG, tools, memory and APIs.

I am pursuing that formal education because I know there are gaps between what I have learned to build and what I can fully explain.

But without AI-assisted building, I don't know that I would have pursued this much software engineering knowledge in the first place.

That's the part I keep circling.

I didn't study ReAct, become fascinated by agent architecture, and then decide to build Verity Lex as an implementation exercise. I had questions. AI gave me enough leverage to turn some of those questions into software experiments, and building those experiments exposed the edges of what I understood.

Those jagged edges and sharp cliffs made me want to learn more.

That pursuit eventually put me in an Agentic Engineer Nanodegree staring at the word ReAct while realizing that part of the lesson was already sitting in a repository I had shipped.

Which one came first?

The building or the learning?

I'm increasingly not sure that's the right question.

Building Ahead of Understanding

I do feel silly about this, and I think that's a reasonable response.

There are consequences to deploying software you cannot explain, and "AI helped me build it" is not a waiver from understanding security, architecture, cost, reliability or what your application is actually doing. Being able to ship something and understanding what you've shipped are different accomplishments.

AI-assisted development can make the distance between those accomplishments deceptively easy to cross.

I've crossed it.

But my experience with ReAct has made me wonder whether the gap only tells one story.

Without the AWS Scholars program and my decision to pursue formal learning alongside building, I might never have recognized this particular gap at all. I could have continued describing Verity Lex accurately at the product level while never acquiring the vocabulary that allowed me to examine part of its architecture more precisely.

And without building Verity Lex first, ReAct might have arrived as another diagram in another lesson: reason, act, observe, repeat. Memorize it. Pass the quiz. Move along.

Instead, I had déjà vu.

I had a repository and architectural decisions I could revisit. I could ask why the model directs discovery but not scoring. I could look at the iteration limit and understand it as a boundary on agent autonomy rather than merely a number in a controller. I could see discovery, fetching and extraction not simply as functions, but as available actions inside a reasoning-and-acting loop.

Formal learning gave names and structure to things experience had already put in my hands.

Experience gave the formal learning somewhere to land.

Neither seems complete without the other.

That is a much less tidy education than the one I had imagined formal learning was supposed to provide.

Learn the concept. Practice it. Build something.

Mine sometimes runs forward, backward and sideways.

I ask a question. I build something. I discover what I built. I realize what I don't understand. I go study. I return to the code and see something different. Then, if things are going well, I leave with a better question than the one that got me there.

I don't know yet whether AI-assisted development has created a good learning model here.

I do know it has created a possible one, because I'm sprinting alongside it.

For now, I understand considerably more about Verity Lex than I did when I shipped it. I have better language for why the model-directed loop works the way it does, what family of ideas it belongs to, and where its autonomy begins and deliberately ends.

And I finally know the difference between React and ReAct.

React is still on the frontend.

ReAct is helping me understand what happens when an agent has to decide what to do next.

To Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan and Yuan Cao: I have now read your work. The name makes sense.

I apologize for questioning your judgment.

Mostly.

I'd still like to speak to the manager.

AI assisted. Human approved. Powered by NLP.