Mission 5 — Key Terms

An AI system that uses the Think-Plan-Act-Reflect loop to pursue goals. Unlike a chatbot (which just responds to prompts), an agent observes a goal, plans how to achieve it, takes action using available tools, and reflects on whether the goal was achieved. If not, it loops back and tries again. Agents handle complexity that decision trees can't because they don't follow a single predetermined path

A workflow where an AI agent, not a decision tree, controls the logic. Instead of "if X, do Y," the agent is given a mission (goal) and uses its brain (LLM), tools (capabilities), and memory (context) to figure out how to achieve it. The agent decides the steps, adapts to unexpected inputs, and escalates to humans when needed. More flexible than decision logic but requires clear guardrails.

The cycle that allows agents to handle complexity. Think: the agent understands the input and goal. Plan: it decides what steps to take. Act: it executes those steps using available tools. Reflect: it evaluates whether the goal was achieved. If not, it loops back to Plan and tries again. This is why agents can handle variability and edge cases that would break a decision tree.

The three components every agent needs: Brain (the LLM), Tools (the capabilities), and Memory (the context and knowledge base). The brain does the thinking. The tools let it act. The memory gives it context. Your job as the AI Officer is to give the agent the right brain, the right tools, and the right memory for its mission.

The underlying intelligence of an agent. The large language model (Claude, GPT, Gemini) that does the thinking, planning, and reflecting. A better brain can handle more complex reasoning. A more powerful brain can tackle harder problems. The brain is what gives the agent intelligence.

The capabilities you give an agent beyond just 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. An agent without tools is just a chatbot. The tools are what let it act.

The context and knowledge base an agent draws from. The reference documents you uploaded. The conversation history. The customer data it's authorized to access. The rules and guardrails you set. The instructions on how to behave. The better and more complete the memory, the better the agent's output.

The boundaries you set for an agent. What it can't do. What data it can't access. When it should escalate to a human. What tone it should use. What it can't promise. Guardrails are how you control an agent without controlling every step it takes. An agent without guardrails will make decisions you didn't authorize. Guardrails transform an agent from a liability into a powerful tool.

The process of handing off a decision or task from an agent to a human. Agents should escalate when they encounter situations outside their guardrails, when the stakes are high, when they're unsure, or when human judgment is required. Escalation criteria should be defined as part of your agent design. Clear escalation rules are what make the 50/50 era work - agent handles routine, human handles ju

A workflow design pattern where AI (agent) and humans work together. Common patterns: agent drafts, human approves. Agent handles routine, human handles edge cases. Agent identifies opportunities, human decides priority. Agent monitors, human acts. The 50/50 era in practice. The agent doesn't replace the human. The agent amplifies human judgment and frees humans from routine work.

Your role as the AI Officer. You're not the doer - you're the supervisor. You don't do the work yourself. You design the system that does the work. You define the mission, set the guardrails, upload the data, connect the tools, set success metrics, and oversee the results. You supervise the system. You make the judgment calls. You make the final decisions. Supervisor, not spectator. Supervisor, no

The phase where you define success metrics before deployment. Before you go live with an agent, you determine what success looks like. What is the current baseline? What improvement are you targeting? How will you measure it weekly? What are your thresholds for retraining? What does success mean in numbers? Determine your metrics before you deploy.

The measurable indicators you track to know if your agent is working. Not vanity metrics like "it's live" but real numbers like: escalation time reduced by 40%, customer satisfaction improved to 4.2/5, successful diagnosis on first attempt reached 75%, human escalations reduced by 30%. Your success metrics are what you review weekly to know whether to keep the agent as-is, retrain it, or adjust it

The if/then logic layer you built in Session 4. Predictable. Cheap. Rigid. You design every branch. It works great for well-defined inputs and clear categorizations. But it breaks when inputs are too varied, too complex, or too unpredictable. Decision logic is not bad - it's just the right tool for some problems, not others.

AI systems that use the Think-Plan-Act-Reflect loop to pursue goals. Broader term for agent-based approaches. Agentic AI is not just responding to prompts - it's actively reasoning, planning, acting, and evaluating to achieve defined goals.

The specific instructions for how your agent should behave. What tone? What should it always do? What should it never do? How should it approach problems? These instructions embed your guardrails and are the operational rules the agent follows. Clear instructions are what make the difference between an agent that does what you want and an agent that does what you didn't expect.

The document you create in Session 6 that takes your prototype from your laptop to your organization. The specification. The guardrails. The success metrics. The documentation that tells an engineering team exactly what you built, how it works, how to maintain it, and what to do when it breaks. The production brief is how an idea becomes a program.

Routine: the standard work that fits your decision tree or agent mission. 80% of cases. The work the agent can handle autonomously. Edge cases: the situations that don't fit the standard path. The ones that require judgment. The 20% that needs human review. The 50/50 era divides work this way - agent handles routine, human handles edge cases.

Testing your agent by trying to break it or trick it. Give it conflicting instructions. Ask it to violate its guardrails. Try to get it to share information it shouldn't. Attack the logic. See where it fails. Adversarial testing is how you find gaps in your guardrails before your team depends on the agent.

Acting on its own, without human intervention. An agent can handle some tasks autonomously - the routine, predictable, low-stakes work within its guardrails. Other tasks require human approval or escalation. Autonomy is defined by the guardrails and escalation criteria you set, not by how smart the agent is.

When an agent attempts to do something it's not supposed to do or tries to cross a boundary you've set. Escalating before guardrail violations happen (clear escalation criteria) is better than discovering violations after they happen. Guardrail violations are what you're testing for in adversarial testing.

The process of giving your agent reference documents and data to work from. Session 2 taught you the importance of good data for packaged prompts. Same principle for agents. Your agent is only as good as what it knows. Upload complete, accurate, current documentation. FAQs. Process guides. Customer data (if authorized). Pricing. Product specs.

Connecting your agent to external systems and capabilities. APIs to your CRM. Database query access. File storage. Search. Email. Calculations. Each integration is a tool that lets your agent do something beyond just thinking. Tool integration is what transforms a chatbot into an agent.

The agent evaluating its own output. Did it achieve the goal? Is the output good enough? If not, it loops back and tries a different approach. Reflection is what allows agents to course-correct. A decision tree doesn't reflect - it just outputs. An agent reflects and improves.

The ability to handle varied inputs and unexpected situations without requiring a decision tree redesign. Agents are flexible because they can adapt their approach. Decision logic is rigid because it follows predetermined paths. Flexibility is the tradeoff for complexity and the need for guardrails.

The characteristic of a problem or input that makes decision logic insufficient. Too many variations. Too much nuance. Too much judgment required. Complex problems are where agents excel and decision trees fail. Complexity is not a problem for agents - it's what they're designed for.