12.5 Building Agentic Applications

🎯 Core Goals

Demystify what an agentic application actually consists of.
Introduce the four core building blocks in plain language.
Present common design patterns as concepts, not code.
Frame everything as “what your team will build” — accessible to business decision-makers.

Agentic applications are built from four simple building blocks: a brain (the Agent), hands (Tools), memory (Sessions), and an engine (the Runner). You don’t need to be a developer to understand them — and understanding them helps you have much better conversations with your development team.

🧩 The Four Building Blocks

Every agentic application, from a simple chatbot to a complex multi-step workflow, is built from the same four pieces. Think of them like the organs of the system — each has a clear job.

🧠

The Agent (the Brain)

The LLM with its instructions. It reads input, thinks about what to do, and makes decisions. Its instructions — what you tell it about its role, rules, and personality — are its interface. Good instructions produce good behavior; vague instructions produce unpredictable behavior.

🔧

Tools (the Hands)

Functions the agent can call to interact with the real world: search the web, read a database, send an email, call an API, update a spreadsheet. Without tools, the agent can only talk. With tools, it can act.

📝

Sessions (the Memory)

How the agent remembers what happened in the current interaction. It knows what you said three messages ago, what tools it called, and what results came back. This is what makes multi-step conversations and workflows possible.

⚙️

The Runner (the Engine)

The orchestration layer that actually runs everything. It manages the loop: send input to the agent, the agent decides what to do, the runner executes tool calls, sends results back, and repeats until the task is complete.

The Four Building Blocks of Agentic Apps

Click a block to learn what it does. Then watch them work together.

Click a building block above to see details.

The key insight: the Agent (brain) is the only part that uses AI. Tools, Sessions, and the Runner are regular software engineering. This means most of the system is predictable and testable — only the decision-making layer involves the unpredictability of an LLM.

🏗️ Common Design Patterns

When developers build agentic applications, they typically reach for one of three well-established patterns. Understanding these helps you evaluate proposals and ask better questions.

A. Delegation (Specialists and Orchestrators)

Instead of building one giant agent that handles everything, you create specialist agents — each an expert in one area — and an orchestrator that knows who to call.

Analogy: A project manager doesn't write code, design graphics, AND handle legal reviews. They know which team member to call for each task.

Example: A customer service orchestrator receives all incoming requests. It routes billing questions to a Billing Agent (which has access to the payment system), technical issues to a Tech Support Agent (which can check system status), and shipping questions to a Logistics Agent (which can track packages). Each specialist is small, focused, and accurate.

Why this works better than one big agent: Small, specialized agents are more accurate and less likely to make mistakes than one massive agent trying to handle every possible scenario.

B. The Router Pattern

A router agent sits at the front door. Its only job is to figure out what kind of request this is and pass it to the right worker. It doesn’t do the actual work — it just sorts.

Analogy: A hospital triage nurse assesses each patient and sends them to the right department. The nurse doesn't treat the patient — but without good triage, the system breaks down.

Example: A customer writes in. The router determines: is this about billing, technical support, or a general question? Then it hands the conversation to the appropriate specialist. The classification step is fast and cheap; the specialized handling is where the real work happens.

C. The Self-Correction Loop

Instead of delivering its first answer and stopping, the agent checks its own work and tries again if the result isn’t good enough.

Analogy: A student who solves a math problem, verifies the answer, and reworks it if it's wrong. The checking step is what separates a careful worker from a sloppy one.

Example: An agent drafts a customer response, then a "quality checker" reviews it against company guidelines. If it fails the check, the agent revises and resubmits. This loop continues until the response passes — or gets flagged for human review after too many attempts.

This pattern is what makes agents feel “intelligent.” They recover from their own mistakes without human intervention — at least for the kinds of mistakes they’ve been taught to catch.

🏢 Multi-Agent Systems: Teams of Agents

Complex workflows don’t need one superhero agent — they need a team of agents working together, just like a human organization.

Think of it as an org chart for agents:

A manager agent coordinates the overall workflow
Specialist agents handle their domain (billing, logistics, content, etc.)
Review agents check quality before anything goes out the door
Escalation paths route difficult cases to humans

This mirrors how your own organization works. The better your human org chart is defined, the easier it is to design an agent org chart to match it.

The most important skill for building agentic applications isn’t coding — it’s clearly describing what the agent should do, what tools it needs, and what it should never do. This is why business expertise is essential to the process. Your developers build the system; your business knowledge defines what it should actually accomplish.

📝 Key Concepts

Four building blocks: Agent (brain), Tools (hands), Sessions (memory), Runner (engine).
Only the Agent uses AI — the rest is predictable software engineering.
Delegation pattern — specialist agents coordinated by an orchestrator, not one giant agent.
Router pattern — classify first, then hand off to the right worker.
Self-correction loop — agents that check and improve their own work.
Multi-agent = team of agents — mirrors your organization structure.
Business expertise drives agent design — clear instructions matter more than code.