• Understand the architecture and working principles of Agentic AI.
• Learn autonomous reasoning, planning, and task decomposition.
• Develop agents capable of tool and function calling.
• Understand agent memory, state, and external knowledge integration.
• Explore MCP and human-in-the-loop workflows.
• Design specialized agents for different tasks.
• Build and orchestrate multi-agent systems.
• Understand agent evaluation, guardrails, and reliability.

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

• Design goal-driven autonomous AI agents.
• Implement reasoning and planning workflows.
• Connect AI agents with tools and external resources.
• Build memory-enabled and context-aware agents.
• Create supervisor and specialized-agent architectures.
• Implement agent handoffs and task delegation.
• Develop multi-agent collaborative workflows.
• Apply guardrails and human oversight.
• Evaluate agent performance and reliability.
• Build an end-to-end Agentic AI application.

• Students: UG/PG students from Computer Science, AI, ML, Data Science, IT, Software Engineering, Robotics, and related disciplines.
• Ph.D. Scholars / Researchers: Researchers working in Generative AI, LLMs, autonomous systems, multi-agent systems, NLP, and intelligent automation.
• Academicians / Faculty: Faculty interested in Agentic AI research, curriculum development, and advanced AI applications.
• Industry Professionals: AI/ML engineers, software developers, data scientists, GenAI developers, automation engineers, AI architects, and technology professionals.