Open slot

Put your brand on Agentic Training.

No company owns this course yet. Buy Agentic Training and we replace this dashed box with your logo. We reply with pricing and how the brand goes live.

Agentic
Training

Ship agents from first principles.

A 6-week leveling course: LLM components, hand-built loops, then production systems in Python and TypeScript.

The bar

From “I’ve used ChatGPT” to a portfolio of working agents.

Students leave with engineering habits agents demand—evals, tracing, guardrails. Experienced engineers apply habits they already have to a new kind of component. Same finish line, whatever your start.

Method

Primitives before frameworks.

Build the agent loop by hand once. Measure behaviour from week one. Ship something every phase. Climb complexity only when the problem demands it.

  1. 01

    Understand the component

    Tokens, sampling, tools, cost, and failure modes—before you glue libraries together.

  2. 02

    Build the loop yourself

    Observe → plan → act → reflect, written line by line so frameworks never feel like magic.

  3. 03

    Ship and operate

    Evals, tracing, MCP, multi-agent tradeoffs, and a production-grade final project.

Six weeks

Lessons, labs, and projects that compound.

Interactive demos, bilingual code, quizzes, and an AI tutor on every unit—intensive at ~15 hours a week, or stretch to a semester pace.

  1. Week 1

    LLMs, tools, and retrieval

    Treat the model as a component with an API, a price and predictable failure modes. Then give it tools and search over your own documents.

    9 lessons · 1 lab · 1 project

    You cover

    • Tokens, context windows and cost
    • Sampling and model tiers
    • Prompting and structured output
    • The tool-calling cycle
    • Embeddings, hybrid search and reranking
    • Your first eval

    You build

    • Lab 1

      Raw API calls and a structured extractor. Call a model over plain HTTP with no SDK, then turn messy text into validated, typed data and measure how often it gets it right.

    • Project 1

      Docs assistant. Question answering over documents you know well, with retrieval exposed to the model as a tool.

  2. Week 2

    Agents by hand

    Build every workflow pattern and the agent loop from raw API calls. No frameworks this week, so nothing is a mystery later.

    9 lessons · 1 lab · 1 project

    You cover

    • Chaining, routing and parallelization
    • Orchestrator-workers and evaluator-optimizer
    • The agent loop and ReAct
    • Stop conditions and budgets
    • Tool design as API design
    • Sandboxing tools

    You build

    • Lab 2

      Workflow patterns side by side. Solve one task five ways, measure each, and see when each pattern pays off.

    • Project 2

      Mini coding agent. A coding agent with no framework that takes a small repository and a failing test, and makes the test pass.

  3. Week 3

    Planning and memory

    Make agents plan, check their own work and remember, while keeping what enters the context window relevant.

    8 lessons · 1 lab · 1 project

    You cover

    • Plan-and-execute and re-planning
    • Reflection and self-critique
    • When to pay for reasoning
    • Compaction and long-term memory
    • Context engineering
    • Sub-agents for context isolation

    You build

    • Lab 3

      Planner and reviewer. Add planning and review to your coding agent and measure whether they help.

    • Project 3

      Research agent. Researches a question across web sources, writes a cited report and remembers what it learned between sessions.

  4. Week 4

    Frameworks and MCP basics

    Port your hand-built agent to two frameworks with different philosophies, then learn how MCP connects agents to tools and data.

    9 lessons · 1 lab

    You cover

    • Why frameworks, and when not
    • Graph-based: LangGraph
    • Loop-based: OpenAI and Claude agent SDKs
    • TypeScript-first: Vercel AI SDK and Mastra
    • Durable state and human-in-the-loop
    • MCP: tools, resources and prompts

    You build

    • Lab 4

      Port Project 2 to two frameworks. Re-implement your coding agent in two frameworks and compare all three versions on the same benchmark.

  5. Week 5

    Protocols and multi-agent

    Take MCP remote, connect agents to each other over A2A, and find out when a multi-agent design is worth what it costs.

    6 lessons · 2 projects

    You cover

    • Transports and remote servers
    • MCP authorization
    • A2A: agent cards and tasks
    • Multi-agent patterns
    • The cost of multi-agent
    • When multi-agent wins

    You build

    • Project 4

      MCP server for a real system. A production-quality MCP server for a system you know: tested, documented and used from two hosts.

    • Project 5

      Multi-agent system. A supervisor-led system for a breadth-first task, with numbers showing whether it beats a single agent.

  6. Week 6

    Production and wrap-up

    The work that separates a demo from a product: evals, tracing, security and cost, applied to an agent you already built.

    10 lessons · 1 lab · 1 project

    You cover

    • Eval layers, graders and datasets
    • Evals in CI
    • Tracing and reliability
    • Prompt injection and least privilege
    • Human approval gates
    • Cost, latency and deployment

    You build

    • Lab 6

      Red-team your agent. Attack your own agent with 20 prompt-injection attempts, add defences and measure again.

    • Project 6

      Production hardening. Take an earlier project to production grade: eval scores, threat model, cost per task and a runbook.

Agentic Training

Sign in with a magic link and pick up at your week—progress stays with your account.

Start learning