Agentic AI — From Foundations to Advanced Systems

• Explain how an agent is different from a normal one-shot LLM call, and point out its four parts (model, tools, memory, loop) in an example.
• Set up a working Python + API setup and run a small model call safely (keys kept in .env).
• Decide when a problem needs an agent and when a simpler tool is better.

Set up your tools and run the test file. Then build a "pretend agent": a script where the model says an action in words, and you (the human) do it and paste the result back. This lets you feel how the loop works before you automate it.

• Build tool calling: make a tool, show it to the model, read the call, run it, and return the result.
• Explain how a tool call works (request and reply), and fix a broken tool call.
• Build an agent with two tools that picks the right one for each request.

Build a small agent with two tools (for example, a calculator and a time or weather tool). Connect the full loop: user → model → tool call → run it → model → answer. Add logging so you can see every tool call.

• Build a ReAct loop (reason → act → observe → repeat) from scratch, with no framework.
• Add a stop rule and a max-step limit so the loop cannot run forever.
• Follow a multi-step run and explain each reason, act, and observe step.

Build a ReAct agent by hand that answers multi-step questions using your Week 2 tools plus a search tool. It must show its thinking, loop until it has an answer, and stop safely at a max number of steps.

• Design good tool descriptions with clear wording, typed inputs (Pydantic), and input checks.
• Add error handling so a failing tool returns a helpful message the agent can recover from — not a crash.
• Connect a real outside API as a tool, including keys and rate limits.

Swap a fake tool for a real API (weather, search, or GitHub). Add Pydantic checks and friendly error messages. Break it on purpose (bad input, network error) and make the agent recover.

• Tell apart working memory (the context window) and long-term memory (saved), and build both.
• Build a retrieval tool that grounds the agent in an outside source.
• Check how memory and retrieval change what the agent does on repeated and fact-based tasks.

Add long-term memory (saved between runs) and a retrieval tool over a small set of documents. Show it answering a question that needs those documents — and saying so when the answer is not there.

• Rebuild one of your hand-made agents in LangGraph, matching your own ideas to the framework's parts.
• Compare LangGraph, CrewAI, and AutoGen, and say which fits a given job.
• Build a simple graph with nodes, edges, and state.

Move your Week 3–5 agent to LangGraph. Then write the same task in a short form in CrewAI or AutoGen, and write a short comparison: what each one made easy or hard.

• Build a multi-agent system where special agents work together on a task.
• Build a clean handoff (how one agent passes control and information to another).
• Judge when many agents beat one good agent — and when they just add cost and new ways to fail.

Build a 2–3 agent "content line" (researcher → writer → editor) with clear handoffs. Compare its output and cost with a single agent.

• Build a supervisor/worker setup where a supervisor sends tasks to workers.
• Build a human-approval step that pauses the graph before an important action.
• Design a graph diagram for your capstone.

Build a supervisor agent that sends work to 2 or more workers, and add a human-approval pause: the graph stops for your "OK" before a risky tool, then continues.

• Use context-engineering skills (what to put in the context, when, and how to shorten it) to improve reliability and cost.
• Connect an outside system with the Model Context Protocol (MCP).
• Check how your context choices change a real task.

Connect your agent to an MCP server and use its tools. Then do a context clean-up on one agent: measure tokens and cost before and after you shorten and summarize.

• Build retries with backoff, caching of results, and model/tool backups in an agent.
• Measure and budget cost and speed for an agent run, and speed up one slow part.
• Check your reliability gains with before-and-after numbers.

Make an agent tougher: add retries with backoff, cache a costly tool or model call, and add a backup model. Make a table of cost and speed (p50/p95) before and after.

• Show a prompt-injection attack on a tool-using agent, and add a defense.
• Build input and output guardrails and a least-privilege permission setup for tools.
• Check an agent for common security risks and write down the risk that is left.

Attack your own agent: hide a prompt injection inside a document or tool result that makes it misbehave. Then defend it — add a guardrail and tighten permissions so the attack fails. Show both the attack working and the defense working.

• Put an agent online as a service (a FastAPI endpoint in a container) that others can reach over the web.
• Add production monitoring: logging, tracing, and basic numbers and alerts.
• Explain the LLMOps loop (watch → measure → improve) for a live agent.

Wrap your agent in a FastAPI endpoint, put it in a container, and deploy it somewhere people can reach. Add request logging and tracing and a simple numbers view.