In-Demand AI Agents to Build
The AI DevOps Engineer was project #1. Here are more, each a category companies are actively hiring for and buying. Every project is a full design chapter — brief, discovery, architecture, safety model, tool surface, evals, and a phased rollout — built the same way as the DevOps capstone, and linked back to the exact course chapters and Python parts you use to build it.
Learning objectives
- Pick the right project for your level and goals — and know what it assumes.
- Run any project the same way: starter repo → brief → phased build → self-grade.
- Read the 7-part design blueprint every project shares, on a concrete example.
- Grade your own build against the project's production rubric before you call it done.
How to actually run a project essential
Every project page is a full design chapter — but a design is only useful if you build it. Here's the exact loop to turn any project on this page into working code you can show.
The build loop (same for every project)
- Set up the starter. Clone the course starter repo, make a venv, and create the project folder. One command block, shown below.
- Read the brief & discovery. Every project opens with the real problem and where the time/cost goes — that's what you're actually solving, not "call an LLM."
- Build phase by phase. Follow the page's sections in order (architecture → tools → safety → evals). Each has a runnable lab; type it, run it, make it pass.
- Gate it with the rubric. Every project ends with a self-scoring rubric. Score your build against it — a green demo is not the same as "meets the production bar."
- Roll out in phases. Ship Observe → Assist → Auto, never straight to autonomous. The rubric's blocking condition tells you what must be true first.
setup.sh# one-time: get the starter repo + a virtualenv
git clone <the course starter repo> && cd llm-course-starter
python -m venv .venv && source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install -r requirements.txt # anthropic, pydantic, pytest, ...
# per project: a clean folder to build in
mkdir -p support-agent/{agent,kb,tests}
cd support-agent && touch agent/__init__.py
# now open the project page and build phase by phase
anthropic SDK installed and your API key in the environment works. The starter just saves you the boilerplate the earlier chapters already taught you to write.Choose your path essential
The projects aren't a strict sequence — pick one that excites you. But they do assume different amounts of prior work. Use this as a difficulty ladder: start where your skills are, then climb.
| Start here (foundational) | Then (intermediate) | Advanced / capstone |
|---|---|---|
| Customer Support Agent | Document Intelligence + RAG | Multi-Agent Research Crew |
| Semantic Search Engine | Coding & Code-Review Agent | Multi-Agent + Observability |
| Content Assistant | Data Analyst Agent | End-to-End Agentic System |
Rule of thumb: every project assumes Chapters 1–5 (API call, prompting, RAG, the agent loop, evals). Projects with multi-agent, guardrails, or observability in the name also lean on the later tracks. The runnable planner below tells you what a given project needs before you start it.
plan_project.pydef plan_project(name, difficulty, prereqs_met):
"""Given what you've already done, say if you're ready and what to do first."""
phases = ["1 Observe (read-only, dry-run)",
"2 Assist (human approves every action)",
"3 Auto (gated, low-risk actions only)"]
ready = all(prereqs_met.values())
missing = [k for k, v in prereqs_met.items() if not v]
return {
"project": name,
"difficulty": difficulty,
"ready_to_start": ready,
"do_first": missing or ["nothing - you're set"],
"rollout": phases,
}
plan = plan_project(
"Customer Support Agent", "intermediate",
{"can call the API (Ch 1)": True,
"built RAG (Ch 3)": True,
"wrote an agent loop (Ch 4)": False}, # <- gap
)
for k, v in plan.items():
print(f"{k}: {v}")
project: Customer Support Agent
difficulty: intermediate
ready_to_start: False
do_first: ['wrote an agent loop (Ch 4)']
rollout: ['1 Observe (read-only, dry-run)', '2 Assist (human approves every action)', '3 Auto (gated, low-risk actions only)']This little planner turns "which project should I build?" into a concrete answer based on what you've already learned — so you don't start a project that assumes skills you haven't covered yet.
plan_project(name, difficulty, prereqs_met)takes the project and a dict of prerequisites you have/haven't done (each True/False).all(prereqs_met.values())is True only when every prerequisite is met — that becomesready_to_start.- The list comprehension collects the
Falseones intodo_first, so you get an actionable to-do list, not just "no." - It always returns the Observe → Assist → Auto rollout, the phased path every project ships on.
What the output means: Because the Ch 4 prerequisite is False, it reports ready_to_start: False and tells you to do the agent-loop chapter first.
Try this: Flip 'wrote an agent loop (Ch 4)' to True and re-run — ready_to_start becomes True and do_first clears.
do_first, do those chapters first — building on a missing foundation is where learners stall. Flip the last prereq to True and the planner clears you to start.The 7-part blueprint, on one project intermediate
Every project page follows the same 7-part design chapter. Here it is filled in for the Customer Support Agent, so you can see the depth before you open a page — this is the shape you'll produce for whichever project you pick.
| Blueprint section | For the Support Agent |
|---|---|
| Brief & discovery | Agents answer repetitive doc-grounded questions; humans should only see the hard 20%. |
| Architecture | Ticket in → RAG over help-docs → Claude drafts answer → confidence gate → auto-reply or escalate. |
| Risk / safety model | Wrong answer = bad CX; ungrounded reply or low confidence → escalate, never guess. |
| Tool surface | search_docs (read), draft_reply (read), update_ticket (write, gated). |
| Evals | Golden Q&A set; measure grounding + escalation precision; hard-fail on out-of-KB answers. |
| Phased rollout | Observe (draft only) → Assist (agent drafts, human sends) → Auto (send high-confidence). |
| Cost & scale | Cache the system prompt; route easy tickets to a small model; batch the backlog. |
The same blueprint every time
Every project chapter follows the structure that made the DevOps capstone buildable:
| Section | What it answers |
|---|---|
| The brief & discovery | What's the real problem? Where does the time/cost go? |
| Architecture | Trigger → knowledge (RAG) → brain (LLM) → tools → review → output |
| Risk / safety model | What can go wrong, and what's gated vs. free |
| Tool surface | The concrete tools, tagged by risk |
| Evals | How you measure it's good enough to trust |
| Phased rollout | Observe → assist → act, earning autonomy on evidence |
| Skills matrix + course links | Every piece mapped to the chapter/Python part that teaches it |
Choose your project
1 · AI DevOps Engineer
SRE / platform teamsDiagnoses incidents, proposes infra fixes as PRs, and (carefully) acts across K8s, Terraform, AWS, CI/CD, monitoring. The full capstone — design + 4 build labs + runnable code.
2 · Customer Support Agent
Support / CX teamsAnswers customers from your docs with citations, drafts replies, files/updates tickets, and escalates to a human when unsure. The most widely-deployed agent type in business today.
3 · Coding & Code-Review Agent
Engineering teamsReviews pull requests for bugs and style, explains failures, and proposes fixes as commits — repo-aware and grounded in your conventions. The fastest-growing enterprise use case.
4 · Document Intelligence Agent
Finance / legal / opsExtracts structured data from contracts, invoices, and forms — validated against a schema, flagged for review when uncertain. Replaces hours of manual data entry.
5 · Data Analyst Agent
Data / BI teamsTurns plain-English questions into SQL, runs it read-only, and explains the results in words and charts. "Talk to your database" — a top enterprise ask.
6 · Deep Research Agent
Analysts / knowledge workPlans a research question, searches multiple sources, verifies claims, and writes a cited report. The pattern behind "deep research" features everywhere in 2026.
7 · Document Intelligence with RAG
Legal / finance / opsIngests a whole corpus of documents and answers grounded questions across all of them with citations — extraction (P4) feeding retrieval (Ch 3) at scale.
8 · Prompt-Powered Content Assistant
Marketing / contentDrafts on-brand blog posts, copy, and social variants from a brief — a reusable prompt-template library with brand voice and a human approval gate.
9 · Semantic Search Engine
Any search / discoveryMeaning-based search with hybrid retrieval and re-ranking — the engine under every RAG system, built as a product with honest relevance metrics.
10 · Agentic RAG Knowledge Assistant
Internal knowledge / supportRAG that reasons about retrieval: plans queries, judges its own results, re-searches when they're thin, and abstains without evidence. A researcher, not a lookup.
11 · No-Code Automation Agent
Ops / marketing / SMBA trigger → LLM → action agent built visually on n8n, Make, or Zapier — the fastest path from idea to a working, business-owned agent, with a human gate on risky actions.
12 · Custom MCP Server with Claude
Platform / integrationsPublish your own tools, data, and prompts to Claude and any MCP client through the Model Context Protocol — build the integration once, use it everywhere, safely.
13 · Multi-Agent Research Crew
Analysis / knowledge workA team of specialized agents — planner, researchers, critic, writer — collaborating like a human team, with a critic role that catches errors before they reach the report.
14 · Customer Support with Guardrails
CX / trust & safetyProject 2 done safety-first: a support agent wrapped in a layered guardrails architecture — input/output rails, PII control, prompt-injection defense, and red-team evals.
15 · Multi-Agent Workflow with Observability
Platform / SRE for AIA multi-agent workflow you can see inside: end-to-end traces, per-agent cost/latency metrics, and online evals — the LLMOps layer that makes agents operable in production.
16 · End-to-End Agentic AI System
The capstone synthesisThe project that ties it all together: take one real problem from discovery through a designed, grounded, guarded, evaluated, observable, deployed system. Your portfolio piece.
✓ Checkpoint — you can move on when you can…
- Explain the 5-step build loop that turns a project page into working code.
- Pick a project matched to your level and name its prerequisites.
- Recite the 7-part design blueprint every project shares.
- Say why you grade against the rubric and roll out Observe → Assist → Auto.
Knowledge check check yourself
Why does every project roll out Observe → Assist → Auto instead of going straight to an autonomous agent?
Show answer
The project planner says ready_to_start: False with do_first: ['wrote an agent loop (Ch 4)']. What should you do?