Agentic AI

What a program is and how to run your first one

Storing values in variables, and why text and numbers behave differently

Making decisions with if, else and comparisons

Storing many values in a list

Looking things up by name with dictionaries

Doing something to every item with loops

Writing your own functions

Reading errors without panic

Finding the mistake in your own code

Saving your code in a file and running it

Importing code other people have written

Giving each project its own environment

Talking to your computer with the terminal

Saving your work with Git

Putting your work on GitHub

What an array is, and why a list is not enough

Picking out pieces: indexing and slicing, including two dimensions

Maths on a whole array at once, and where you go next

Getting Started with Python for AI

Setting Up Your Claude API Key

Python Essentials for AI Agents

Your First Agent: Hello World

Git & Reproducible Environments for Agentic Projects

Agentic Architecture: Perception → Reasoning → Planning → Action

Building an LLM-Powered Agent

Tool Use and Function Calling

Short-Term Memory and Context Management

Long-Term Memory and Knowledge Systems

Chain-of-Thought and Reasoning Frameworks

Reflection and Self-Correction

Multi-Step Planning

Debugging and Tracing Agent Behavior

Structured Output and Parsing

Agent Types: Reactive, Deliberative, and Hybrid

Guardrails and Safety Constraints

State Persistence and Versioning

Cost Optimization for Agentic Systems

Retrieval-Augmented Generation (RAG) in Agents

Function Calling and Tool Selection

Handling Uncertainty and Asking for Clarification

Agent Personas and Role-Playing

Context-Aware Behavior Adaptation

Reward Modeling for Agents

Real-Time Information Processing

Agent Introspection and Explainability

Learning from Human Feedback

Agent Constraints and Resource Limits

Decision-Making Under Uncertainty

Observability and Monitoring

Cost Optimization at Scale

Agent Debugging and Tracing

Multi-Provider Architecture

Rate Limiting and Backpressure

Handling Provider Outages

Compliance and Regulatory Considerations

A/B Testing and Experimentation

Security and Red Teaming

Performance Optimization Techniques

Agent Governance and Approval Workflows

Scalability and Load Testing

Knowledge Base Integration

Evaluation Metrics and KPIs

Incident Response and Postmortems

Multi-Agent Communication Patterns

Agent Teams and Role Assignment

Consensus and Voting Mechanisms

Agent Cooperation and Competition

Resource Sharing and Load Balancing

Agent Learning from Collective Experience

Agent Negotiation and Conflict Resolution

Distributed Decision-Making

Agent Supervision and Oversight

Agent Metrics and Health Monitoring

Hierarchical Agent Structures and Task Delegation

State Synchronization Across Agents

Failure Recovery and Resilience

Emergent Behaviors and Swarm Dynamics

Production Multi-Agent Architecture and Evaluation

Why MCP: The M×N Integration Problem

MCP Architecture: Hosts, Clients, Servers & the Lifecycle

Tools: Exposing Capabilities to the Model

Resources & Prompts: Context and Templates

Sampling, Roots & Elicitation: Inverting Control

MCP Security: Trust, Tool Poisoning & OAuth 2.1

A2A & the Protocol Landscape: Agent-to-Agent + Observability

Hierarchical Task Network Planning for Agents

Constraint Satisfaction: Modeling and Propagation

Scheduling and Resource Allocation Under Constraints

Plan Repair, Replanning, and Execution Monitoring

Hybrid LLM-Solver Architectures

Causal Graphs and Structural Causal Models for Agents

Interventions vs Observations: Acting with the do-Operator

Counterfactual Evaluation of Agent Decisions

World Models and Model-Based Simulation

Learning Causal Structure from Agent Traces

Event-Driven Agent Architectures and Streaming

Interruptibility, Turn-Taking, and Human-Agent Pairing

Shared State and Conflict Resolution in Collaborative Sessions

Autonomous Code Review: Static Analysis Meets LLM Judgment

Latency Engineering for Real-Time Agents

Sharded Agent Fleets and Work Distribution

Federated Learning Fundamentals for Agent Systems

Privacy-Preserving Aggregation and Secure Computation

Cross-Organization Agent Protocols and Trust

Consistency, Consensus, and Failure Recovery at Scale

Architecture Synthesis: Choosing the Right Agent Topology

SLOs, Capacity Planning, and Cost Engineering

Safety Cases, Approvals, and Guardrail Design

Incident Response and Postmortems for Agent Systems

Capstone Walkthrough: Shipping a Production Agent Platform