Agent Mastery Quiz
8 questions covering everything you've learned. Prove you understand agent fundamentals.
Course Recap
Before you take the quiz, let us walk through everything you have learned across three modules. Each module built on the last — from understanding what agents are, to building one, to shipping it safely.
Understanding what agents are, how they think, and why they are different from chatbots.
- ✓ Chatbot vs. agent — the autonomy spectrum
- ✓ The agent loop — perceive, think, act, observe, learn
- ✓ Tool calling — how agents interact with the real world
- ✓ Why tools turn text generators into action-takers
Designing your agent from the ground up — its brain, its tools, and its memory.
- ✓ System prompts — the 6 essential blocks
- ✓ Tool integration — JSON schemas, descriptions, routing
- ✓ Memory systems — short-term, long-term, and RAG
- ✓ Designing agents with a clear goal and focused tool set
Making your agent safe, reliable, and ready for real users in the real world.
- ✓ Error handling — try/catch, retries, fallback tools
- ✓ Guardrails — what your agent must never do
- ✓ Evaluation — the 5 dimensions and the 70+ threshold
- ✓ Deployment — monitoring, logging, and continuous improvement
The Agent Builder's Checklist
Every agent needs these seven things before it touches a real user. This is your pre-flight checklist. If any item is missing, your agent is not ready.
One sentence that defines exactly what your agent does and for whom. "This agent helps customer support reps find order information and process refunds." If you cannot say it in one sentence, the agent is too broad.
Start small. Two to four well-defined tools beat ten vague ones. Each tool needs a clear name, a precise description, and a JSON schema the model can understand. More tools means more decision points where the agent can choose wrong.
Your system prompt must include: Identity (who the agent is), Goal (what it is trying to do), Tools (what it can use and when), Memory (what to remember), Guardrails (what it must never do), and Output Format (how to structure responses). Missing any block creates blind spots.
Every agent needs at least one hard boundary it will never cross. "Never share another customer's data." "Never execute a refund over $500 without human approval." "Never generate medical advice." Guardrails are non-negotiable safety rules, not suggestions.
Decide what your agent remembers within a session (short-term: conversation history) and across sessions (long-term: user preferences, past interactions, learned patterns). An agent without long-term memory starts from zero every time. An agent that remembers everything wastes tokens and money. Find the balance.
When a tool call fails — and it will — your agent needs a plan. Retry once with corrected parameters. If that fails, try a fallback tool. If all tools fail, tell the user what happened honestly and suggest an alternative. Never silently swallow errors. Never make up data to fill the gap.
Before deploying, score your agent on Accuracy (correct answers), Speed (response time under 10 seconds for simple queries), Reliability (consistent results, no crashes), Cost Efficiency (affordable per interaction), and User Satisfaction (people actually like using it). All five must score 70 or higher.
Common Agent Mistakes
These are the mistakes that trip up most first-time agent builders. They are easy to make and expensive to fix in production. Learn them here so you do not learn them from angry users.
When an agent has 15 tools available, it spends more time deciding which tool to use than actually helping the user. Every extra tool adds a decision branch. With 4 tools, the agent has 4 options per step. With 15, it has 15 — and the probability of choosing wrong goes up fast. Start with 2-4 tools. Only add more when you have data showing users need them.
An agent without guardrails is a liability. It might share private data, execute destructive operations, or follow adversarial prompts that trick it into bypassing its own instructions. Guardrails are not optional safety theater — they are the walls that keep your agent inside the sandbox. "But my agent is just a demo" is not an excuse. Demos become products faster than you think.
Shipping an agent without a test suite is like launching a rocket without checking the fuel gauge. It might work. It might also explode spectacularly in front of your users. Build at least 20 test cases covering happy paths, edge cases, ambiguous inputs, and adversarial prompts. Run them. Score them. Only deploy when all five dimensions hit 70+.
Accuracy is not the only thing that matters. If your agent takes 45 seconds to answer a simple question, users will leave before they see how smart it is. Target under 5 seconds for simple queries and under 30 seconds for complex multi-tool tasks. If you are over that, look into caching, parallel tool calls, or routing simple questions to faster models.
Your test suite passes. You deploy. Two weeks later, accuracy has dropped from 85% to 60% and nobody noticed. Why? User patterns changed, an API you depend on updated its response format, or the model drifted. Without production monitoring — logging every interaction, tracking error rates, reviewing failure cases weekly — you are flying blind. Pre-launch testing is the beginning, not the end.
Pre-Quiz Review
Make sure you can define each of these concepts before taking the quiz. If any term feels fuzzy, revisit the relevant lesson.
The continuous cycle that defines agent behavior: perceive the environment, think about what to do, act using tools, observe the result, and learn from the outcome. Repeats until the goal is met.
The mechanism that lets an agent interact with the real world. The model outputs a structured JSON request (function name + arguments), a runtime executes it, and the result feeds back into the conversation.
The instruction set that defines an agent's identity, goal, tools, memory behavior, guardrails, and output format. It is read before every interaction and shapes every decision the agent makes.
Hard boundaries the agent must never cross, regardless of user input. They protect against data leaks, destructive actions, and adversarial prompt injection. A guardrail is a rule, not a guideline.
When a tool fails, the agent tries alternatives before giving up. Retry with corrected parameters, try a fallback tool, and only escalate to the user if all options are exhausted. Never silently fail. Never fabricate data.
Short-term memory is the conversation history within a single session — it disappears when the session ends. Long-term memory persists across sessions using a database, letting the agent recall user preferences and past interactions.
Accuracy, Speed, Reliability, Cost Efficiency, and User Satisfaction. An agent must score 70+ on all five to be production-ready. One weak dimension can sink the entire user experience.
A chatbot responds to a single message and stops. An agent uses tools, maintains memory, and loops autonomously toward a goal. The difference is autonomy — an agent acts, observes, and adapts without waiting for the next human message.
Ready? The quiz below covers all three modules — 8 multiple-choice questions. You need to understand the agent loop, system prompt blocks, tool calling, memory, error handling, guardrails, and evaluation. Take your time. Good luck.
This lesson is for Pro members
Unlock all 520+ lessons across 52 courses with Academy Pro.
Already a member? Sign in to access your lessons.