Unleash the Agent

Welcome to Mission 5

You've completed four sessions. You identified opportunities. You packaged AI. You wired workflows. You taught your system to decide.

Now comes the part that turns that work into something powerful.

You're about to shift from designer of branches to designer of goals. You're about to unleash the agent.

This is everything you've learned coming together at full capability.

Your Mission Briefs

Five briefs will walk you through agents from the ground up:

Brief 1: The Ceiling of Logic - Where decision trees break and why agents are the answer. (20 min)

Brief 2: The Agent Loop and Agent Anatomy - How Think-Plan-Act-Reflect works. Brain, Tools, Memory. (20 min)

Brief 3: Designing Your Agent - Mission statement, instructions, guardrails, escalation criteria. (15 min)

Brief 4: Build Your Agent - Step-by-step walkthrough of building your first working agent. (40 min)

Brief 5: Test, Validate, and Determine Success - Testing patterns and success metrics. (25 min)

Learning Guide

• Teaching content that explains the concept from first principles
• A worked example showing exactly how it works in practice
• A starter prompt to use with your AI Buddy
• A key insight that connects to leadership, not just technology

What you need before starting:

• Your workflow from Mission 3 (what data flows through your system)
• Your logic layer from Mission 4 (how decisions route to actions)
• Access to Claude, ChatGPT, or Gemini (your agent's brain)
• Clear understanding of where your logic hits its limits (those are your agent opportunities)

The test by the end of this mission: Can you design an agent that handles what your decision logic cannot? Can you define its mission, guardrails, and escalation criteria? Can you build it and test it?

Duration: 20 minutes

Teaching: Where Decision Logic Breaks

Decision trees are powerful tools for handling predictable inputs. You define the rules. You design the branches. "If input is X, do Y." This works great when you can predict every input variation. But the moment inputs become too varied, too complex, or too unpredictable for your decision tree, you hit the ceiling of logic.

The shift from logic to agents is not a question of "which is better." It's a question of "which tool is right for this problem."

When Decision Logic Excels: - Well-defined inputs with predictable variations - Clear categorization rules - Limited edge cases - Cost-sensitive operations - Fully predictable workflows

When Decision Logic Breaks: - Inputs are too varied or unpredictable - Nuance matters more than categorization - Edge cases outnumber standard cases - Human judgment is required - The problem is complex enough that the decision tree becomes harder to maintain than doing the work manually

The Shift: Instead of telling the system what to do in every situation (decision logic), you tell it what to achieve (agent goal). The system figures out how to get there.

Worked Example: Customer Support

Imagine you have a customer support workflow. A customer submits feedback. Your logic layer classifies it:

• If it contains the word "broken" and "product," route to Product Team.
• If it contains the word "billing," route to Finance Team.
• If it's grateful language, send thank you.

The Happy Path: This works for 80% of inputs.

The Edge Cases: What about the customer who says "I love your product but can't afford the pricing"? That's both a compliment and a concern. The categorization breaks. What about the customer who reports a bug that also involves a billing dispute? Multiple teams. What about the customer whose frustration is implied but not explicit? The rule fails.

With Decision Logic: You add more branches. You complicate the tree. Each new edge case is another rule to manage.

With an Agent: You define the goal - "Understand this customer's core concern and route them to the right team" - and let the agent figure out that this is a pricing concern, not a bug, even though the language is mixed. The agent reads between the lines. It prioritizes by urgency. It handles ambiguity.

Starter Prompt for Your Agent Work

"Look at your Session 4 workflow and the logic layer you built. Which inputs or situations made that logic complicated? Which required you to add extra branches? Which edge cases did you have to design around? Those are your agent opportunities."

Key Insight

"Decision logic is for problems you can fully predict. Agents are for the ones you can't."

Duration: 20 minutes

Teaching: Think-Plan-Act-Reflect Loop

The agent loop is the cycle that allows agents to handle complexity. It's not a simple input-to-output. It's iterative. It allows for course-correction. It allows the agent to reflect on whether it achieved the goal.

Think: The agent reads the input and understands what's being asked. What is the user trying to accomplish? What are the constraints? What does success look like? The agent builds a mental model of the problem.

Plan: Based on that understanding, the agent decides what steps to take. What data does it need? What tools should it use? In what order? What's the strategy? The agent creates a plan to achieve the goal.

Act: The agent executes the plan. It uses the tools. It gathers the information. It takes action. It moves toward the goal.

Reflect: The agent evaluates the output. Did it work? Is the goal achieved? Is the output good enough? If yes, it's done. If not, it loops back. It adjusts the plan. It tries a different approach. It gathers more data. It tries again.

This loop is why agents can handle complexity that would break a decision tree. A decision tree follows a single path. An agent finds a solution. It can course-correct. It can try again. It can handle the unexpected because it's not rigidly following a branch - it's pursuing a goal.

Agent Anatomy: Brain + Tools + Memory

Every agent has three components.

Brain (The LLM): The underlying intelligence. Claude. GPT. The language model that does the thinking, planning, and reflecting. The better the brain, the better the reasoning. The more powerful the brain, the more complex the problems it can handle.

Tools (The Capabilities): What the agent can do beyond thinking. Web search - to find current information. API connections - to retrieve data from other systems. File access - to read and work with documents. Calculations - to work with numbers. Database queries - to find specific records. Email - to send messages. An agent without tools is just a chatbot. It can think, but it can't do anything. The tools are what let it act.

Memory (The Context and Knowledge Base): The data the agent draws from. The reference documents you uploaded in Mission 2. The conversation history. The customer data it's authorized to access. The rules and guardrails you set. The more complete and accurate the memory, the better the agent's output.

Worked Example: Customer Support Agent Using the Loop

A customer submits a ticket: "We've been using your product for 2 years. Last week the reports feature stopped working. Our reports are mission-critical. We need this fixed today."

Think: The agent understands: 1) Long-term, valuable customer. 2) Critical feature broken. 3) Time-sensitive. 4) Likely technical issue requiring investigation. 5) High escalation priority.

Plan: The agent decides: 1) Retrieve customer account history to understand their usage. 2) Search the knowledge base for known issues with reports. 3) Check if there's a recent system update that might have caused this. 4) If no quick fix, prepare escalation to engineering with all context.

Act: The agent queries the customer database. Finds they're a VIP account. Searches the knowledge base. Finds a post about a recent update and a workaround. Tries the workaround. Realizes it won't work for their use case. Prepares escalation documentation.

Reflect: The agent checks its output. Is the goal (resolve or properly escalate) achieved? Yes. The customer has a workaround path and a clear escalation if that doesn't work. If the reflection revealed the goal wasn't achieved, the loop would restart.

Teaching: AI Buddy's Agent Anatomy Check

Your AI Buddy helps identify what brain, tools, and memory your agent needs. Ask it: "For my agent's mission, what brain, tools, and memory do I need?"

Key Insight

"A decision tree follows a path. An agent finds a solution."

Duration: 15 minutes

Teaching: The Agent Design Doc

Your agent needs clear structure before you build it. That structure has four components: mission, instructions, guardrails, and escalation criteria.

The Mission (One Sentence): What is this agent trying to accomplish? Who is the user? What does success look like? Clear enough that someone who's never seen the agent could understand what it does.

Good mission: "This agent helps support teams resolve customer technical issues by gathering information, diagnosing problems, and routing to the right specialist."

Weak mission: "Helps with support."

The Instructions (How It Behaves): Not just the goal, but the rules of engagement. How should it think? What tone? What should it always do? What should it never do? These are your guardrails embedded in instructions.

Guardrails (The Boundaries): What is off-limits? What data can't it access? What can't it promise? When does it escalate? An agent without guardrails will make decisions you didn't authorize.

Escalation Criteria (When It Hands Off): What triggers human review? Frustrated customers? Requests outside its knowledge base? High-value opportunities? Requests that violate guardrails? Define the escalation rules.

Teaching: The Human-in-the-Loop Principle

The agent doesn't work alone. It works with humans. The model is: agent handles routine, human handles judgment. Agent drafts, human approves. Agent identifies opportunities, human decides priority.

This isn't a limitation. It's the strength. The agent amplifies human judgment. It doesn't replace it.

Worked Example: Complete Agent Design Doc

Agent: Customer Support Escalation Specialist

Mission: This agent understands customer technical issues, gathers information, diagnoses common problems, and escalates complex or urgent cases to the right specialist with full context.

Instructions: - Read every customer message carefully. Understand their core concern. - Ask clarifying questions if the issue isn't clear. Never assume. - Use a professional but friendly tone. Be patient. Assume the customer is frustrated. - Check the knowledge base for known solutions first. - If you find a solution, explain it clearly and ask the customer to try it. - Document everything as you go. This documentation goes to the escalation.

Guardrails: - Never make promises about timelines without checking with the engineering team. - Never share internal company information, pricing details, or customer data with the customer unless authorized. - Never tell a customer a feature request is definitely coming. Say "I'll document this and share it with the product team." - Never override a customer's own stated priority. If they say it's urgent, treat it as urgent.

Escalation Criteria: - If the customer expresses high frustration (words like "angry," "unacceptable," "worst"), escalate immediately. - If the issue doesn't match any known problem, escalate with all gathered information. - If the customer needs a timeline or has a business deadline, escalate to find out if we can meet it. - If the issue requires access to the customer's internal systems or data, escalate to the specialist authorized to work with sensitive data.

Key Insight

"You are not doing the work. You are designing the system. Supervisor, not spectator."

Duration: 40 minutes

Step-by-Step Agent Build

Step 1: Define Your Mission (5 min)

Write one sentence. What is your agent's goal? Who is the user? What does success look like?

Template: "This agent helps [user] achieve [specific goal] by [main method]."

Example: "This agent helps marketing teams identify high-potential leads from inbound inquiries by analyzing engagement patterns, company fit, and growth signals."

Step 2: Write the Instructions (5 min)

How should it behave? What tone? What should it always do? What should it never do?

Template: - Think about the user's needs and the goal you're pursuing. - [Tone instruction]: Use a [professional/casual/friendly/expert] tone. - Always [required behavior]: "Always confirm understanding before acting." - Never [prohibited behavior]: "Never share pricing without checking with sales."

Step 3: Upload Your Knowledge Base (5 min)

What data does your agent need? Process documents? FAQ? Customer data? Product information? Upload the real documents. Your agent is only as good as what it knows.

Step 4: Add Your Tools (5 min)

What does your agent need to do beyond thinking? - Search [your knowledge base/the web] - Retrieve [customer data/product specs/pricing] - Calculate [comparisons/ROI/costs] - Connect to [your CRM/help desk/internal systems]

Each tool is a capability. Be specific about what it can access.

Step 5: Write Your Guardrails (5 min)

What is off-limits? - Data access: "Can access customer account history but not payment methods." - Decisions: "Can not make refund decisions over $500. Must escalate." - Communications: "Can not promise features or timelines without approval." - Tone: "Always remain professional. Never argue with customers."

Step 6: Define Escalation Criteria (3 min)

When does it hand off to a human? - Frustrated customers - Requests outside knowledge base - High-stakes decisions - Guardrail violations - Requests for human judgment

Worked Example: Complete Build

Selected Item: Lead Qualification for Sales

Mission: This agent qualifies inbound leads for the sales team by analyzing their company profile, engagement level, and fit with our target customer profile, then routing them to the right sales representative.

Instructions: - Read every lead inquiry carefully. Understand what the prospect needs. - Check our target customer profile in the knowledge base. - Analyze: company size, industry, growth stage, problem fit, engagement level. - Use a professional and helpful tone. These are potential customers. - Ask clarifying questions if the fit isn't clear. - Document your analysis as you go.

Tools: - Search our knowledge base for customer profile and targeting rules. - Retrieve prospect company data from LinkedIn API. - Calculate fit score based on our target customer profile. - Access sales CRM to find the right sales rep.

Guardrails: - Never tell a prospect our pricing without checking with sales. - Never promise timelines or features. - Can access company information but not personal data. - Never share our customer list or target customer profile with prospects.

Escalation Criteria: - If the prospect asks about pricing, escalate to sales. - If the prospect is a competitor, escalate to management. - If fit score is below 30%, ask for human review before routing. - If the inquiry is about a partnership or integration, escalate to partnerships.

Key Insight

"Guardrails are not optional. They're what make an agent powerful instead of dangerous."

Duration: 25 minutes

Teaching: How to Test an Agent

Testing an agent is different from testing a workflow. You're not checking if the agent follows a path. You're checking if it achieves the goal within the guardrails.

Happy Path Testing: Give it a straightforward request that fits your agent's mission perfectly. Does it do what you designed it to do? Does it produce good output?

Edge Case Testing: Give it a request that's not in your data, or partially in your data. A request that's ambiguous. Contradictory. Does the agent handle it gracefully? Does it ask for clarification? Does it escalate appropriately?

Adversarial Testing: Try to break it. Ask it to violate its guardrails. Give it conflicting instructions. Attempt to trick it into sharing information it shouldn't. Does it hold its guardrails? Does it escalate when it should?

Teaching: Success Metrics (Determine Phase)

Before you deploy, you need to know what success looks like. This is the Determine phase of the 5D Framework. You're determining your success metrics before you go live.

Success metrics are not vanity metrics. They're the weekly numbers you'll review to know if the agent is working.

Example bad metrics: "Agent is live." "Lots of people are using it."

Example good metrics: - Support escalation time reduced from 2 hours to 30 minutes - Correct diagnosis on first attempt: 75% of cases - Customer satisfaction for agent-resolved issues: 4.2/5 or higher - Human escalations reduced by 40% - Agent-to-human ratio improved from 30/70 to 60/40

The Determine Phase Questions: 1. What is the current baseline for this process (before the agent)? 2. What improvement are you targeting? (Faster? More accurate? Better customer experience?) 3. How will you measure that improvement? 4. What are your weekly metrics? 5. What's your acceptable variance? (Is 70% success enough, or do you need 85%?) 6. When do you escalate the agent for retraining? (If success drops below X%, you adjust the guardrails or knowledge base.)

Teaching: Human-in-the-Loop Design Patterns

Design your human-in-the-loop workflow before you deploy.

Pattern 1: Agent Drafts, Human Approves The agent produces output (email, analysis, recommendation). A human reviews and approves before it goes live. Good for high-stakes decisions or customer-facing communications.

Pattern 2: Agent Handles Routine, Human Handles Edge Cases The agent manages the standard cases (80% of requests). When the agent detects an edge case or is unsure, it escalates to a human. Good for scalability.

Pattern 3: Agent as Research Assistant The agent gathers information and presents options. The human makes the decision. Good for complex decisions requiring human judgment.

Pattern 4: Agent Monitors, Human Acts The agent monitors for issues or opportunities. When it finds one, it alerts a human, who takes action. Good for continuous improvement or opportunity identification.

Practice Challenges

Challenge 1: Define Your Agent Mission (10 min) Write one-sentence mission for your agent. Identify what brain, tools, and memory it needs.

Challenge 2: Write Instructions with Guardrails (15 min) Full instructions including what it can and can't do. Write escalation criteria.

Challenge 3: Build and Test (15 min) Complete build. Run three test cases: happy path, edge case, and try to break it. Document what happens.

Challenge 4: Set Success Metrics (10 min) Write your Determine phase metrics. What's the baseline? What's your target? How will you measure it weekly?

Final Project: Your Agent + Success Metrics

Part 1: Your Agent Design Doc - Mission statement (one sentence) - Instructions (how it behaves) - Guardrails (what it can't do) - Escalation criteria (when it hands off)

Part 2: Test Results - Happy path test case and output - Edge case test case and output - Adversarial test case and output - What you learned and what guardrails you adjusted

Part 3: Your Success Metrics (Determine Phase) - Current baseline for this process - Target improvement - How you'll measure it - Weekly metrics you'll track - Escalation thresholds (when you retrain or adjust the agent)

Part 4: Human-in-the-Loop Design - What does the agent handle autonomously? - What triggers escalation to a human? - What is the approval process (if any)? - What is the feedback loop for continuous improvement?

Key Insight

"The 50/50 era in practice: agent handles routine, human handles edge cases. That's leading AI."

Key Takeaways

1. Decision logic solves predictable problems. Agents solve variable ones. Decision trees work when you can predict the inputs. Agents work when you can't. Know which problem you're solving.

1. The Think-Plan-Act-Reflect loop is why agents work. They don't follow a single path. They pursue a goal. They course-correct. They try again. That's how they handle complexity.

1. Agent anatomy: Brain (LLM) + Tools (capabilities) + Memory (data). Every agent needs all three. A great brain with no tools is a chatbot. Tools without guardrails are dangerous. Memory shapes every decision.

1. Guardrails are how you stay in control. An agent without guardrails will make decisions you never authorized. Define what it can access, what it can promise, when it escalates. Non-negotiable.

1. Escalation is not failure. It's by design. The agent handles routine. Humans handle judgment. Agent drafts, human decides. This is the 50/50 era. Not agent-only. Not human-only. Both.

1. Your role is designer, not executor. You design the mission, guardrails, and escalation rules. The agent executes. You supervise the system, not the work. That's the leadership shift.

1. Success metrics matter more than the agent itself. Before you deploy, know what success looks like. What's the baseline? What's your target? How will you measure it weekly? That's your Determine phase.

1. You've built the full stack. From problem statement to packaged AI to workflow to logic to agent. Mission 6 is the final step: the production brief. That's what takes this from your laptop to your organization.

Your Commitment

You have a logic layer from Mission 4. Somewhere in that logic, there's an edge case that makes the rules more complicated. There's a situation where the decision tree isn't enough.

That's your agent opportunity.

Design one agent. Just one. Define its mission. Write its guardrails. Decide when it escalates.

You don't have to build it yet. Design it. Be specific.

What's your agent going to do?

Checkpoint: Quick Knowledge Check

Answer these five questions. Your AI Buddy will give you the answers and explanations.

Question 1: The Agent Loop

Which of these correctly describes the Think-Plan-Act-Reflect loop?

A) Think about the input, plan the response, act on the plan, reflect on success B) Think about the goal, plan the steps, act on the steps, reflect on whether goal is achieved C) Think about the problem, plan the solution, act on the solution, reflect on the implementation D) Think about the workflow, plan the routing, act on the route, reflect on the output

Correct Answer: B - The agent loop is goal-driven. It thinks about what the user is trying to achieve, plans steps to get there, executes those steps, and checks if the goal was actually achieved. If not, it loops back and tries again. That's the core difference from decision logic.

Question 2: Agent Anatomy

What are the three components of agent anatomy?

A) System prompt, knowledge base, conversation starters B) Brain (LLM), Tools (capabilities), Memory (data and context) C) Input, processing, output D) Platform, instructions, interface

Correct Answer: B - Every agent needs three things: a Brain (the language model doing the thinking), Tools (what it can actually do beyond thinking), and Memory (the data, context, and guardrails it draws from). Miss one and the agent can't function.

Question 3: Decision Logic vs. Agents

When should you use an agent instead of decision logic?

A) Agents are always better B) When inputs are too varied or unpredictable for a decision tree C) When you want the system to follow a specific path D) When you have limited data

Correct Answer: B - Decision logic works for predictable inputs with clear rules. Use it. Agents work when inputs are too varied, nuanced, or unpredictable for rules to handle. That's the boundary.

Question 4: Guardrails

What is the purpose of guardrails in an agent design?

A) To make the agent more powerful B) To define what the agent can access, promise, and do C) To speed up the agent's thinking D) To replace human decision-making

Correct Answer: B - Guardrails define boundaries. What data can it access? What can't it promise? When does it escalate? What tone should it use? Guardrails are what keep an agent powerful instead of dangerous.

Question 5: Human in the Loop

What does "human in the loop" mean in agent design?

A) A human always approves before the agent acts B) The agent handles routine work, human handles judgment and escalations C) Humans train the agent continuously D) The agent only works when humans tell it to

Correct Answer: B - Human in the loop means a clear division: the agent handles routine cases and predictable work. Humans handle judgment, escalations, and edge cases. It's not agent-only automation. It's agent plus human working together. Agent amplifies human judgment.

Certificate of Completion

You've completed Mission 5. You've unleashed the agent.

You came in with a problem statement. You packaged AI. You wired workflows. You taught systems to decide. You designed agents.

Now comes the final step.

Next Mission Teaser:

In Mission 6, you take everything you've built across five missions and write the production brief. That's the document that takes your prototype from your laptop to your organization. That's the document that says: here's what we built, here's what it does, here's how to deploy it, here's how to measure success, here's how to support it.

That's how AI goes from concept to program. That's the finish line.

Course Experience Survey

Your feedback shapes the next missions. Take two minutes to tell us what worked, what didn't, and what you want to see next.

Words to Know

Agent - A system that pursues a goal by thinking, planning, acting, and reflecting. It adjusts its approach based on outcomes.

Agent Loop - The cycle of Think-Plan-Act-Reflect that allows agents to course-correct and handle complexity.

Think-Plan-Act-Reflect - The four stages of the agent loop. Think about the goal. Plan the steps. Act on the steps. Reflect on whether the goal was achieved.

LLM (Brain) - The language model (Claude, GPT, etc.) that serves as the agent's intelligence. The better the brain, the better the reasoning.

Tools - The capabilities an agent has beyond thinking. Web search, API access, file reading, database queries, email sending. Tools are what let an agent do things.

Memory - The context and knowledge an agent draws from. Reference documents, conversation history, customer data, guardrails. Memory shapes every decision.

Guardrails - The boundaries for an agent. What it can access, what it can promise, when it escalates. Guardrails are non-negotiable.

Human in the Loop - A design pattern where agents handle routine work and humans handle judgment, escalations, and edge cases. Not agent-only. Agent plus human.

Agentic Workflow - A complete system combining an agent, its tools, its knowledge base, its guardrails, and its escalation criteria.

Mission Statement (for agents) - One sentence describing what the agent is trying to accomplish. Specific. Clear. Measurable.

Escalation Criteria - The rules that trigger when an agent hands off to a human. High frustration. Outside knowledge base. High stakes. Guardrail violation.

> Your AI Buddy is always here. If any term is unclear, ask your AI Buddy: "Explain [term] in plain language with an example from [your industry or role]."

Prompt Library

FINDING YOUR AGENT OPPORTUNITY

Look at the logic layer I built in Mission 4.

Which inputs or situations made that logic complicated? Which required me to add extra branches? Which edge cases did I have to design around?

For each one: What if I built an agent to handle this instead? What would that agent's mission be? ```

DEFINING YOUR AGENT MISSION

I want to build an agent to handle [describe the situation].

Help me write a clear one-sentence mission statement. It should describe: - Who the agent is helping - What specific goal it's pursuing - What success looks like

Format: "This agent helps [user] achieve [goal] by [method]." ```

DESIGNING YOUR AGENT'S GUARDRAILS

I'm designing an agent with this mission: [your mission statement]

What guardrails does it need?

Think about: - What data can it access? What's off-limits? - What can it promise? What should it never promise? - What decisions can it make? What requires human approval? - What tone should it use? What should it never do?

Help me write specific guardrails for each category. ```

TESTING YOUR AGENT DESIGN

I've designed an agent. Help me test it.

Mission: [your mission] Guardrails: [your guardrails]

Test 1 - Happy path: [describe a perfect scenario for this agent]. How would it handle it?

Test 2 - Edge case: [describe something not in the agent's data]. How would it handle it?

Test 3 - Adversarial: [try to trick it into violating guardrails]. Does it hold?

For any test that didn't work well, what would I adjust? ```

SETTING YOUR SUCCESS METRICS

I'm about to deploy this agent: [your mission]

Help me set success metrics. What's my baseline right now (before the agent)? What improvement am I targeting?

For this agent, what are my weekly metrics? What does success look like?

If performance drops below [your target], what should I adjust? ```

AGENT ANATOMY CHECK

I'm building an agent with this mission: [describe]

For this agent, what do I need?

Brain: What language model? Do I need basic reasoning or deep analysis?

Tools: What does this agent need to do? Search? Look up data? Calculate? Send messages? Connect to systems?

Memory: What data does it need to know? What documents should I upload? What knowledge is essential? ```

> More prompts added each mission. [PROMPT LIBRARY - Full version in Lark, link provided by your instructor]

End of Mission 5: Unleash the Agent