Stop building demos.
Start shipping agents.

Call multiple providers reliably, get structured outputs, engineer context like a 2026 engineer.

• The 2026 model landscape — Claude Opus 4.7/Sonnet 4.6, GPT-5.5, open models — choosing by cost, latency & capability.
• Context engineering > prompt engineering — System prompts, 1M context windows, what to put in context vs retrieve vs tool.
• Structured outputs — JSON schema / Pydantic, tool-calling-as-extraction, why “respond in JSON” fails.
• Prompt caching & token economics — Anthropic cache breakpoints, when caching pays off, measuring it.
• Reasoning & extended thinking — When to turn it on, effort levels, and the cost trade-offs.

Lab → Build a provider-agnostic LLM client + structured-extraction pipeline with a cost report.

Understand what an agent really is — a loop + tools + state — and build one from scratch, then in LangGraph.

• Tool / function calling — Schemas, parallel tool calls, and the agent loop demystified — built in raw Python first.
• Intro to LangGraph 1.x — Nodes, edges, state, and why graphs beat chains.
• ReAct vs plan-then-act — Tool design: idempotency, error surfaces, descriptions as prompts.
• Guarding the loop — Max steps, timeouts, and tool-error handling.

Lab → Give your assistant 3 real tools with step limits and error handling.

Build production RAG: hybrid search + reranking + agentic retrieval on Qdrant.

• Chunking & embeddings — Qwen3 embeddings and a sane indexing strategy.
• Qdrant in production — Collections, metadata filtering, native hybrid search + Reciprocal Rank Fusion.
• Reranking — Cross-encoder reranking and actually measuring retrieval quality.
• Agentic RAG — Let the agent decide whether/what to retrieve, multi-hop; when GraphRAG earns its keep.

Lab → Index a real corpus; hybrid + rerank; expose retrieval as an agent tool.

Add memory, prove it works with evals, deploy it as a real API.

• Agent memory — Short-term state vs long-term (LangGraph store / Mem0 / Letta) — and when you actually need it.
• Evals — Why “it looks good” isn’t an answer; Ragas for RAG + DeepEval (pytest-for-LLMs).
• LLM-as-judge — The basics, plus building a small golden dataset.
• Deploying an agent — FastAPI service, streaming, env/secrets, and a Dockerfile.

Lab → Ship Project 1: deployed URL, eval suite in CI, demo video, blog post.

Master durable LangGraph (HITL, checkpointing) and place it among CrewAI / MAF / OpenAI SDK / ADK.

• State, checkpointing & durability — Reducers, durable execution, and replay.
• Human-in-the-loop — Interrupts, time-travel debugging, and LangGraph Studio.
• Streaming & subgraphs — Fan-out / fan-in patterns.
• Framework comparison — CrewAI, Microsoft Agent Framework, OpenAI Agents SDK, Google ADK — and why we standardize on LangGraph.

Lab → Refactor a fragile agent into a durable graph with checkpointing + human approval.

Build your own MCP server, consume MCP tools, and use the Claude Agent SDK + Skills.

• MCP spec 2025-11-25 — Tools, resources, prompts; client/server architecture; the MCP Registry.
• Build an MCP server — FastMCP in Python — expose your retrieval + a real API as MCP tools.
• New spec capabilities — Elicitation (form + OAuth/URL mode), sampling, async tasks; OAuth 2.1 for remote servers.
• Claude Agent SDK + Skills — Package instructions + scripts + resources as auto-invoked Skills.

Lab → Convert your project’s tools into an MCP server other agents can call.

Design multi-agent systems that actually work — supervisor, hierarchical, delegation, long-running async.

• Supervisor / router patterns — When multi-agent beats one good agent — and when it’s over-engineering.
• Hierarchical & plan-and-execute — The deep-research-agent pattern (LangChain Deep Agents).
• Sub-agents & delegation — Context isolation per sub-agent.
• Long-running / async agents — Background tasks, task IDs, start/check/cancel; durability for hour-long runs.

Lab → Build a supervisor over 3 sub-agents with delegation + an async research task.

Make agents interoperate via A2A and instrument everything with tracing + online/offline evals.

• A2A v1.0 — Agent Cards (incl. signed cards), discovery, task lifecycle; MCP + A2A together.
• A2A interop — Expose one agent over A2A; consume an external A2A agent.
• Observability — Langfuse / LangSmith / Phoenix — trace every node, cost & latency per run.
• AgentOps — Online vs offline evals, CI regression suites, alerting on quality drift.

Lab → Ship Project 2: multi-agent system, custom MCP server, A2A interop, full observability.

Decide when to fine-tune, then do it: LoRA/QLoRA with Unsloth, quantize, serve on vLLM.

• When to fine-tune — Prompt → RAG → tools → then fine-tune; for style/format/latency/cost, not fresh knowledge.
• PEFT / LoRA / QLoRA — How they work; 2026 defaults (r=16, α=16, all-linear, DoRA); dataset construction.
• Fine-tune with Unsloth — A small open model (Llama 4 / Qwen3) on Colab/RunPod — no local GPU needed.
• Quantize & serve — GGUF / AWQ / GPTQ, then serve the adapter on vLLM; eval tuned vs base.

Lab → Fine-tune + serve a model; produce a base-vs-tuned eval report.

Take an agent from notebook to a cost- and latency-bounded production service.

• Packaging — FastAPI + Docker; async, streaming, concurrency, structured logging.
• Orchestration — Kubernetes basics for LLM services — health checks, autoscaling, secrets.
• Cost engineering — Prompt caching, batching, model routing, token budgets, cost dashboards.
• SLOs — Latency budgets, P95, fallbacks/timeouts/circuit breakers — Vivek’s 50% cost-cut playbook.

Lab → Deploy a containerized agent with caching, model routing, an SLO, and a fallback.

Add voice/vision/document capabilities, harden against attacks, survey the frontier.

• Voice / speech-to-speech — OpenAI Realtime 2 (GPT-Realtime-2) with MCP + image input + SIP.
• Vision & document AI — Multimodal Claude/GPT-5.5; Claude Skills for Excel/PDF/Docx workflows.
• AI safety — Prompt-injection defenses, output guardrails, basic red-teaming, PII handling.
• Frontier patterns — Deep-research, computer-use & browser agents, reasoning in loops — real vs hype.

Lab → Build a voice agent calling an MCP tool; red-team a deployed agent and add guardrails.

Ship Project 3, present it, and convert the cohort into a job.

• Capstone polish — README, demo video, blog post, deploy, and an eval report.
• Demo Day — Each learner presents (5 min) to the cohort + invited hiring contacts.
• The AI engineer interview — Agent system design, evals, cost, debugging; resume + LinkedIn positioning.
• Certification & next steps — Earn the credential; lifetime Discord; cohort-2 alumni perks.

Lab → Ship your capstone. Present at Demo Day. Earn the certification (if you pass).