AI Agents Bootcamp

Focus

Deconstructing the historical, theoretical, and architectural origins of agency, exploring the shift from traditional deterministic programming to goal-seeking autonomous loops, systems thinking, and tool-use maximalism.

Key Takeaways

– The Modality and Structure of Agency: Distinguishing micromanagement from autonomous delegation, Moravec’s paradox, and the three load-bearing pillars of enterprise AI.
– Tool-Use Maximalism: Cognitive scaffolding, natural language programming vs. microservices, and why comprehensive documentation acts as the primary interface for LLMs.
– The Agentic Loop (ReAct) & Systems Thinking: The fundamental paradigm shift of goal-seeking loops, decomposing non-deterministic multi-step goals into verifiable subgoals, and analyzing high-effort real-world systems.

Lab

– Environment setup and Lab environment, Access to Ray Cluster
– n8n

Focus

Mastering agent environment interaction topologies, context window mechanics, KV cache token economics, mitigation of context rot, and the hardware and distributed computing principles underlying foundation models.

Key Takeaways

– Agent Geography & Environmental Interaction: Closed-loop vs. open-loop environments, and parametric vs. non-parametric memory structures.
– Context Engineering & Token Economics: Mitigating the “Lost in the Middle” phenomenon, context rot diagnostics, KV cache reuse economics, and sidecar memory architectures (DeepSeek Engram).
– Indeterminacy in Language Space: The philosophical introduction to epistemic and aleatoric uncertainty, lexical variance vs. semantic core stability, and overcoming developer assumptions via explicit priors.

Lab

– Google ADK Basics
– LangGraph Basics

Focus

Transforming raw foundational models into specialized, reliable reasoning agents through structured prompt frameworks, multiperspective personas, meta-prompting, and multi-agent social dynamics.

Key Takeaways

– Structured Frameworks & High-Fidelity Prompting: The Singapore CO-STAR framework, instruction precision, and addressing the critical question: *”What did I leave unsaid?”*.
– The Actor-Persona Model: The fly-by-wire control metaphor, steering probability spaces, and multiperspective persona decomposition.
– Meta-Prompting & System Instruction Generation: Synthesizing rigid Pydantic function calling schemas, severity scoring, and automated system instruction hardening.
– Chain of Thought Evolution & Reasoning Substrates: Analysis of CoT latency/cost overheads, self-consistency quorums, and the declining need for manual CoT in modern frontier reasoning models.
– Multi-Agent Emergence & Social Dynamics: Reconstructing the Stanford *Generative Agents (Simulacra)* architecture, memory stream reflection, and emergent coordination.

 Lab
– Prompting Techniques

Focus
Automated evaluation harnesses, actor-critic architectures, and decoupled prompt robustness testing.

Key Takeaways
– Actor-Critic Architectures & Automated Testing: Decoupled parameter scaling in multi-agent reviewer loops, DAG-based critique networks, and automated prompt robustness evaluation with Promptfoo.

Lab
– Promptfoo

Focus

Engineering robust, secure, and standardized tool interfaces for language models using the Model Context Protocol (MCP), establishing strict contracts, and defending against enterprise agent security vulnerabilities.

Key Takeaways

– The USB-C Moment for AI: Anthropic’s unopinionated Model Context Protocol (MCP), decoupling agents from point-to-point tool APIs, and transitioning from stream pipelines to async function interfaces.
– Tool Engineering & Design by Contract: Strict schema typing, tool politeness (information density vs. token bloat), Single Responsibility Principle (SRP), and symmetric mitigations (extraction and garbage collection).
– The “Blame the Tools” Philosophy: FastMCP server construction, LightLLM abstraction layers, and tracing execution failures to ambiguous docstrings rather than model stochasticity.
– Security Engineering & Threat Vectors: Deconstructing the 16 MCP threat scenarios, tool poisoning via docstrings, typo-squatting, tool rugpulling, and indirect prompt injection.
– Enterprise Agent Governance: The Microsoft Governance Toolkit, OWASP Top 10 for LLMs/Agents, just-in-time privilege escalation, and dynamic intent drift tracking.

Lab

– Google ADK – MCP and OAuth

Focus

Architecting modular, composable, and progressive skill libraries for AI agents, navigating the exploration-exploitation dilemma with multi-armed bandits, and implementing file-system-driven cognitive scaffolding.

Key Takeaways

– Skills vs. Tools Abstraction: Procedural knowledge (“knowing-how”) vs. declarative interfaces (“knowing-that”), pure skills vs. tool-using skills, and progressive disclosure architecture.
– Progressive Disclosure & Scoping: Preamble strategies, project-level skill scoping via the CLI, resolving global namespace collisions, and dynamic context injection.
– The Multi-Armed Bandit Paradigm: Balancing exploration vs. exploitation in agent tool selection, $\epsilon$-greedy strategies, regret minimization, and bell-curve reward distributions.
– Self-Evolution: Dynamic skill synthesis, automated code-level verification, and iterative curriculum evolution in open-ended environments.
– Skill Marketplaces & Governance: Anti-patterns of “God Skills”, auditing untrusted community skills, and least-privilege runtime sandboxing.

Lab
– Using Skills with Google ADK Agents

Focus
Moving beyond manual prompt hacking by compiling natural language declarations with DSPy, Genetic-Pareto optimization (GEPA), Bayesian search (MIPROv2), textual gradients (TextGrad), and Agentic Context Engineering (ACE).

Key Takeaways
– Mathematical Foundations of Prompt Optimality: Discrete linguistic gradients, the metric operator $\mu$, Goodhart’s Law in prompt compilation, and calculating the 10-minute Headroom pre-flight test.
– The DSPy Compiler Paradigm: Declarative Signatures, parameterized Modules, and compiling natural language pipelines into optimal few-shot exemplars and instructions.
– Six Families of Prompt Optimization: BootstrapFewShot, Instruction Search (COPRO), Bayesian joint-space search (MIPROv2), Textual Gradients (TextGrad), and Evolutionary Search (APE, Prompt Breeder).
– Genetic Pareto Optimization (GEPA) vs. RL/GRPO: Multi-objective Pareto frontiers, natural language reflection side-channels vs. opaque scalar rewards, and mutation/crossover mechanics.
– Agentic Context Engineering (ACE): Continuous context adaptation vs. fine-tuning, dynamic playbook ledgers, delta updates, and mitigating brevity bias and context collapse.

Lab
– DSPy Basics
– DSPy Optimizers

Focus
Determining when to scale from single tool-maximalist agents to multi-agent topologies, enforcing server-side reliability, and handling aleatoric uncertainty with robust engineering patterns.

Key Takeaways
– Single vs. Multi-Agent Dilemma: Avoiding premature multi-agent complexity, the planetary motion analogy, and evaluating the hidden costs of latency and token velocity.
– Server-Side Tool Infrastructure: Hardening Python backends, Ray Inference Server for high-concurrency MCP hosting, and treating tools as enterprise-grade infrastructure.
– Handling Aleatoric Uncertainty & Fault Tolerance: Idempotency keys for non-deterministic model retries, deduplication with Bloom Filters, and probabilistic sketching algorithms (HyperLogLog, Count-Min Sketch).
– System 1 vs. System 2 Agent: Partitioning reactive single-step execution from deliberate, multi-hypothesis planning and evaluation.

Lab
– Server-Side Tool Infrastructure & Idempotency Patterns
– Multi-Agent Vacation Planning System (System 1 vs. System 2)

Focus
Grounding agent memory in cognitive science and operating systems theory, engineering multi-tiered memory stores, temporal decay mechanics, context garbage collection, generational heap promotion, and graph-relational memory mapping.

Key Takeaways
– Cognitive Foundations of Memory: Tulving’s distinction (Episodic vs. Semantic), Squire’s declarative vs. procedural models, Baddeley’s working memory desk, and the four agentic memory tiers (Working, Episodic, Semantic, Procedural).
– Temporal Fact Dynamics: The Zombie Fact Problem, handling contradiction vs. evolution, and the four verbs of memory (Write, Read, Consolidate, Forget).
– Three-Signal Retrieval Scoring: Unifying Park et al.’s scoring function (Recency $\times$ Importance $\times$ Relevance) with Ebbinghaus forgetting curves and cache eviction theory.
– Context Garbage Collection & Tenuring: JVM heap vs. agent context window, generational tenuring (young vs. old pools), tombstoning stale facts, and multiplicative veto scoring formulas.
– The Space Reclamation Trilemma: The architectural tradeoff between Compression (summaries), Delegation (sub-agents as stack frames), and Externalization (MemGPT paging), alongside GDPR compliance governance.
– Mem0 Graph Memory Architecture: Mem0 Architecture and Memory Lifecycle, Graph extraction pipelines, resolving cross-turn contradictions via graph edges, subgraph query retrieval protocols, and choosing the Appropriate Memory Architecture.

Lab
– Agent Memory Labs (Google ADK)
– Mem0, and other Memory frameworks

Focus
Scaling multi-agent collaboration to internet-scale distributed systems using the Agent-to-Agent (A2A) protocol, dynamic capability discovery via Agent Cards, debate protocols, and decentralized governance.

Key Takeaways
– The Agentic Inter-Networking Paradigm: Scaling beyond isolated monoliths, the $N^2$ communication explosion, and comparing A2A protocols against traditional REST/gRPC APIs.
– The Agent Card Specification: Declarative capability advertisement, caller expectations, non-deterministic contract negotiation, and distinguishing MCP tools from Agent Cards.
– Security, AuthN & AuthZ in Agent Networks: The propagation problem in Role-Based Access Control (RBAC), just-in-time authorization delegation, and preventing multi-agent sycophancy.
– Debate & Consensus Protocols: Multi-agent cooperation patterns, voting mechanics, the consensus prompt, and adversarial cross-reflection verification loops.
– Discovery Standards & The Internet of Agents: Intent-based routing registries, Cisco Agency, the NANDA protocol, and building decentralized enterprise agent networks.

Lab
– A2A with G-ADK
– A2A with LangGraph + Agent Registry

Focus
Mastering enterprise agent architecture layers, applying the doctrine of ruthless simplification, and implementing the 9 canonical agentic design patterns for production reliability.

Key Takeaways
– The Agentic Architecture Layers: Standardizing the stack across Tool Integration (MCP), Collaboration (A2A), Development SDKs (Google ADK / LangGraph), and Trust Registries (NANDA).
– The Doctrine of Ruthless Simplification: Mitigating the mathematics of error compounding ($P(\text{success}) = p^n$), the “Half-Baked Physician” principle, and the 4-question architectural decision framework.
– The 9 Canonical Agentic Design Patterns:
1. Sequential Pipeline (deterministic staging)
2. Router & Dispatcher (intent triage)
3. Parallel Fan-Out / Fan-In (MapReduce decomposition)
4. Orchestrator-Workers (dynamic delegation)
5. Evaluator-Optimizer (generate-critique loop)
6. Group Chat & Council (multi-expert debate)
7. Dynamic Handoff (state transfer)
8. Task Ledger / Adaptive Planning Manager (living execution state)
9. Explicit State Machine (rigid business constraints)
– Enterprise Case Studies: Supply chain orchestration (Tyson Foods), SRE incident resolution (Resolve.ai), and multi-agent customer service networks (Salesforce Agentforce).

Lab
– Agentic Design Patterns (Implementing the 9 canonical enterprise topologies)

Focus
Treating the agent harness as the core differentiator of system performance, applying cybernetic control systems theory, designing machine verifiers, and engineering fail-safe execution runtimes.

Key Takeaways
– The Agent Harness Paradigm: “The Model Proposes, The Harness Disposes” — the Seven Verbs of a Harness, micro-architectural yield boundaries, watchdog timers, and Write-Ahead Logging (WAL).
– The Servlet Container Metaphor: Mapping Tomcat/WebLogic lifecycle management, thread pooling, declarative sandboxing, and transaction rollbacks to agentic runtimes.
– Verifier Mathematics & Information Theory: Hard verifiers vs. soft LLM judges vs. human-in-the-loop, precision ceiling formulas, and defining immutable exit conditions.
– Harness Evolution Across Model Generations: Early multi-agent brittle scaffolding vs. modern minimalist harnesses powered by high-capability base models.

Lab
– Agentic Harness Verifier Loops & Control Systems
– Watchdog & Loop Breaker Engineering

Focus
Evaluating framework paradigms (AI-OS vs Graph-centric), benchmarking modern agent frameworks, dissecting runtime architectures, and enterprise containerization.

Key Takeaways
– Framework Paradigms & The AI-OS: Graph-centric workflow topologies (LangGraph) vs. dynamic runtime discovery (Google ADK), and treating agent runtimes as modern operating systems.
– Evolution of Agent Frameworks: The AutoGPT autopsy (self-amplification bias and missing machine verifiers), CrewAI role constraints, LangGraph state graphs, Pydantic AI, and SDK-first harnesses.
– Systems Engineering & Rust Runtimes: Transitioning to systems programming for agent harnesses, memory safety, concurrency, and evaluating frameworks with HarnessBench.
– Enterprise Containerization & Distributed Reliability: The Two Generals’ Problem in agent communication, distributed idempotency keys, and asynchronous human escalation workflows.

Lab
– Framework Benchmarking (Google ADK vs. LangGraph vs. CrewAI)

Focus
Preventing vibe-coding pathologies, enforcing human-governed specification contracts, and implementing mutation testing and contract-driven metrics for resilient agentic codebases.

Key Takeaways
– Vibe Coding vs. Spec-Driven Governance: The technical debt of unverified vibe coding, mutation testing for generated code, and enforcing human-governed specification contracts.
– Metrics for Contract-Driven Systems: The 4 metrics of resilient agentic codebases: Pinning, Disposability, Convergence, and Lit Code.

Lab
– Spec-Driven Verification Contracts & Mutation Testing

Focus
Unifying exploratory retrieval with autonomous reasoning and deconstructing multi-hop investigation architectures.

Key Takeaways
– Agentic RAG vs. Linear RAG: Multi-hop query decomposition, the Librarian investigation analogy, HyDE query expansion, and adaptive retrieval routing.
– Judgment & Grounding: Why judgment is harder than retrieval, managing contradictions across disparate corporate knowledge bases, and epistemic humility.

Lab
– Agentic RAG

Focus
Training agents using multi-turn trajectory rollouts and credit assignment.

Key Takeaways
– The Core Hypothesis of Agentic Training: The failure of single-turn imitation learning (SFT), the deterministic vs. stochastic divide, and why prompt engineering hits saturation ceilings.
– Trajectory-Based Multi-Turn Optimization: Generating sequential rollouts, identifying branching points of failure, and shifting token probabilities across multi-step execution traces.
– The Credit Assignment Problem in Agents: Distributing sparse episodic rewards across intermediate tool calls and decisions, and automated backpropagation with Microsoft Agent Lightning.

Lab
– Agent Lightning