Course · MultilingualIntermediateStage 1 of AI & Agent Engineering

Agent Engineering in Java: From LLM Foundations to Production Systems

Build agents. Understand the architecture. Engineer for production. Learn to design, build and own a production AI agent in Java, from one model call to a durable, observable, secured system you operate through real incidents.

Offered byTarkev
  • 16 modules
  • 136 lessons
  • 24 weeks
  • Multilingual
  • Fumu in every lessonAsk Fumu inside any lesson. It explains the material using the lesson you are on.
  • A verified certificate on your recordSoonAdded to your public profile the day you finish, tied to your verified identity.
Course overview

About this course

Most agent courses teach you to make an agent work. This one teaches you to own one in production.

You will build one system through the whole course: the Order Support Assistant, which answers order questions, cancels and refunds within policy, retrieves return rules, and asks a person before it does anything it cannot undo. It is never thrown away. Every module adds a capability and a new way for it to break, and the capstone is the same system, hardened and run under traffic.

Every lesson asks you to make a decision, not just write code: whether a task needs an LLM, a tool, an agent, retrieval or several agents at all, and what the cheaper deterministic alternative would cost. You will list what can fail and how you would know, trace every model call and tool call from the first module, and keep the documents real teams keep: an architecture doc, an ADR log, a failure and threat register, a runbook, an evaluation set, a cost ledger and postmortems.

You build the mechanism before you use the tool that hides it. You call the provider's API directly before LangChain4j, write the agent loop, budgets and retries yourself before Spring Boot packages them, and build checkpoint and resume by hand before Temporal makes execution durable. That way you can judge when a framework helps and when it is overkill.

You are assessed the way engineering teams assess senior engineers: through decision memos, design reviews, incident drills with postmortems, and evaluation-driven changes. Code that runs is the entry ticket, not the grade.

The course has a core path and optional depth lessons, and four credentials along the way: Foundations after Module 2, Reliable Agent after Module 5, Production Agent after Module 12 and Agent Engineer after the capstone.

Curriculum

16 modules · 136 lessons
1Orientation2 lessonsThe whole system in miniature before the foundations begin. In one sitting you run the starter repository, make one model call, give the model one tool, and read the trace of the run end to end. Nothing is explained in depth yet; the point is to see the destination, the Order Support Assistant you will build and own for the rest of the course, and the artifacts you will keep alongside it.
  1. 1.1 The Whole System in One HourVideo and reading · 48 min
  2. 1.2 Module 1 Model Answers: Lesson 1.01Reading
2LLM Foundations12 lessonsWhat changes when part of a system is probabilistic. You learn how a model reads tokens and messages, how providers and APIs expose it, how prompts and structured outputs shape its behaviour, and where it fails. The module ends with the prototype of the Order Support Assistant: one traced model call that classifies a support request into a validated result, the first entry in the cost ledger, version 0 of the architecture doc, and a decision memo on whether an LLM or plain rules should do the classification.
  1. 2.1 From Traditional Software to LLM-Powered SystemsVideo and reading · 23 min
  2. 2.2 Tokens, Tokenization, and Context WindowsVideo and reading · 30 min
  3. 2.3 Messages and the LLM Conversation ModelVideo and reading · 25 min
  4. 2.4 How LLM Generation WorksVideo and reading · 20 min
  5. 2.5 Models, Providers, and LLM APIsVideo and reading · 28 min
  6. 2.6 Prompts, Instructions, and Model BehaviorVideo and reading · 32 min
  7. 2.7 Structured OutputsVideo and reading · 35 min
  8. 2.8 Embeddings and Semantic RepresentationVideo and reading · 20 min
  9. 4 more lessons in this module
3Tool Calling and Structured Interaction13 lessonsThe model gets its first capabilities, and you decide which ones it must never have. You specify tool contracts before coding them, run the tool-calling lifecycle by hand, enforce validation, authorization and least privilege in application code, and handle errors, timeouts and retries with idempotent side effects. The failure-mode and threat register and the first evaluation cases start here. The module ends with Design Review 1 and the Foundations credential.
  1. 3.1 From Structured Output to Tool CallingVideo and reading · 25 min
  2. 3.2 Tool Definitions, Descriptions, and SchemasVideo and reading · 30 min
  3. 3.3 The Tool Calling LifecycleVideo and reading · 28 min
  4. 3.4 Returning Tool Results to the ModelVideo and reading · 28 min
  5. 3.5 Designing Good Tools for LLMsVideo and reading · 17 min
  6. 3.6 Validation and AuthorizationVideo and reading · 37 min
  7. 3.7 Least Privilege and the Tool PolicyVideo and reading · 33 min
  8. 3.8 Tool Errors, Timeouts, Retries, and IdempotencyVideo and reading · 34 min
  9. 5 more lessons in this module
4Agent Fundamentals9 lessonsWhen a single call is not enough, and when an agent is too much. You learn what makes a system agentic, choose between an LLM call, a workflow and an agent, and build the observe–decide–act loop with stopping conditions and an execution budget written before the loop is coded. Every step is traced, so loop count and budget use are visible. The module ends with the Order Support Assistant's agent loop and an ADR on workflow versus agent for the return flow.
  1. 4.1 What Makes a System AgenticVideo and reading · 25 min
  2. 4.2 LLM Application, Workflow, or Agent: Choosing the ShapeVideo and reading · 25 min
  3. 4.3 The Observe–Decide–Act LoopVideo and reading · 16 min
  4. 4.4 Agent State, Goals, and ObservationsVideo and reading · 18 min
  5. 4.5 Stopping Conditions and Execution BudgetsVideo and reading · 27 min
  6. 4.6 Bounded Autonomy and When Not to Use an AgentVideo and reading · 24 min
  7. 4.7 Building the Order Support Agent LoopVideo and reading · 37 min
  8. 4.8 Module 4 Model Answers: Lessons 4.01–4.04Reading
  9. 1 more lessons in this module
12 more modules · 100 lessons
After this course

Next on the AI & Agent Engineering roadmap

This course is in stage 1 of 2: Foundation.

Agent Engineering in Java: From LLM Foundations to Production SystemsSee the whole roadmap