Building Scalable Multi-Agent Systems
From first principles to production. Learn how to design, build, deploy, and operate real AI agent systems with LangChain, LangGraph, memory, tools, and a control plane — using a single running example: a company-wide "Jarvis" assistant.
What you'll be able to do at the end
- Explain what an LLM agent is, when to use one, and when not to.
- Design a multi-agent system: pick the right architecture (supervisor, network, hierarchical, swarm).
- Wire agents to tools so they take real actions in the real world (APIs, databases, external services).
- Give agents memory — both short-term (a conversation) and long-term (facts they learn about users and the org).
- Add human-in-the-loop approvals before risky actions execute.
- Deploy agents behind a control plane (LangGraph Platform / Server) and scale them.
- Observe, evaluate, and harden agents for production (LangSmith, evals, security, cost).
- Build "Jarvis" end-to-end as your portfolio capstone.
Who this is for
You're technical-adjacent or technical — comfortable with at least one programming language (this course shows both Python and TypeScript, switchable from the sidebar). You don't need prior ML experience. We start from "what is an agent" and build to "deploy a horizontally-scaled multi-agent service with a control plane and human approvals."
The course at a glance
Foundations: agents & the loop ✓
What an LLM agent really is. The ReAct loop. Workflows vs. agents. Why multi-agent.
The orchestration ecosystem ✓
LangChain vs. LangGraph vs. LangSmith vs. LangGraph Platform — the layer cake.
Your first agent ✓
Models, messages, prompts, structured output. Build a working single agent.
LangGraph core ✓
State, nodes, edges, conditional routing. Build the agent loop as a graph you control.
Tools & taking actions ✓
Define tools, call APIs, handle errors. Make the agent actually do things.
Memory & state ✓
Short-term (threads, checkpointers), long-term (the store), semantic/episodic/procedural memory.
Multi-agent architectures ✓
Supervisor, network, hierarchical, swarm. Build Jarvis as a supervisor over specialists.
Human-in-the-loop & guardrails ✓
Interrupts, approvals, breakpoints, time-travel. Safety before destructive actions.
Control plane & deployment ✓
Control vs. data plane. LangGraph Platform/Server. Assistants, threads, runs, scaling.
Observability & evaluation ✓
LangSmith tracing, datasets, online + offline evals. How you know the agent works.
Production hardening ✓
Security, prompt injection, auth, cost, streaming, testing, reliability.
Capstone: build Jarvis ✓
Assemble every piece into a deployable company-wide assistant. What to build next.
The running example: "Jarvis"
Throughout the course we build one product: Jarvis, an organisation-wide AI assistant for a fictional 200-person company called Acme Robotics.
An employee says: "Jarvis, the printer on floor 3 is jammed again, and can you book the small conference room tomorrow at 2 PM with Priya?" — and Jarvis files an IT ticket, schedules the meeting, and updates the employee.
Behind that single user interface is a supervisor agent delegating to specialist agents (IT helpdesk, HR, calendar, company-knowledge), each with its own tools, memory, and approval rules — running behind a control plane.
Every module advances Jarvis one step. By Module 12 you've built and deployed the whole thing.
How to use this course
- Go through modules in order — each builds on the last.
- Use the Python / TypeScript switch in the sidebar to pick your language. All code blocks change with one click.
- Each module ends with a quiz. Take it — it's the difference between "I read this" and "I understood this".
- Click Mark module complete at the bottom. Your progress is saved in your browser's localStorage and persists across sessions.
- Don't just read — actually build. Set up the environment below before starting Module 3.
Environment setup
You'll write real code starting in Module 3. Set this up now.
Python (recommended for AI work in 2026)
# 1. Install Python 3.11+ from python.org if you don't have it
python3 --version
# 2. Create a project
mkdir jarvis && cd jarvis
python3 -m venv .venv
source .venv/bin/activate # on Windows: .venv\Scripts\activate
# 3. Install the core libraries used across this course
pip install -U \
langchain \
langchain-anthropic \
langchain-openai \
langgraph \
langgraph-checkpoint-sqlite \
langsmith \
pydantic
# 4. Set your API keys (replace with real values, or put in a .env file)
export ANTHROPIC_API_KEY="sk-ant-..."
export OPENAI_API_KEY="sk-..."
export LANGSMITH_API_KEY="lsv2-..."
export LANGSMITH_TRACING="true"
export LANGSMITH_PROJECT="jarvis-course"// 1. Install Node 20+ and npm/pnpm
node --version
// 2. Create a project
mkdir jarvis && cd jarvis
npm init -y
npm pkg set type=module
// 3. Install the core libraries used across this course
npm install \
langchain \
@langchain/core \
@langchain/anthropic \
@langchain/openai \
@langchain/langgraph \
@langchain/langgraph-checkpoint-sqlite \
langsmith \
zod
npm install -D typescript tsx @types/node
npx tsc --init
// 4. Set your API keys (in your shell or a .env file)
export ANTHROPIC_API_KEY="sk-ant-..."
export OPENAI_API_KEY="sk-..."
export LANGSMITH_API_KEY="lsv2-..."
export LANGSMITH_TRACING="true"
export LANGSMITH_PROJECT="jarvis-course"You only need one model provider key to follow the course. Anthropic (Claude) is the default in code samples, but every example also works with OpenAI by swapping the model class. We cover provider choice in Module 3.
LangChain and LangGraph evolve fast. The code shown here uses idiomatic, current-stable APIs at time of writing. If a method signature has shifted slightly when you read this, check docs.langchain.com and the LangGraph docs for the latest exact call — the concepts are stable even when names move.
Ready?
Start with Module 01 — Foundations →