Core Topics

• What is an AI agent: the perception → planning → action loop
• ReAct (Reason + Act): the foundational single-agent architecture
• Agent vs Chain vs Pipeline: when each pattern applies
• Building a ReAct agent from scratch using bare OpenAI API
• Thought-action-observation cycle: understanding agent step traces
• Agent failure modes: loops, hallucinated tool calls, context overflow
• LangChain AgentExecutor: wrapping tools and the underlying loop

Tools & Tech

Learning Outcomes

• Build a ReAct agent loop from scratch that reasons about a task and selects tools iteratively until it reaches a correct answer — without a framework hiding the internals.

Core Topics

• OpenAI function calling: schema definition, tool selection, result handling
• Tool design principles: single responsibility, typed inputs/outputs, idempotency
• Building custom tools: web search (Tavily), Python REPL, file read/write, HTTP calls
• Parallel function calling: handling multiple simultaneous tool requests
• Error handling in tool results: graceful degradation strategies
• Pydantic tool schemas: generating OpenAI-compatible JSON schemas automatically
• Security considerations: what tools should and should not be able to do

Tools & Tech

Learning Outcomes

• Build a custom toolbox of 4+ tools (search, calculator, file I/O, HTTP) with Pydantic-typed schemas, and wire them into an agent that selects and calls tools autonomously.

Core Topics

• Planning strategies: chain-of-thought planning, plan-and-execute pattern
• Plan-and-Execute agent: the planner model vs the executor agent split
• Short-term memory: in-context conversation history management
• Long-term memory: semantic memory with vector stores, episodic storage
• External memory with Zep and mem0: storing and retrieving user context
• Memory compression: summarising long conversation histories automatically
• Handling context window limits in long-running agentic tasks

Tools & Tech

Learning Outcomes

• Build an agent with both short-term conversation memory and long-term semantic memory — one that remembers facts across sessions and plans multi-step tasks explicitly.

Core Topics

• CrewAI concepts: Crew, Agent, Task, Process (sequential vs hierarchical)
• Defining agent roles, backstories, and goals for specialised behaviour
• Task delegation: sequential task pipelines and task context passing
• Hierarchical process: a manager agent assigns tasks to specialist agents
• Inter-agent communication: how agents share output as context
• Custom CrewAI tools and integrating third-party APIs as tools
• Building a research and writing crew: researcher, analyst, writer agents

Tools & Tech

Learning Outcomes

• Orchestrate a 3-agent CrewAI crew (researcher, analyst, writer) that autonomously researches a topic, synthesises findings, and produces a structured report.

Core Topics

• Why LangGraph: stateful, cyclical graphs vs sequential chains
• LangGraph fundamentals: StateGraph, nodes, edges, and conditional routing
• Defining agent state: TypedDict state schema for shared memory
• Conditional edges: routing agent flow based on tool output or score
• Human-in-the-loop: interrupt before tool calls for human approval
• Persistence and checkpointing: resuming interrupted agent runs
• Subgraphs and modular agent composition in LangGraph

Tools & Tech

Learning Outcomes

• Design and implement a stateful LangGraph workflow with conditional branching, human-in-the-loop interrupts, and run persistence — demonstrating production agent architecture.

Core Topics

• AutoGen ConversableAgent: user proxy agents and AI assistant agents
• GroupChat: orchestrating multiple agents in a round-robin conversation
• GroupChatManager: controlling who speaks next in a multi-agent session
• Code execution agents: having agents write and run Python code autonomously
• Nested chats: agents triggering sub-conversations to complete sub-tasks
• AutoGen vs CrewAI vs LangGraph: a comparative analysis for team selection
• Building a code review pipeline with a coder agent and critic agent

Tools & Tech

Learning Outcomes

• Build an AutoGen GroupChat with a coder agent, a critic agent, and a user proxy — where the agents collaboratively write, review, and refine Python code autonomously.

Core Topics

• What is MCP: the open protocol for connecting AI models to external tools and data
• MCP architecture: host, client, server — and how they communicate
• Building an MCP server in Python: exposing resources, tools, and prompts
• MCP tools vs function calling: similarities and key differences
• Connecting an MCP server to Claude Desktop and other MCP-compatible clients
• MCP resources: serving dynamic context (database records, files) to AI models
• Security model in MCP: capability permissions and sandboxed execution

Tools & Tech

Learning Outcomes

• Build a working MCP server in Python that exposes 2+ tools and 1+ resource, and connect it to a Claude or compatible AI host for tool-augmented AI interactions.

Core Topics

• Why observability matters: diagnosing agent failures in production
• LangSmith tracing: capturing every LLM call, tool use, and token count per run
• AgentOps: session tracking, cost monitoring, and agent behaviour analytics
• Agent evaluation: success rate, average steps to completion, cost per task
• LLM-as-judge evaluation for agent output quality
• Capstone project: design and deploy an autonomous workflow agent with full observability
• Agent safety: rate limiting, cost caps, approval gates for high-stakes actions

Tools & Tech

Learning Outcomes

• Deploy an observed, evaluated, production-ready autonomous agent workflow — with LangSmith or AgentOps tracing, an LLM-as-judge evaluation suite, and a live public endpoint.