Day 1: Agentic AI Fundamentals, Reasoning & Autonomous Planning
- From LLMs to AI Agents: Difference between chatbots, assistants, workflows and autonomous agents.
- Agentic AI Architecture: Model, instructions, goals, tools, memory, state and environment.
- Reasoning & Decision Making: How agents break complex tasks into manageable actions.
- Task Decomposition: Converting high-level goals into subtasks and executable steps.
- Planning Strategies: Sequential, iterative and goal-directed planning.
- ReAct-Style Agents: Combining reasoning with actions and observations.
- Agent Loops: Observe → Reason → Act → Evaluate → Repeat.
- State & Memory Fundamentals: Maintaining context across multi-step tasks.
- Failure Modes: Hallucinations, looping, poor planning and uncontrolled autonomy.
- Introduction to Agent Frameworks: OpenAI Agents SDK and LangGraph.
Hands-On
Build Your First Autonomous Planning Agent
Participants will create an AI agent that:
Receives a Goal → Decomposes the Task → Generates a Plan → Executes Steps → Reviews the Result
Tools: Python, Google Colab, OpenAI Agents SDK / LangGraph
Practical Output: A functional goal-driven AI planning agent.
Day 2: Tool-Using Agents, Memory & MCP Integration
- Why Agents Need Tools: Moving beyond text generation to real-world task execution.
- Function/Tool Calling: Connecting agents with Python functions and external services.
- Agent Tool Selection: Allowing the model to determine which tool should be used.
- Structured Outputs: Producing reliable machine-readable agent responses.
- External Knowledge Access: Connecting agents with documents, search and databases.
- Short-Term Memory: Maintaining context during an active task.
- Long-Term Memory Concepts: Persisting information across agent interactions.
- Introduction to MCP: Model Context Protocol for connecting AI systems with external tools and resources.
- MCP Architecture: Client, server, tools and resources.
- Tool Permissions: Controlling what an autonomous agent can and cannot execute.
- Human-in-the-Loop: Adding approval checkpoints before critical actions.
- Guardrails: Input, output and tool-execution safety controls.
Hands-On
Build an AI Agent with Tools & External Knowledge
Participants will develop an agent capable of:
User Request → Reasoning → Select Tool → Execute Tool → Retrieve Information → Generate Final Response
Participants will connect multiple tools and observe how the agent dynamically decides which one to use.
Tools: OpenAI Agents SDK, Python, LangGraph, MCP concepts, Google Colab
Practical Output: A tool-using AI agent capable of completing multi-step tasks.
Day 3: Multi-Agent Systems, Orchestration & Agent Evaluation
- Why Multi-Agent Systems?: When one general-purpose agent is not enough.
- Agent Specialization: Creating agents for research, analysis, planning and validation.
- Multi-Agent Architectures: Supervisor, hierarchical, sequential and collaborative agent patterns.
- Agent Handoffs: Transferring tasks between specialized agents.
- Supervisor Agents: Dynamically assigning tasks to appropriate worker agents.
- Agent-to-Agent Communication: Sharing context, outputs and intermediate decisions.
- Multi-Agent Orchestration: Coordinating multiple agents toward one common objective.
- Shared vs Individual Memory: Managing state across collaborating agents.
- Agent Conflict & Failure: Handling contradictory outputs and failed tasks.
- Human Oversight: Designing approval checkpoints in autonomous workflows.
- Agent Evaluation: Measuring task completion, accuracy, reliability and tool-use success.
- Tracing & Observability: Understanding what happened during agent execution.
- Production Considerations: Cost, latency, reliability, scalability and security.
Hands-On
Build a Multi-Agent Research & Decision System
Participants will create a workflow such as:
User Goal →Supervisor Agent →Research Agent → Analysis Agent → Planning Agent → Validation Agent →Supervisor Review →Final Decision / Report
Each specialized agent will perform a defined role and collaborate through an orchestrated workflow.
Tools: LangGraph, OpenAI Agents SDK, Python, Google Colab
Practical Output: A functional multi-agent system with task delegation, agent handoffs and final-output synthesis.
