A while back, I built a simple turn-based Hangman game where two LLM agents play against each other, both guessing letters back and forth until the word is revealed or the game ends. I wasn't trying to build an "agentic" system; I just wanted a practice project for my AI exam.
Surprisingly, agentic behavior started emerging on its own: The two agents alternated turns seamlessly by guessing and updating the game state. It felt like natural multi-agent collaboration. Instead of doing free-text guesses, they called a clean GuessLetter() tool/method, keeping outputs parsable and error-free. For persistence, the active agent wrote the full updated game state (revealed letters, misses, attempts left) directly into the chat history after each turn. The next agent simply read the context. Interestingly, when I tried fetching the state via a separate GetGameState() tool call instead, the agent sometimes got confused and returned empty or hesitant responses. Sticking to chat history made everything reliable and intuitive, the agents "knew" what to do next without extra prompting.
During testing, I noticed something interesting: the agents would sometimes start self-critiquing their guesses mid-response or reasoning aloud before committing ("Hmm, vowels are mostly gone... maybe S is better?"). It created longer, hedgy outputs that broke the crisp turn structure. To fix it, I added a strict line to the prompt: "Pass the result from GuessLetter() EXACTLY to the chat message." That forced clean, single-action outputs and restored smooth flow.
Later, I came across ByteByteGo's article "Top AI Agentic Workflow Patterns" (Dec 2025), outlining five essentials: Reflection, Tool Use, ReAct, Planning, and Multi-Agent Collaboration.
I recognized two patterns in the game: Multi-Agent for the turn-based teamwork and Tool Use for the structured guesses. In addition the game uses basic external memory via the chat state, which isn't one of ByteByteGo's essential patterns. Planning wasn't necessary (one-letter guesses are trivial). But reading the descriptions, I realized what I'd seen in testing was emergent ReAct (alternating reasoning with action) and Reflection (self-critique and revision), behaviors the model was doing on its own, likely from its training data and capabilities. Suppressing them deliberately prevented the hedging and kept the game playable.
The result: reliable turns instead of stalled agents.
Moral: Agentic workflows can emerge naturally even in tiny exam-prep projects and sometimes the smartest choice is to hold certain patterns back just to make it actually work.
Anyone else seeing spontaneous ReAct/Reflection in local models or dealing with unresponsive agents in multi-agent setups?
Full article for reference: Top AI Agentic Workflow Patterns
