Track 2: Agentic AI

From talking to AI to building with it- the FDE Courseline's core AI track.

What This Track Covers

An agent, in this track's sense, is an AI system that doesn't just answer a question once — it can hold context across a conversation, decide to use tools (like searching a document or calling an API), remember what happened earlier, and work toward a goal over multiple steps. Right now you've probably used AI chat tools. This track teaches you to build the systems behind them.

You'll start from the basics — what a large language model (LLM) actually is and how it generates text — and progressively add capability: reliable prompting, memory across turns, the ability to look up real information instead of guessing, the ability to call external tools, and finally coordinating multiple agents together. Each submodule adds one capability on top of the last. By the end, you won't just know the vocabulary of "agentic AI" — you'll have built the core loop yourself.

Why This, Why Now

Forward Deployed Engineers increasingly build software with AI models embedded inside it — a customer-facing chatbot that needs to answer from their internal docs, an internal tool that automates a multi-step workflow, an assistant that needs to call the customer's APIs safely. None of that works if you only know how to send a prompt and read a reply; you need to understand why an agent forgets things, why it hallucinates an answer instead of looking it up, and how to give it safe, limited "hands" to act in the real world. This track builds that understanding in the same order you'll need it on the job: foundations first, then reliability, then memory, then grounding in real data, then action, then coordination.

Prerequisites

Programming Fundamentals (Track 1) — you should be comfortable with variables, functions, and control flow (if/else, loops) before starting. No machine learning background is assumed or required; every ML-adjacent concept (embeddings, vectors, tokens) is explained from scratch when it's introduced.

The Submodules, In Order

Each module builds directly on the one before it — skipping ahead will leave gaps, since later modules assume the mental model from earlier ones.

1. FDE 2.01 — AI & Agents: From Talking to AI to Building One (Core) Starts from zero: what an LLM is, how it predicts text, and what turns a plain chat model into an "agent" — a loop of think → act → observe that repeats until the goal is done. Everything else in this track is a refinement of this one loop.
2. FDE 2.02 — Prompt & Context Engineering (Core) An agent is only as reliable as the instructions and context you give it. This module teaches how to design prompts and structure context so the model's behavior is consistent and predictable, instead of a coin flip.
3. FDE 2.03 — Agent Memory Systems (Core) LLMs don't remember anything by default — every request starts from a blank slate. Here you'll learn how agents fake memory: short-term (recent conversation), long-term (facts saved across sessions), and how conversational state is tracked so an agent doesn't "forget" what you told it two turns ago.
4. FDE 2.04 — Retrieval-Augmented Generation (RAG) (Core) Instead of the model guessing from what it was trained on, RAG lets it look up real, current information before answering — using embeddings (numeric representations of meaning) and vector search (finding the closest matching text) to ground responses in actual documents.
5. FDE 2.05 — Tool Use & Function Calling (Core): Gives the agent "hands" — the ability to call a function, hit an API, or run a calculation instead of just generating text about it. This is the module where agents start actually doing things, not just describing them.
6. FDE 2.06 — Multi-Agent Orchestration & Workflows (Core): The capstone. You'll combine everything — memory, retrieval, tool use — to coordinate multiple agents working together on a larger task, the way production FDE systems are often structured.