Agentic AI Patterns

From Chatbot to Agent

So far, you've been working with LLMs as chatbots: you ask a question, the model responds. A back-and-forth. But what if the model could tackle a complex task on its own -- across multiple steps, using tools, and making decisions along the way?

That's exactly the leap from chatbot to AI agent. An agent is no longer a passive answer machine. It's a system that autonomously plans, acts, and learns from results -- in a loop, until the task is done.

What Makes an AI Agent?

An AI agent has three core capabilities that set it apart from a simple chatbot:

1. Thinking (Reasoning)

The agent analyzes the task and develops a plan. It leverages the LLM's reasoning to determine the next steps. This goes beyond a simple answer -- it's strategic thinking.

2. Acting

The agent can call tools: query APIs, read files, search databases, execute code. It doesn't limit itself to text -- it interacts with the real world.

3. Observing

After every action, the agent evaluates the result. Did the API call work? Is the information correct? Does the plan need adjusting? This feedback loop is what truly makes an agent intelligent.

Why Agents Matter Now

Three developments are making agentic AI mainstream in 2026:

• Better reasoning models -- Claude Opus 5, GPT-5.6 Sol, and Gemini 3.1 Pro can reliably plan complex, multi-step tasks
• Tool use / function calling -- LLMs can call external tools in a structured way, not just generate text
• Larger context windows -- With 1M+ tokens, agents can keep extensive tasks in context

Three Paths to the Goal

When planning a software project, you face a fundamental decision: How much of a role should AI play? There are three approaches — and none is inherently better:

1. You Build It Yourself — Traditional Development

The team implements traditionally: backend, API, frontend, tests, deployment. AI only assists in specific areas (Copilot, code reviews). Full control, but the highest time investment.

When it makes sense: Highly regulated systems (healthcare, finance), real-time requirements under 50ms, deterministic logic strictly required.

2. An Agent Builds for You — AI as Developer

You write a specification or agents.md, the agent builds code, tests, and infrastructure. You review and deploy. Hours instead of weeks.

When it makes sense: Clear requirements or spec available, standard patterns (REST APIs, CRUD), human-in-the-loop for review and deployment.

3. The Agent IS the Product — AI as End Product

The agent runs autonomously as part of your product: customer chatbot, support agent, monitoring system. Here you're not building with AI, but building from AI.

When it makes sense: Conversational use cases (support, consulting), automations that need to run 24/7, tasks requiring natural language processing.

What to Expect in This Module

• The ReAct Pattern -- The fundamental think-act-observe loop that nearly all agents use
• Tool Use & Function Calling -- How agents concretely interact with the outside world
• Plan-and-Execute -- How you can save 90% in costs using two models
• Guardrails & Reality Check -- Why agents can go wrong and how to prevent it

Let's get started -- with the pattern that ties everything together: ReAct.

Reflect

Agentic AI patterns give you a repertoire of architectural decisions -- from ReAct to Tool Use, Plan-and-Execute, and Guardrails. Choosing the right pattern for the right use case is a core competency. Let us start with the ReAct pattern.