Chelsea AI Ventures
Technical AI Training Developer Pathway 6 Weeks (Online, approx. 5-6 hours/week) or 3 Day Intensive (In-Person, London)

Developing Agentic Systems: The Next Frontier of AI

Move beyond Q&A bots. Design and build autonomous AI agents that can reason, plan, and use tools to accomplish complex tasks

Target Audience

The Advanced AI Engineer

Core Value

Design and build autonomous AI agents that can reason, plan, and use tools to solve complex problems

Key Differentiator

Features a deep-dive technical case study of the KirokuForms HITL architecture

Learning Objectives

  • Explain and implement core agentic design patterns like ReAct and Plan-and-Execute
  • Integrate external tools (APIs, custom functions) into LLM-based systems using function calling
  • Design and build complex, stateful, and cyclical agentic workflows using LangGraph
  • Implement Human-in-the-Loop (HITL) interruption points for oversight and verification
  • Architect and evaluate a multi-step AI agent capable of solving complex problems

Prerequisites

Completion of 'GenAI Application Development' or equivalent experience with LLM APIs, LangChain, and RAG.

Course Structure

Week 1: Introduction to Agentic Design Patterns

What makes an AI agent? Moving from chains to agents. Deep dive into the ReAct framework and other patterns.

Activities:

  • Implement basic ReAct agent
  • Compare different agent architectures

Week 2: Mastering Tool Use & Function Calling

The core of agentic capability. Define tools for LLMs, master function calling mechanics, build agents that use multiple tools.

Activities:

  • Build multi-tool agent
  • Implement error handling for tool failures

Weeks 3-4: Building Multi-Agent Systems with LangGraph

Week 3: LangGraph fundamentals - state management, nodes, edges. Week 4: Complex graphs, multi-agent collaboration workflows.

Activities:

  • Build stateful agent with LangGraph
  • Implement multi-agent collaboration system

Week 5: Case Study Deep Dive - KirokuForms HITL Architecture

Exclusive look at production architecture. Dissect real-world LangGraph implementation with human verification checkpoints.

Activities:

  • Analyze KirokuForms architecture diagrams
  • Implement HITL patterns from the case study

Week 6: Advanced Topics: Evaluation and Debugging

Strategies for evaluating agent performance, debugging complex graphs, managing the 'runaway agent' problem.

Activities:

  • Build agent evaluation framework
  • Debug complex agent behaviors

Topics Covered

AI agent fundamentals and theory
ReAct and Plan-and-Execute patterns
Tool use and function calling
LangGraph framework deep dive
State management in agent systems
Multi-agent collaboration patterns
Human-in-the-Loop (HITL) design
Production agent architectures
Agent evaluation strategies
Debugging non-deterministic systems
Safety and control mechanisms
Real-world case study analysis

Capstone Project

Design and build a multi-step AI research agent using LangGraph that autonomously gathers information, synthesizes it, and produces a final report.

Why This Course Matters

The next wave of AI isn’t about better answers—it’s about autonomous action. While most developers are still building chatbots, the frontier has moved to agents that can plan, use tools, and accomplish complex multi-step tasks with minimal human intervention.

This isn’t science fiction. Companies are deploying agents that handle customer service escalations, conduct market research, write and debug code, and manage complex workflows. The developers who can build these systems are writing their own tickets in today’s job market.

What Makes This Course Different

This is the only course that provides an insider’s view of a production agentic system. You’ll get exclusive access to the technical architecture behind KirokuForms, including the LangGraph implementation and Human-in-the-Loop patterns we use to ensure reliability.

You won’t just learn theory—you’ll see how these patterns work in a real system processing thousands of requests. This isn’t a toy example or a simplified demo. It’s the actual architecture that powers a production application.

Course Philosophy

We believe the future of AI development lies in building systems that can think and act, not just respond. This requires a fundamental shift in how we design AI applications—from linear pipelines to dynamic, stateful graphs.

Throughout this course, we emphasize practical patterns over academic theory. Every concept is grounded in real-world requirements: How do you prevent agents from going rogue? When should you interrupt for human oversight? How do you debug non-deterministic behavior?

Who Should Take This Course

This course is designed for:

  • Experienced developers ready for the cutting edge of AI
  • Engineers who’ve built LLM applications and want to go deeper
  • Researchers interested in practical agent implementation
  • Architects designing next-generation AI systems
  • Anyone who wants to build AI that acts, not just answers

You should be comfortable with Python, have experience with LLMs and ideally LangChain, and be ready for advanced concepts. This is not an introductory course.

If you’re ready to build the future of autonomous AI, this course provides the advanced training and real-world insights you need.

Ready to transform your team?

Contact us to discuss custom training solutions or group enrollment options.

Discuss Training Needs