Agentic AI Frameworks Deep Dive
Field | Description / Template |
|---|---|
Purpose | This course provides an advanced exploration of agentic AI systems, focusing on autonomous multi-agent architectures, orchestration frameworks, and real-world enterprise workflows. Learners will design, coordinate, and deploy intelligent AI agents capable of reasoning, planning, collaboration, and tool usage using modern agentic frameworks and protocols. |
Audience | AI engineers, software developers, platform engineers, researchers, and architects building autonomous AI systems and multi-agent workflows. |
Role | AI Engineer, GenAI Engineer, Machine Learning Engineer, Solutions Architect, Platform Engineer, Research Engineer. |
Domain | Agentic AI, Multi-Agent Systems, Generative AI, AI Infrastructure |
Skill Level | Advanced |
Style | Deep technical, architecture-focused, and hands-on with real-world orchestration labs, framework integration, and collaborative multi-agent projects. |
Duration | 3 Days |
Related Technologies | LangGraph, CrewAI, MCP (Model Context Protocol), AgentCore Observability, Weights & Biases Weave, Python, Llama Models, Phi Models, Vector Databases |
Course Description
This course explores the rapidly evolving field of agentic AI systems, where autonomous agents collaborate, reason, and execute tasks dynamically. Learners begin by understanding the transition from traditional chatbots to intelligent autonomous workflows capable of perception, planning, action, and reflection.
The course introduces modern architectural patterns for multi-agent systems, including sequential pipelines, manager-worker orchestration, and collaborative agent swarms. Learners will evaluate how specialized Small Language Models (SLMs) can improve efficiency, reduce latency, and optimize operational costs within distributed AI systems.
A key focus is placed on the Model Context Protocol (MCP), an emerging standard that enables agents to dynamically discover and interact with external tools and services. Learners will explore MCP architecture and implement real-world integrations with APIs, databases, and productivity tools.
The course also covers advanced coordination mechanisms such as agent-to-agent communication, negotiation, conflict resolution, and shared memory management across distributed agent systems. Production observability and debugging techniques are introduced using AgentCore Observability and Weights & Biases Weave.
Through hands-on labs and a final capstone project, learners will design and deploy collaborative multi-agent systems capable of autonomously generating technical content, validating outputs, and optimizing results using coordinated AI workflows.
Who is this course for
AI engineers building autonomous systems
Developers exploring multi-agent orchestration
Architects designing scalable AI workflows
Researchers working on agentic AI systems
Advanced GenAI practitioners implementing collaborative agents
Course Objectives
By the end of this course, learners will be able to:
Understand agentic AI evolution, architectures, and multi-agent orchestration patterns
Design sequential, hierarchical, and collaborative autonomous agent workflows
Build and coordinate multi-agent systems using MCP, LangGraph, and CrewAI
Implement agent communication, negotiation, shared memory, and distributed context management
Monitor, debug, and deploy production-ready enterprise AI systems using observability and governance practices
Prerequisites
Strong understanding of Python programming
Familiarity with LLMs and generative AI concepts
Experience with APIs and workflow automation
Basic knowledge of LangChain or AI orchestration frameworks
Understanding of cloud infrastructure concepts is recommended
Course outline
Section 1: Overview of Agentic AI
The Evolution: From Chatbots (Static) to Workflows (Deterministic) to Agents (Autonomous).
The Agentic Loop: Perception → Reasoning → Planning → Action → Reflection.
Small Language Models (SLMs) in Agentic AI: Why focus on using specialized sub-agents (e.g., Phi-4 or Llama-Small) for efficiency.
Lab 1: The Anatomy of an Agent. Building a simple "Researcher" agent that can autonomously search, summarize, and cite its own sources.
Lab 1.1: Planning-Based Research Agent
Lab 1.2: Self-Reflection & Critic Loops
Lab 1.3: Fast Reasoning with Small Language Models
Section 2: Architecture & Use Cases
Architectural Patterns:
Enterprise Use Cases: Self-healing DevOps pipelines, autonomous customer success fleets, and agentic supply chain optimization.
Lab 2: Designing a Multi-Step Workflow. Use LangGraph or CrewAI to architect a "Technical Support Triage" system that decides whether to resolve, retrieve data, or escalate.
Lab 2.1: Ticket Routing with LangGraph
Lab 2.2: Specialized Worker Agents
Lab 2.3: Multi-Agent State Handoffs
Section 3: The Model Context Protocol (MCP)
Standardization: Introduction to MCP as the "USB-C for AI."
MCP Architecture: Understanding the MCP Host (the Agent), the MCP Client (the Connector), and the MCP Server (the Tool/Data).
Tool Discovery: How MCP allows agents to dynamically "find" and use new tools without manual integration.
Lab 3: Connecting to the World with MCP. Configure an MCP server to connect an agent to your Google Calendar or a private database, enabling it to answer questions about your real-world data.
Lab 3.1: MCP Server Deployment
Lab 3.2: MCP Host & Tool Discovery
Lab 3.3: Dynamic MCP Tool Invocation
Section 4: Building Multi-Agent Systems (MAS)
Coordination Mechanisms:
State & Memory Management: Sharing context across a "swarm" of agents without context window overflow.
Monitoring & Observability: Tracing a single request across five different agents using AgentCore Observability or Weights & Biases Weave.
Lab 4: Coordination, Conflict & Observability
Lab 4.1: Multi-Agent Negotiation Systems
Lab 4.2: Tracing with LangSmith or Weave
Lab 4.3: Persistent Shared Agent Memory
Section 5: Capstone - The "Executive Team" Swarm.
Build a 3-agent system (a Writer, a Fact-Checker, and an SEO Expert) that collaboratively produces a technical blog post. You will use MCP for the tools and LangGraph for the coordination logic.