Choosing Reasoning Patterns for Problem Solving

Introduction

In our last lesson, we established the fundamental mechanism of agentic action: how an agent uses a structured data protocol to request the execution of an external tool. You now understand that the LLM decides on an action, and the orchestration layer executes it.

However, a single tool call is just one step. Complex problems, like the underwriting analysis or research synthesis you're interested in, require a sequence of steps—a plan. This brings us to a crucial architectural question: how does an agent formulate and execute a multi-step plan?

This lesson addresses that question. Our learning outcome is to be able to select appropriate reasoning patterns (e.g., ReAct, Chain-of-Thought, Reflection) for given problem types. These patterns are the cognitive frameworks that enable an agent to decompose a complex goal into a sequence of thoughts and actions. Mastering them is essential for designing effective, reliable, and cost-efficient agentic systems.

From Static Prompts to Dynamic Reasoning

First, let's formalize what a "reasoning pattern" is. In a conventional LLM application, you provide a static prompt and receive a single output. Reasoning patterns, by contrast, are inference-time frameworks that orchestrate an iterative process. At each step, the agent might generate an intermediate thought, call a tool, and then incorporate the result into its next decision.

This approach is a form of test-time scaling—a set of techniques that improve the performance of a pre-trained LLM by using more computation at inference time to structure its reasoning process. Instead of just asking for an answer, you're asking the model to "show its work."

A Taxonomy of Core Reasoning Patterns

While many patterns exist, we will focus on a few foundational ones that form the building blocks for more complex agent designs. The paper you just read provides a helpful classification in its Table I, which we will use as a guide.

1. Chain-of-Thought (CoT): Structuring Internal Reasoning

Chain-of-Thought is the simplest and most fundamental reasoning pattern. It prompts the LLM to break down a problem into a sequence of intermediate, logical steps before arriving at a final conclusion. It doesn't use external tools; its entire purpose is to make the model's internal reasoning process more explicit and reliable.

• Core Concept: Sequential, step-by-step logical deduction.
• Analogy: A financial analyst writing out each step of a valuation calculation, rather than just stating the final number. This reduces errors and makes the process auditable.
• When to Use: Problems that can be solved with information already known to the model and benefit from structured, step-by-step logic. This includes math problems, logic puzzles, and summarizing complex text.

The AWS blog post on agentic patterns in finance maps this concept to a Workflow Pattern, which is ideal for processes with clear dependencies and a required information flow, such as AML/KYC compliance or claims adjudication.

2. ReAct (Reason + Act): The Workhorse of Agentic AI

ReAct is arguably the most important pattern for building capable agents. It extends CoT by interleaving reasoning steps (Thoughts) with actions that interact with the external world (Actions, i.e., tool use). The agent observes the outcome of its action and uses that new information to inform its next thought.

• Core Concept: An iterative loop of Thought -> Act -> Observation -> Thought...
• Analogy: A consultant tasked with a market analysis. They don't know all the answers upfront. Their process is:
  1. Thought: "I need to understand the current market size."
  2. Act: Query a market research database (tool use).
  3. Observation: Receive the market size data.
  4. Thought: "Given this size, who are the key competitors? I need to find a list."
  5. Act: Perform a web search (tool use).
     ...and so on, until the final report is complete.
• When to Use: Almost any task that requires gathering information or taking actions in an external environment to solve a problem. This is the default pattern for research, planning, and interacting with APIs.

3. Reflection: Self-Critique for Higher Quality

While ReAct is powerful, it can sometimes get stuck in a loop or produce a suboptimal result. The Reflection pattern adds a layer of self-evaluation. After generating a plan or completing a task, a "critic" component (often another LLM call with a specific prompt) assesses the work against the initial goal and a set of quality criteria. This evaluation provides feedback to the original agent, which then refines its output.

• Core Concept: An iterative cycle of Attempt -> Evaluate -> Refine.
• Analogy: The legal principle of a two-person integrity rule. One lawyer drafts a document (the "actor"), and a second lawyer reviews it for errors and omissions (the "reflector"). The first lawyer then incorporates the feedback to produce a more robust final version.
• When to Use: Complex tasks where the first draft is unlikely to be perfect and quality is paramount. This includes code generation, writing long-form reports, or generating complex financial models. The trade-off is higher accuracy for increased latency and cost.

The diagram above also illustrates the Reflexion pattern (right side), showing its meta-cognitive loop of Reason -> Improve -> Reflect. The AWS blog refers to this as a Loop Pattern, where iterative cycles allow the system to self-improve until a quality threshold is met, useful for optimizing trading strategies or credit scoring models.

A Framework for Selecting the Right Pattern

As an architect, your role is to choose the right tool for the job. The choice of reasoning pattern is a critical trade-off between task performance, cost, and latency.

Here is a decision framework to guide your selection:

The academic paper LINK quantifies these trade-offs. Its analysis in Figure 13 (Section V-A) shows that as you move from simpler patterns (like ReAct) to more complex ones (like Reflexion and Tree Search), accuracy generally increases, but so does latency, often with diminishing returns. For a business executive, this is a familiar Pareto frontier analysis: you must decide how much you're willing to pay in cost and time for marginal gains in accuracy.

Conclusion

You now have a framework for thinking about and selecting the appropriate reasoning pattern for an AI agent. This moves you beyond simply enabling tool use to architecting how an agent thinks.

Key Takeaways:

• Reasoning patterns are structured, iterative methods for problem decomposition that improve an LLM's performance at inference time.
• Chain-of-Thought (CoT) is for structured internal reasoning without external tools.
• ReAct is the fundamental pattern for dynamic tasks that require interleaving thought and action (tool use).
• Reflection adds a self-critique loop to improve the quality of complex or creative outputs.
• The choice of pattern is a critical architectural decision, balancing task complexity, required accuracy, and acceptable cost and latency.

Preview of the Next Lesson:

We've focused on how a single agent can formulate a plan. But some problems are too large or complex for any single agent, no matter how sophisticated its reasoning pattern. What if you need to model the interactions between different departments in your bank—underwriting, risk, and compliance? This requires a team of agents.

In our next lesson, we will explore multi-agent architectures. We will examine patterns like hierarchical and collaborative systems, where specialized agents work together to achieve a common goal. This will directly build on some of the more advanced graph and swarm patterns mentioned in today's resources.