Professional Certificate Programme in Agentic AI and Applications

• Numbers, Strings, Lists, Dictionaries, Loops and conditionals in Python

• Live coding: Build a decision-making chatbot

• Loop exercises and variable tracing

• Tools:

  • Python Tutor, Replit, ChatGPT

• Project / Case:

  • Build a user-input based chatbot that gives greetings or advice based on age/gender input

• Defining functions, Arguments and returns, Importing and using libraries (requests, Json)

• Working with NumPy and Pandas

  • Modular coding session

• Reuse logic from one file in another

• Build a simple calculator CLI

• Calling a public API

• Working with Data

• Tools:

  • Jupyter, Python

• Project / Case:

  • Getting Weather Data in Python

• AI vs ML vs DL, Supervised & Unsupervised learning, Neural networks intro

• Reinforcement Learning basics

• Search and optimisation in AI agents

• Quick quiz/discussion on ML types using case examples

• Demonstration of basic models using visual tools (e.g., classification agent)

• Show DL in Real life with pretrained model examples

• Tools:

  • Google Teachable Machine (demo), Scikit-learn (visual), TensorFlow Playground

• Project / Case:

  • Use a visual tool to create a basic classifier (e.g., image or sentiment) and share insights

• Transformer architecture (overview)

• Tokenisation & Embeddings

• Context windows & memory limits

• Basics of prompt engineering

• Tokenisation demo (breaking inputs into tokens)

• Visualisation: How attention works in Transformers

• Live exploration: Prompt responses using various LLMs

• Prompt tuning challenge: Generate summaries with context constraints

• Tools:

  • OpenAI Playground, HuggingFace Spaces, LangChain (prompt templates), Tokeniser Visualisers

• Project / Case:

  • Prompt engineering challenge: Compare how different prompts produce different results for the same task

• What are embeddings?

• Token vectors vs sentence embeddings

• Distance metrics (cosine, Euclidean)

• Intro to similarity search

• Visualise word/sentence embeddings using dimension reduction (PCA/t-SNE)

• Explore cosine similarity between query and docs

• Build basic vector search using OpenAI embeddings and FAISS

• Tools:

  • OpenAI Embeddings, HuggingFace Transformers, FAISS, LangChain Embedding Functions, t-SNE tools, ChromaDB

• Project / Case:

  • Build a mini 'document similarity finder' using embeddings and FAISS/ChromaDB, where users input text and find top 3 matching docs

• Basics of LangChain, OpenAI API, Prompt formatting and response parsing

• Demo: Build a simple tool-using agent (e.g., use calculator + search tool)

• Prompt templates introduction

• Tools:

  • LangChain, OpenAI, Python

• Project / Case:

  • Build a mini assistant that uses a calculator tool and returns a formatted response to 'How many hours in X days?'

• What is Agentic AI?

• Autonomous AI vs Traditional AI, Agent lifecycle and capabilities

• Types of autonomy in AI systems

• Real-world examples of agents (assistants, planners, scouts)

• Discuss maturity levels of AI autonomy

• Compare rule-based systems vs agents

• Interactive brainstorming: Where can agents be used in business?

• Live demo of a simple agent in action (e.g., task planner)

• Tools:

  • Flowise (demo), Autogen Studio (demo)

• Project / Case:

  • Reflection sheet: Identify 3 areas in your work/life where an AI agent can help

• Agents vs Functions vs APIs

• Overview of agentic libraries: LangChain, Autogen, CrewAI

• Tool abstraction and orchestration basics

• How agents use external tools via APIs

• Walkthrough: Building a basic tool-using agent

• Demo: Visual orchestration with LangFlow or Flowise

• Agent execution tracing and debugging demo

• Mini hands-on: Connecting a calculator or search tool

• Tools:

  • LangChain, Autogen, CrewAI, Flowise, LangFlow, OpenAgents (as needed)

• Project / Case:

  • Build a basic tool-using agent (e.g., calculator or web search wrapper) using either code or visual builder

• Types of agents: Reactive, Deliberative, Hybrid

• Multi-agent system fundamentals

• Task-oriented vs Goal-oriented agents

• Agent communication & reasoning frameworks

• Diagramming session: Design your own agent architecture

• Demo: CrewAI or Autogen multi-agent setup

• Simulation: Agent collaboration on a task (e.g., writer + editor agent)

• Agent design roleplay: Who does what in a team?

• Tools:

  • CrewAI, Autogen, LangChain Agents, AgentVerse (optional)

• Project / Case:

  • Design a 2-agent team for a collaborative task (e.g., research + summarisation) with clear roles and interactions

• Goal setting and planning in autonomous agents

• Hierarchical vs reactive planning

• Multi-agent strategies

• Reinforcement loops in planning

• Live demo: Agent planning task using CrewAI or LangChain planning agent

• Hands-on: Modify plan based on changing goals

• Group activity: Define agent goals and break into tasks

• Scenario simulation: Travel planning agent with constraints

• Tools:

  • LangChain Agents (PlannerAgent), CrewAI, Autogen Planning Loops

• Project / Case:

  • Build a simple goal-oriented planner agent (e.g., event scheduler or itinerary builder) with fallback handling

• Short-term vs Long-term memory in agents

• Vector stores and embedding storage

• Semantic similarity & chunking

• Retrieval-Augmented Memory loop

• Demo: Building an agent with memory (short-term + long-term)

• Hands-on: Document chunking + vector search

• Workshop: Improve agent response with memory access

• Case Study: Memory use in customer support agents

• MCP demo

• Tools:

  • ChromaDB, Pinecone, LangChain Memory, FAISS, OpenAI Embeddings

• Project / Case:

  • Create a memory-augmented agent for document Q&A or repeat-user tracking scenario

• Prompt types: Zero-shot, One-shot, Few-shot

• Chain-of-thought prompting

• Instruction tuning basics

• Dynamic prompt construction patterns

• Prompt engineering lab: Refine prompts for clarity, tone, reasoning

• Demo: Chain-of-thought & step-by-step tasks

• Hands-on: Modular prompt assembly using LangChain or Flowise

• Activity: Fix a badly behaving agent by prompt rewrites

• Tools:

  • OpenAI Playground, LangChain PromptTemplates, Flowise, PromptLayer (optional)

• Project / Case:

  • Prompt Design Challenge: Create 3 versions of a task-solving prompt (basic, step-by-step, role-specific) and evaluate their outputs

• Reinforcement Learning fundamentals

• RLHF (Reinforcement Learning with Human Feedback)

• Reward systems for agents

• Adaptive behaviour tuning

• Demo: Adaptive agent adjusting to new inputs (using OpenAI functions or simulated RL)

• Walkthrough: Feedback loops in task agents

• Group activity: Design a reward system for a learning agent

• Comparison: Hardcoded vs adaptive behaviours

• Tools:

  • OpenAI API (with temperature tuning), LangChain + feedback loops, RL demo environments (e.g., CleanRL, simple Gridworld visual)

• Project / Case:

  • Define a reward mechanism for a hypothetical agent (e.g., support agent, recommender) and simulate its improvement logic or rules

• RAG architecture overview

• Combining retrieval and generation flows

• Contextual embeddings & relevance ranking

• Customising RAG for Q&A, summarisation

• Demo: Build a document Q&A bot with RAG

• Hands-on: Connect embedding model + vector store + LLM chain

• RAG tuning exercise: Improve relevance, reduce hallucination

• Group debugging: Why is this RAG agent failing?

• Tools:

  • LangChain RAG Chain, ChromaDB / Pinecone, Hugging Face Transformers, Flowise

• Project / Case:

  • Build a custom RAG-powered assistant that answers questions based on a given knowledge base (PDF, text, or URL dump)

• Hosting options for agents (cloud, serverless, embedded)

• API deployment walkthrough

• Latency optimisation basics

• Monitoring principles

• Demo: Deploying an agent on Hugging Face, Streamlit, or LangChain + FastAPI

• Performance testing: latency & response quality

• Add observability using LangSmith or OpenTelemetry

• Live deployment of one agent end-to-end

• Tools:

  • Hugging Face Spaces, Streamlit, LangChain + FastAPI, LangSmith, Render / Replit

• Project / Case:

  • Deploy your own agent (e.g., Q&A bot or planner) on a cloud/no-code platform and test it live with users

• Why agent evaluation is hard

• Key metrics: task success, coherence, correctness, coverage, latency

• Logging & tracing basics

• Manual vs automated evaluation approaches

• Demo: Agent tracing and error inspection using LangSmith

• Case review: Diagnosing agent failure (RAG or Planner)

• Hands-on: Design a custom evaluation rubric

• Activity: Fix a broken agent based on logs

• Tools:

  • LangSmith, PromptLayer, Autogen logs, LangChain Tracing, Gradio logs

• Project / Case:

  • Evaluate a given agent using a checklist or metric rubric; submit improvement recommendations and patch changes

• What is responsible AI?

• Risks with autonomous agents (bias, hallucinations, misuse)

• Data privacy and consent for agent interactions

• Group debate: Should AI agents make decisions independently

• Walkthrough: Designing a safety layer (rate limiting, content filtering)

• Review real-world agent failures and ethical breaches

• Tools:

  • OpenAI Moderation API, Guardrails AI, AI Fairness Checklist, Ethics Cards Toolkit

• Project / Case:

  • Scenario Design: Learners create an agent with built-in safety mechanisms (e.g., content moderation or intent validation); Document trade-offs between autonomy and control

• Agent use cases across domains (business, education, healthcare, customer support, research)

• ROI of agent adoption

• Success stories and failure lessons

• Demo: Business workflow automation agent (e.g., lead qualifier or research assistant)

• Group discussion: Analyse case studies

• Ideation: Brainstorm your domain-specific agent

• Interactive Q&A with instructor

• Tools:

  • OpenAgents, LangChain Hub, Flowise, CrewAI templates, Streamlit demos

• Project / Case:

  • Identify a relevant agent use case in your domain and outline a basic agent design with roles, tools, and outcomes

• What are low-code/no-code tools for agents?

• Pros and cons of visual pipelines

• Intro to Flowise, LangFlow, AutoGen Studio

• When to use low code over code

• Guided walkthrough: Build a multi-tool agent in Flowise or LangFlow

• Explore visual node linking, memory blocks, and prompt templates

• Live debugging with flow-based tools

• Tools:

  • Flowise, LangFlow, AutoGen Studio, OpenAgents (UI), LangChainHub visual flows

• Project / Case:

  • Assignment: Use Flowise to build a planner agent that fetches event info, stores it in memory, and gives recommendations. Learners submit a visual flow screenshot and agent output

• Project guidelines and success checklist

• Project templates: research agent, planner, assistant, tutor, etc.

• Tips on deployment & UI wrapping

• Project planning and peer idea reviews

• Demo: Step-by-step agent build with tools and memory

• Breakout rooms for mentorship support

• Final presentations & feedback

• Group reflection: what worked, what didn’t

• Instructor showcase of top submissions

• Tools:

  • LangChain, Flowise, CrewAI, OpenAI, Streamlit, Hugging Face, ChromaDB, Pinecone

• Project / Case:

  • Design, build, and demo a fully functional AI agent tailored to a use case (with RAG, memory, tools, and deployment)

• Limitations and Ethical Issues of Generative AI

• Social and Economic Impact and Responsible Generative AI

• Generative AI in Business: Trends, Ideas, and Implementation

• Generative AI: Impact and Opportunities for Career Growth

Yes. The Professional Certificate Programme in Agentic AI and Applications is offered by IITM Pravartak (the technology innovation hub of IIT Madras). This beginner-friendly programme enables learners to build AI agents using tools like LangChain, CrewAI, Hugging Face, and more, through domain expert-led weekly live sessions and few masterclasses delivered by IITM Pravartak Lead faculty.

You will work hands-on with 30+ cutting-edge tools and frameworks in Agentic AI, including:

• LangChain

• CrewAI

• AutoGen

• Flowise

• OpenAI APIs

• ChromaDB

• Hugging Face

• Pinecone

• Streamlit

These tools support the design and deployment of autonomous agents, vector-based search systems, and Retrieval-Augmented Generation (RAG) pipelines.

Absolutely. This programme is designed for beginners, including non-coders and professionals from domains like finance, HR, marketing, and education. The curriculum begins with Python fundamentals and gradually builds toward advanced Agentic AI concepts, making it ideal for anyone looking to upskill in the most in-demand artificial intelligence and machine learning capabilities.

IITM Pravartak, the technology innovation hub of IIT Madras, delivers this programme in collaboration with domain experts. It includes weekly live sessions with Domain Experts and a few masterclasses by IITM Pravartak Lead faculty, ensuring academic rigour and real-world relevance in every module.

Graduates will be equipped to take on roles such as:

• AI Agent Developer

• Prompt Engineer

• Automation Strategist

• AI Product Owner

• LLM Application Specialist

With growing demand in domains like finance, customer support, legal tech, and education, Agentic AI opens doors to future-proof, high-growth careers.

Unlike generic LLM or GenAI courses, this programme focuses on building intelligent agents that can autonomously use tools, store memory, retrieve documents, and interact through reasoning. You’ll learn how to implement agentic workflows using modular prompts, memory chains, and tool orchestration, which are not commonly covered in other short-term courses.

You’ll complete 20+ hands-on assignments and a final capstone project, where you’ll build your own deployable AI agent. Projects include creating document Q&A bots, itinerary planners, memory-enhanced assistants, and goal-based automation agents using LangChain, AutoGen, and Flowise.

Upon successful completion, you will receive a Certificate of Completion from IITM Pravartak (the tech innovation hub of IIT Madras). Additionally, you will earn 3 IBM digital certifications, adding strong global credibility to your AI portfolio.

You can apply directly through the official programme landing page. The application process is simple and includes flexible payment options.