Practical Agentic AI: Building Intelligent Agents

Description:

This three-day, hands-on course introduces participants to the emerging field of agentic AI—systems that can reason, plan, and act autonomously. Using the OpenAI SDK, learners will design agents that interact with tools, maintain context, and execute multi-step goals. Through guided labs and projects, participants will develop a deep understanding of the core patterns that underpin agentic behavior, including reasoning loops, planning, reflection, and memory.

The course culminates with an introduction to multi-agent orchestration with LangGraph, offering a preview of how these concepts scale into collaborative and production-ready systems. By the end, learners will be equipped to design, build, and evaluate intelligent agents capable of meaningful autonomous action.

Duration: 3 Days

Course Code: BDT 527

Learning Objectives:

After this course, you will be able to:

1. Explain the key concepts and architecture of agentic AI systems
2. Build reasoning agents using the OpenAI SDK and function calling.
3. Apply common agentic design patterns such as ReAct, Plan–Execute, and Reflection.
4. Integrate tools, memory, and external data sources into autonomous workflows
5. Implement and evaluate multi-step reasoning loops for practical applications
6. Understand when and how to extend SDK-based agents using LangGraph
7. Design reliable, interpretable, and safety-aware agentic systems for real-world tasks

Familiarity with Python programming and a basic understanding of APIs

Course Outline:

Day 1 – Foundations of Agentic AI

Learning goals:

• Understand what “agentic AI” means in practice
• Grasp the OpenAI SDK as the foundation of agent behavior
• Write agents that reason and act

Core topics:

• The Agentic Model: think → act → observe → adjust
• Degrees of Autonomy
• Agentic AI Applications
• Decomposing a Task for Agentic AI
• Common Design Patterns:
• ReAct
• Plan–Execute
• Reflection
• Overview of the OpenAI SDK: Assistants, messages, and functions
• The anatomy of an agent loop (reason–act–observe)
• Practical exposure to tools (retrieval, code execution, function calling)
• Building an agent that uses a tool (e.g., web search, MCP)

Hands-on labs:

• Create a reasoning agent using OpenAI’s SDK.
• Add one tool: function or API call.
• Observe and explain its decision steps.

Day 2 – Building Agentic Behavior: Memory, Tools, and Autonomy

Learning goals:

• Extend agents with memory, multiple tools, and goal-directed reasoning
• Understand the principles of evaluation, reliability, and safe autonomy
• Learn to chain decisions and responses within the SDK

Core topics:

• State and memory: how agents remember context and past actions
• Tool orchestration: context-aware selection
• Error handling and guardrails: keeping autonomy reliable
• Evaluation and logging: traces and workflow analysis
• Integrating with external data (e.g., retrieval-augmented generation, APIs)

Hands-on labs:

• Build an assistant that plans a multi-step task (e.g., data analysis, research)
• Add short-term memory (context tracking) and simple reasoning traces
• Evaluate success and failure cases

Day 3 – Multi-Agent Systems: Coordinating Workflows

Learning goals:

• Consolidate understanding of SDK-level agency through a project
• Understand the conceptual leap to multi-agent systems
• Get a guided preview of LangGraph and its design philosophy

Core topics:

• Planning a practical agent system end-to-end
• Introduction to LangGraph: graphs as stateful workflows for agents
• Nodes, edges, and control flow: the logic of orchestration
• How LangGraph builds on the OpenAI SDK
• LangGraph for persistent agents, collaboration, workflow management

Hands-on labs:

• Build and coordinate multiple SDK-based agents
• Guided demo: LangGraph workflow, coordinating two agents (e.g., “researcher” and “summarizer”).
• Discuss design trade-offs and extensibility

Training material provided: Yes (Digital format)