Certification in Agentic AI Program

Python Programming:

Build fluency in variables, data types, conditions, loops, collections, functions and modules so learners can solve problems and write reusable programs independently.

Files, Errors and Type-Safe Code:

Work with files, exceptions and type hints while learning to structure programs that are easier to understand, validate and maintain.

Debugging and Testing:

Use systematic debugging, assertions and introductory automated tests to identify failures rather than relying on trial-and-error coding.

Developer Workflow:

Set up notebooks, VS Code and the command line, and use Git and GitHub to manage code, changes and reproducible technical work.

APIs and Data Acquisition:

Understand HTTP, REST and JSON, and use Python requests, environment variables and API credentials to work safely with external data sources.

Data Preparation:

Use NumPy, Pandas and basic SQL to inspect, clean, transform and combine data before it enters a machine learning or AI workflow.

Machine Learning Fundamentals:

Understand supervised and unsupervised learning, features and targets, regression and classification, and how real questions become measurable learning tasks.

Transformer and LLM Foundations:

Build a high-level mental model of tokenisation, embeddings, positional information, self-attention and decoder-only transformers, without entering unnecessary mathematical detail.

Pre-Training and LLM Limitations:

Connect next-token pre-training and instruction tuning to hallucination, prompt sensitivity, context limits, stale knowledge and non-determinism, establishing why LLM systems require evaluation and control.

LLM APIs and Prompt Design:

Call language models through APIs and structure instructions, messages, context and examples while decomposing complex tasks into manageable steps.

Structured Outputs and Reliability:

Generate schema-constrained outputs, validate responses, handle failures and balance quality against context, latency and cost.

Agentic Workflow Design:

Understand degrees of autonomy, task decomposition and the difference between deterministic workflows and systems that dynamically decide their next action.

Tools and Structured Actions:

Implement tools as typed Python functions with validated inputs, outputs and error handling before introducing any agent framework.

Reason + Act (ReAct):

Build the reasoning-action-observation loop in raw Python so an agent can select a tool, use its result, iterate and stop under explicit conditions.

Reflection and Planning:

Introduce generator-critic, evaluator-optimizer and plan-and-execute patterns for controlled iteration, feedback and replanning.

Early Agent Evaluations:

Define success criteria, create representative test cases and use basic error analysis to compare agent behaviour across system versions.

Embeddings, Retrieval and RAG:

Represent meaning with embeddings and build grounded LLM responses over chunked documents using semantic retrieval, metadata, source evidence and citations.

RAG Quality:

Recognise chunking, retrieval and grounding failures and apply introductory checks for retrieval relevance and answer faithfulness.

LangChain Essentials:

Use model, prompt, structured-output, retriever and tool abstractions to rebuild first-principles LLM and agent workflows with reusable components.

LangGraph and Stateful Orchestration:

Represent execution through nodes, edges, state and conditional routing, with introductory checkpointing and human intervention.

Agent State and Memory:

Distinguish context, state and memory while introducing short-term and long-term memory, persistence, summarisation, context trimming and basic privacy considerations.

Advanced Agent Patterns:

Design reflection, evaluator-optimizer and plan-and-execute systems with feedback, measurable stopping criteria and recovery after failure.

Robust Tool Engineering:

Create typed tool contracts with validation, permissions, timeouts, retries, rate-limit handling, idempotency and deterministic test doubles.

Eval-Driven Improvement:

Measure tool use, retrieval, intermediate decisions and outcomes, then classify failures and prioritise changes using quality, latency and cost evidence.

Advanced LangGraph Orchestration:

Design state schemas, subgraphs, parallel branches and controlled transitions for complex workflows whose execution remains inspectable and testable.

Durable Execution and Human Control:

Use checkpointing, recovery and interrupts to pause long-running workflows for approval, editing, rejection or additional input.

Memory Architecture and Safety:

Design short-term and long-term memory with write and retrieval policies, consolidation, forgetting, user isolation and tests for accuracy, privacy and poisoning.

Advanced Retrieval and Data Agents:

Apply hybrid retrieval, reranking, query decomposition, citation verification and guarded SQL access to build reliable agents over enterprise knowledge.

Production FastAPI:

Structure authenticated, typed and versioned agent APIs with validation, streaming, consistent error contracts and secure configuration.

Asynchronous Agent Services:

Support background jobs, task status, database persistence and long-running operations using asynchronous execution patterns.

Containers and Deployment:

Package services with Docker, configure deployment environments and add health checks and reproducible runtime settings.

Model Context Protocol:

Understand MCP hosts, clients, servers, tools, resources and prompts, and build permission-aware integrations with external data and services.

Multimodal Agents:

Introduce document, image, OCR and audio workflows, multimodal structured outputs and the additional storage, context and evaluation challenges they create.

Multi-Agent Design:

Choose between single-agent and multi-agent architectures and design specialist, supervisor, router, handoff and delegation patterns for justified use cases.

Coordination and Reliability:

Manage message passing, shared state, context isolation, parallel execution and failures such as circular delegation, deadlocks and runaway work.

Multi-Agent Evaluation:

Evaluate delegation quality, specialist performance, communication efficiency and end-to-end outcomes across coordinated agent workflows.

Agent-to-Agent Protocol:

Use Agent Cards, discovery, messages, tasks, parts, artifacts and task lifecycles to connect independently hosted agentic systems.

Distributed Agent Communication:

Implement authenticated, streaming and asynchronous A2A interactions and combine A2A agent collaboration with MCP-based tool access.

Advanced Evaluations:

Build component, trajectory, retrieval, memory and multi-agent evaluation suites using deterministic assertions, calibrated LLM judges and human review.

Regression and Adversarial Testing:

Use simulation, regression datasets and adversarial cases to detect behavioural changes and expose weaknesses before deployment.

Agent Security:

Address direct and indirect prompt injection, excessive agency, unsafe tool use, sensitive-data exposure, least privilege, sandboxing and approval boundaries.

Observability and Optimisation:

Trace model and tool activity, inspect state transitions and monitor latency, token use and cost while applying caching, routing and fallback strategies.

Production Operations:

Use CI/CD, automated quality gates, load and reliability testing, configuration versioning, rollback strategies and monitoring to operate deployed agent services.