Agentic AI Engineering Bootcamp

3-Day Hands-on Intensive: Architecture, Orchestration, Tooling & Production Governance

Program Overview

This intensive, three-day hands-on bootcamp equips entry-level software engineers, technical leads, and computer science students with foundational LLM programming experience with the practical skills needed to design, build, evaluate, and safely operate autonomous, tool-using agentic systems.

Participants transition from basic, single-turn prompt-and-response scripts to stateful, multi-turn agent graphs, interoperable tool protocols (Model Context Protocol - MCP), modular agent skills, rigorous regression testing, and production-grade observability.

NoteQuick Facts
  • Audience: Entry-level software engineers and university students with LLM programming fundamentals.
  • Duration: 3 Days · 12 Deep-Dive Sessions · 10 Guided Hands-on Labs · 1 Capstone Showcase.
  • Pacing: 40% Architecture & Design Principles, 60% Practical Guided Labs.
  • Default Model: Google Gemini (gemini-2.5-flash / gemini-1.5-pro) via the official google-genai SDK.
  • Tooling Standards: Python 3.11+ managed with uv, Node.js 22 LTS with npm, and zero-friction local telemetry.
  • Interactive Slide Deck: Launch Agentic AI Bootcamp Presentation

Prerequisites

  1. Python Programming: Comfort with Python functions, classes, async syntax, dictionaries, and virtual environments.
  2. LLM Fundamentals: Working understanding of prompts, completions, tokens, temperature, and making API calls to LLMs.
  3. Developer Tooling: Basic comfort with terminal CLI commands, Git (clone, commit, branch), and VS Code.

Overall Learning Outcomes

By completing the bootcamp, participants will be able to:

  1. Differentiate Agentic Systems: Explain what makes a system agentic versus a standard LLM pipeline or chatbot, placing any architecture accurately on the autonomy spectrum.
  2. Design Agent Runtimes: Architect agents from first principles (foundation model, instructions, context engineering, tool contracts, memory, and reasoning loops).
  3. Master Production Frameworks: Implement stateful workflows and approval gates in both LangGraph and the Google Gen AI Agent Development Kit (ADK) using Gemini models.
  4. Standardize Tooling with MCP: Build and connect custom servers using the open Model Context Protocol (MCP) across local stdio and HTTP transports.
  5. Package Reusable Agent Skills: Author, test, and distribute modular skill bundles with progressive disclosure to keep prompt contexts lean.
  6. Accelerate with Coding Agents: Direct CLI coding agents using spec-driven development, test suites, and iterative human review.
  7. Quantify Quality & Regressions: Build deterministic evaluation harnesses combining rule-based checks and calibrated LLM-as-a-Judge scoring.
  8. Trace & Debug Locally: Instrument multi-step agent runs with zero-friction local OpenTelemetry and Langfuse tracing to pinpoint latency and cost bottlenecks.
  9. Harden Against Threats: Red-team tool-using agents against direct and indirect prompt injection, applying least privilege and deterministic approval gates.
  10. Formulate Adoption Roadmaps: Draft enterprise-grade governance, data privacy, and IP protection guidelines for deploying agents in real-world organizations.

Schedule at a Glance

Day Time Session Focus Area Hands-on Deliverable
Day 1 09:00 1. What is Agentic AI? Agents vs. LLM programming & autonomy spectrum Lab 1: Plain Gemini call to tool-using loop
Day 1 11:00 2. Anatomy of an Agent Components, context engineering & tool schemas Lab 2: Scratch agent with Pydantic schemas & memory
Day 1 14:00 3. System Types & Patterns Workflows, chaining, routing & multi-agent Lab 3: Sequential chain vs. Orchestrator-Worker
Day 1 16:00 4. Framework Landscape LangGraph, ADK, CrewAI, AutoGen & trade-offs Activity 1: Framework decision matrix across 3 use cases
Day 2 09:00 5. LangGraph Deep Dive Pregel, Command, Send, time-travel & persistence Lab 5: Stateful graph with SqliteSaver & interrupt()
Day 2 10:45 6. Google Gen AI ADK LlmAgent, LiteRT-LM edge, LoopAgent & A2A Lab 6: SRE incident response team on Google Cloud Run
Day 2 13:00 7. Model Context Protocol (MCP) Open standards, architecture & custom servers Lab 7: FastMCP SQLite server mounted in FastAPI
Day 2 14:45 8. Agent Skills Packaging reusable expertise & progressive disclosure Lab 8: DevOps canary rollback skill with uv
Day 2 16:00 9. Coding Agents Exact block edits, diffs & autonomous repair Lab 9: Self-healing refactoring agent with pytest
Day 3 09:00 10. Evaluation & Testing Non-determinism, trajectory eval & LLM judge Lab 10: 20-case test suite with rule & judge scoring
Day 3 10:45 11. Observability & Telemetry Zero-friction local tracing, latency & cost Lab 11: Local SQLite tracer & FastAPI timeline explorer
Day 3 13:00 12. Security & Guardrails Prompt injection, least privilege & HMAC gates Lab 12: Financial guardrail pipeline with human gate
Day 3 14:45 13. Enterprise Governance Budget circuit breakers, rate limits & audit Lab 13: Governed Enterprise Agent Gateway & Capstone

Detailed Daily Curriculum

Day 1 · Foundations & Core Architecture

Day 1 transitions participants from single-prompt LLM calls to working, goal-directed agents, followed by an exploration of foundational patterns and framework selection.

Session 1 · 09:00 – 10:30 · What is Agentic AI?
  • Topics:
    • Chatbots (conversational UI) vs. LLM Pipelines (static chains) vs. Autonomous Agents.
    • The Autonomy Spectrum: from deterministic scripts to autonomous multi-agent systems.
    • The Perceive-Reason-Act loop: Observation \(\rightarrow\) Thought \(\rightarrow\) Action \(\rightarrow\) Environment Feedback.
    • Value vs. Risk: identifying genuine agentic use cases and when deterministic code is strictly superior.
  • Hands-on Lab 1: Convert a single Gemini prompt call into an autonomous tool-using loop calling database lookup and calculation functions.
Session 2 · 11:00 – 12:30 · Anatomy of an Agent
  • Topics:
    • The 5 core pillars: Model, System Instructions, Tool Contracts, Memory, and Control Loop.
    • Context Engineering: token budgeting, system prompt formulation, dynamic context injection, and mitigating context degradation.
    • Tool Design: rigorous JSON Schema generation via Pydantic v2, unambiguous descriptions, and error feedback as agent steering signals.
    • Memory architectures: short-term context scratchpad vs. persistent key-value and vector memory.
  • Hands-on Lab 2: Build an agent runtime from scratch in raw Python (no third-party frameworks) with Pydantic tool schemas, conversational buffer, and error recovery.
Session 3 · 14:00 – 15:30 · Agentic System Types and Patterns
  • Topics:
    • Deterministic Workflows vs. Autonomous Agents (predictability vs. dynamic flexibility).
    • Common patterns: Prompt Chaining, Routing, Parallelization (Voting & Sectioning), Orchestrator-Workers, and Evaluator-Optimizer loops.
    • Agentic RAG: Corrective RAG (CRAG), query rewriting, document relevance grading, and fallback search.
    • Designing with Occam’s Razor: choosing the simplest reliable pattern.
  • Hands-on Lab 3: Implement two architectural patterns (sequential chain vs. orchestrator-worker) for technical document analysis and compare latency, cost, and output consistency.
Session 4 · 16:00 – 17:30 · Framework Landscape & Selection Matrix
  • Topics:
    • Comparative analysis: LangGraph, Google Gen AI ADK, CrewAI, AutoGen/AG2, OpenAI Agents SDK, and Claude Agent SDK.
    • Decision criteria: control, learning curve, debugging ease, state persistence, ecosystem lock-in, and production readiness.
    • Framework vs. No-Framework: when to use a specialized framework vs. raw Python with FastAPI.
  • Group Activity 1: Evaluate three real-world software engineering case studies (automated PR review & test fixer, customer support bot with actions, and data ingestion pipeline) and defend framework choices with a filled scorecard.

Day 2 · Depth, Ecosystem & Tooling

Day 2 dives into production-grade frameworks, standard interoperability protocols, reusable capabilities, and developer productivity tools.

Session 5 · 09:00 – 10:30 · LangGraph Deep Dive
  • Topics:
    • Pregel execution engine, supersteps, and cyclical graphs.
    • State schemas (TypedDict), reducers with operator.add, and modern Command / Send APIs.
    • Persistence with SqliteSaver, time-travel replay, and interrupt() human-in-the-loop review.
    • Functional API (@entrypoint and @task) vs. Graph API.
  • Hands-on Lab 5: Build a technical RFC drafting agent in LangGraph with memory checkpoints and an interactive approval gate.
Session 6 · 10:45 – 12:15 · Google Gen AI Agent Development Kit (ADK)
  • Topics:
    • LlmAgent, Runner, and SessionService state lifecycles.
    • On-device edge intelligence with LiteRT-LM (local SLMs).
    • Multi-agent coordination: SequentialAgent, ParallelAgent, and LoopAgent iterative refinement.
    • ADK 2.0 Graph Workflows (Workflow), RoutedAgent failover, Agent-to-Agent (A2A) protocol, and Generative UI (A2UI).
  • Hands-on Lab 6: Deploy a multi-agent Site Reliability Engineering (SRE) incident response team to Google Cloud Run.
Session 7 · 13:00 – 14:15 · Model Context Protocol (MCP)
  • Topics:
    • The \(M \times N\) integration problem vs. open standards.
    • Host \(\leftrightarrow\) Client \(\leftrightarrow\) Server architecture.
    • MCP primitives: Tools, Resources, and Prompts.
    • Transports: Local stdio vs. Remote SSE mounted directly inside FastAPI (mcp.get_asgi_app()).
    • Resource subscriptions (resources/subscribe) and multi-server client aggregation.
  • Hands-on Lab 7: Build and mount a production FastMCP SQLite server with AST query validation inside FastAPI.
Session 8 · 14:30 – 15:45 · Agent Skills & Progressive Disclosure
  • Topics:
    • Solving the context window dilemma with 3-tier progressive disclosure.
    • The SKILL.md instruction specification, scripts, and references.
    • PEP 723 inline script dependencies with uv run --isolated.
    • Zero-trust sandboxed execution and multi-skill orchestration.
  • Hands-on Lab 8: Author a production DevOps canary rollback skill with isolated uv script execution.
Session 9 · 16:00 – 17:30 · Coding Agents in Modern Engineering
  • Topics:
    • The 3 generations of AI coding tools: completions \(\rightarrow\) chat assistants \(\rightarrow\) autonomous CLI agents.
    • 5 core tooling pillars: workspace discovery, exact-match block edits (replace_file_content), execution sandboxes, linter repair loops, and human-in-the-loop review.
    • Dual-tier permission models and long-horizon context compaction.
  • Hands-on Lab 9: Build an autonomous self-healing refactoring agent running pytest in an automated test-fix cycle.

Day 3 · Trust, Production & Enterprise Application

Day 3 turns working prototypes into trustworthy, production-grade systems through evaluation, zero-friction telemetry, security hardening, and governance.

Session 10 · 09:00 – 10:30 · Evaluation and Testing (Eval-Driven Development)
  • Topics:
    • Real-world failure: The $1,200 fraudulent refund catastrophe and why “vibes-based” spot-checking fails.
    • The 3 levels of evaluation: Level 1 Deterministic Assertions, Level 2 Trajectory Auditing, and Level 3 LLM-as-a-Judge.
    • Core metrics: Faithfulness (groundedness), Answer Relevance, and Tool Call F1-score.
    • Synthetic test dataset bootstrapping with Gemini 2.5 and automated CI/CD regression gating.
  • Hands-on Lab 10: Build a 20-case customer support evaluation harness with deterministic tool assertions, LLM-as-a-judge scoring, and a regression scorecard.
Session 11 · 10:45 – 12:15 · Observability & Telemetry
  • Topics:
    • Real-world failure: The $4,800 infinite API loop billing shock and the black-box problem.
    • OpenTelemetry (OTel) GenAI semantic conventions (gen_ai.system, gen_ai.usage.prompt_tokens).
    • Distributed context propagation: W3C traceparent headers across microservice hops.
    • The 4 Golden Signals: cost/tokens, latency/TTFT, tool error rate, and step efficiency.
    • Zero-friction embedded SQLite tracing vs. enterprise backends (Langfuse, Phoenix, Cloud Trace).
  • Hands-on Lab 11: Implement an embedded SQLite trace logger with @tracer.span context managers and a FastAPI /traces/{trace_id} timeline explorer.
Session 12 · 13:00 – 14:30 · Security & Guardrails
  • Topics:
    • The unique threat surface: In LLMs, Data IS Instructions.
    • Real-world exploits: The invisible 1pt PDF resume injection and markdown image token exfiltration.
    • OWASP Top 10 for LLMs (2025): Prompt injection (LLM01), sensitive data leaks (LLM02), and excessive agency (LLM06).
    • Multi-layered “Swiss Cheese” defense: XML prompt armor, bi-directional PII masking, least-privilege tool sandboxes, and cryptographic HMAC approval gates.
  • Hands-on Lab 12: Construct a financial banking agent guardrail pipeline with injection interceptors, PII tokenizers, and human approval gates for high-value wire transfers.
Session 13 · 14:45 – 17:30 · Enterprise Governance & Capstone Showcase
  • Topics:
    • Real-world failure: The departmental budget runaway ($14,000 lead-gen scraper incident).
    • The 4 pillars of enterprise governance: Financial, Operational, Compliance, and Security.
    • Multi-tenant token bucket rate limiting in Redis and automated budget circuit breakers.
    • Resilient model routing cascades (Gemini Flash \(\rightarrow\) Pro fallback) and immutable SHA-256 audit ledgers.
    • The Grand Capstone Showcase: Uniting all 3 bootcamp days into an enterprise-grade agent running on FastAPI, with XML armor, FastMCP tools, lazy-loaded skills, OTel telemetry, and human verification.
  • Hands-on Lab 13 / Capstone: Build, instrument, test, and demonstrate the enterprise agent system; complete the 30-day adoption roadmap.

Local Environment & Setup Requirements

Each participant works on their own laptop with Python 3.11+, an isolated virtual environment managed by uv, Node.js 22 LTS, and a Google Gemini API key.

Hardware & Software Checklist

Component Minimum Specification Recommended Notes
Operating System Windows 11, macOS 13+, or Ubuntu 22.04+ Same, fully updated Labs verified on all three platforms
Memory (RAM) 8 GB RAM 16 GB RAM or more 16 GB recommended if running local Ollama models
Free Disk Space 10 GB 25 GB For virtual environments, packages, and caching
Python 3.11 or 3.12 3.12 via uv Managed with uv python install 3.12
Python Tooling uv package manager Latest uv release Ultra-fast dependency resolution and lockfiles
Node.js Node.js 22 LTS Node.js 22 LTS Minimum Node 22 with npm for MCP servers
Git & VS Code Current stable releases VS Code with Python extension For cloning repositories and editing code
Docker (Optional) Docker Desktop Current release Optional for self-hosted Langfuse or sandboxing
Model API Key Google Gemini API Key Gemini 2.5 Flash / Pro Active key configured in .env

Python Package Manifest (pyproject.toml / uv)

[project]
name = "agentic-ai-bootcamp"
version = "0.1.0"
description = "Hands-on code and labs for the 3-Day Agentic AI Engineering Bootcamp"
requires-python = ">=3.11"
dependencies = [
    "google-genai>=0.1.0",
    "langchain-google-genai>=2.0.0",
    "langgraph>=0.2.0",
    "langchain-core>=0.3.0",
    "mcp>=1.0.0",
    "pydantic>=2.9.0",
    "pydantic-settings>=2.5.0",
    "httpx>=0.27.0",
    "fastapi>=0.115.0",
    "uvicorn>=0.31.0",
    "python-dotenv>=1.0.1",
    "pytest>=8.3.0",
    "pytest-asyncio>=0.24.0",
    "opentelemetry-api>=1.27.0",
    "opentelemetry-sdk>=1.27.0",
    "langfuse>=2.50.0",
    "pip-audit>=2.7.3",
]

Quick Setup Steps with uv

# 1. Ensure uv is installed
curl -LsSf https://astral.sh/uv/install.sh | sh

# 2. Clone the repository and initialize environment
git clone <bootcamp-repo-url> agentic-bootcamp
cd agentic-bootcamp
uv sync

# 3. Configure API Keys
cp .env.example .env
# Edit .env and set: GEMINI_API_KEY="your-gemini-api-key"

# 4. Verify environment with check script
uv run python scripts/check_env.py

The check_env.py script validates the Python version, Node.js version, package imports, and executes a test ping to the Google Gemini API to ensure complete readiness before Day 1.

Participant Deliverables & Assessment

Every participant leaves the bootcamp with complete, tested artifacts: 1. Lab Code Repository: Executable code for all 10 hands-on labs. 2. Framework Decision Matrix: Customized evaluation scorecard for their team’s use cases. 3. Custom MCP Server & Skill: Working MCP server and packaged reusable skill bundle. 4. Automated Evaluation Set: 20-case test dataset with outcome and trajectory scoring. 5. Security & Guardrails Checklist: Hardened agent configuration and threat audit template. 6. Capstone Project: Complete, working production-grade agent with telemetry and human gates. 7. 30-Day Adoption Roadmap: Personal or team action plan for scaling agentic AI.

30-Day Follow-Up Support

  • Week 1: Repository code updates, session recordings, and open discussion channel for lab extensions.
  • Week 2: Virtual office hours for troubleshooting and refining custom agents.
  • Week 4: Virtual showcase session of piloted agents and adoption retrospective.