Models & agents
Attention, embeddings, positional encoding and transformer architecture; pretraining, fine-tuning and alignment; model APIs, reasoning limits and basic tool use.
EAG V4
Engineering AGents Program
BUILD AGENTS.DELIVERRELIABLY.
Engineer reliable agent systems. Use coding agents to build, verify and deliver the software around them. One continuous project connects the two.
How learning works
A Practical Engineering Course
Build Agentic Harnesses
Build the runtime behind an agent: tool use, context and memory, task coordination, approvals and failure recovery. Rather than learning to use LangChain or Hermes, learn to build harnesses of that kind—and design custom harnesses for your own agentic workflows.
Engineer Large-Scale Software with Agents
Use coding agents to build substantial, multi-component applications—not just demos. Take a project from detailed requirements and architecture through coordinated implementation, integration, testing and deployment. Build your own application or co-develop one with TSAI.
Deliver Your Capstone
Bring it together in a working application—your own software or a project co-developed with TSAI. Demonstrate the complete workflow, including how it performs on realistic tasks and handles failures.
Dates & enrollment
Plan your enrollment.
| First class | 5 December 2026 |
|---|---|
| New-student discount | 25% from 31 October through 14 November 2026 |
| Former TSAI students | 40% discount throughout enrollment |
| Refund policy | A full refund, no questions asked, within the first 15 days from the first class. |
Before Session 01
Arrive ready to build.
Prepare with foundation recordings, a developer setup checklist and a readiness exercise before the first live session.
Developer readiness
Python, basic Node.js and frontend concepts, HTTP/JSON, Git and containers. Run a starter model call and a small test; identify gaps for the Session 01 recap.
One continuous engineering project
Build a working system.
Build a customer-operations assistant that handles invoice and status enquiries, reconciles records and proposes actions for human review. Use synthetic documents and simulated CRM, invoice and ticketing APIs. Add grounded answers, event triggers, reviewable outputs and human approvals.
Agent engineering
Build the runtime: tools, context, memory, orchestration, recovery, permissions, evaluation and operation.
Agentic SDLC
Build and evolve the application through specifications, coding-agent workstreams, PRs, review, testing, decisions and release.
Evidence throughout
Keep a task set, traces and versioned acceptance criteria. Compare success, latency and cost against the baseline as capabilities are added.
For Agentic SDLC, choose your own substantial, end-to-end application with detailed requirements, or co-develop an application with TSAI. Both paths cover specifications, architecture, implementation, verification and delivery.
Models for practical work
Work with state-of-the-art LLMs.
EAG V4 will provide access to state-of-the-art (SOTA) LLMs for assignments and the capstone, giving students hands-on exposure to real industry workflows.
Part I / Sessions 01–15
Agentic AI Engineering.
Build the runtime and application incrementally, carrying specification, testing and review habits through every lab.
| 01 | Project Kickoff, First Agent & the SDLC Baseline | Translate a customer-operations brief into a specification, repository, tool-using agent and working test. Establish acceptance criteria, an issue board and a baseline task set. Project evidence: A runnable first agent, project specification and baseline results. |
| 02 | Model Behaviour, Tool Contracts & Structured Outputs | Apply the foundations recap to reasoning limits, model selection, schema validation, tool ergonomics and action-space design. Compare deterministic code, a single agent and multi-agent approaches. Project evidence: Validated tool contracts and a documented choice of architecture. |
| 03 | MCP & Enterprise Integrations | Build and consume MCP tools for a simulated CRM, invoice store or ticketing system. Cover authentication boundaries, credentials, discovery, deferred tool loading, API failures and contract tests. Project evidence: A tested integration with explicit permissions and error handling. |
| 04 | Context Engineering, Memory & Grounding | Manage context budgets, compaction, tool-result trimming and provenance. Compare retrieval with complete requirement coverage; decide what to retain, update or forget. Introduce graph-based retrieval through a small example. Project evidence: A context policy and memory/retrieval tests, including a long-document task. |
| 05 | Reasoning, Planning & Fast Agent Control | Implement task decomposition, ReAct-style loops and typed decisions. Use deterministic fast paths, uncertainty checks, model fallback and stop conditions; inspect the effect of additional reasoning on success and cost. Project evidence: A controlled planner with measurable fallback and termination behaviour. |
| 06 | Durable Agent Runtimes & Human Approval | Build the execution harness: persistent state, checkpoints, pause/resume, timeouts, idempotency, retries and compensation. Separate proposed actions from approved execution and recover from interrupted runs. Project evidence: A resumable workflow demonstrating retry-safe handling of simulated consequential actions. |
| 07 | Agent Evaluation & Error Analysis | Create representative task sets, inspect trajectories and classify failures. Measure task success and tool-use correctness; calibrate judge rubrics against human review. Compare prompt, context and memory changes using regression runs. Project evidence: An evaluation harness, labelled failure examples and an improvement report. |
| 08 | Agent Security, Trust Boundaries & Containment | Threat-model prompt injection and tool poisoning across documents, MCP, browser and desktop inputs. Apply least privilege, sandboxing, controlled egress, secret isolation and approval gates; test adversarial cases. Project evidence: A threat model, permission policy and repeatable security tests. |
| 09 | Multi-Agent Orchestration & Shared State | Design DAGs, ownership, delegation and parallel execution. Manage shared-state conflicts, dependency failures, checkpoints and handoffs. Compare a multi-agent workflow against the single-agent baseline. Project evidence: An orchestrated workflow with evidence for when multiple agents are justified. |
| 10 | Browser & Desktop Automation in a Controlled Workflow | Use Playwright/CDP, accessibility and screen-based interaction where APIs are insufficient. Add perception checks, bounded actions, approval for sensitive steps and recovery from UI changes. Project evidence: One sandboxed browser/desktop task with success and failure cases. |
| 11 | Events, Channels & Voice Interaction | Trigger agents from webhooks, schedules and queues; handle deduplication and asynchronous responses. Connect one primary channel and introduce a bounded voice lab covering streaming and interruption handling. Project evidence: An event-triggered workflow with a reviewable result and channel adapter. |
| 12 | Observability, Model Routing & Agent Economics | Instrument traces across tools and agents, replay failures and investigate latency. Route models by task needs, manage context/cache budgets, enforce spend limits and compare cost per successful task. Project evidence: A trace view and a benchmark covering success, latency and cost. |
| 13 | Agent Interoperability, A2A & Harness Portability | Use capability discovery, task contracts and lifecycle states to connect independent agents. Examine A2A, version compatibility, cancellation and trust boundaries; keep tools, state and skills portable across runtimes. Project evidence: A versioned inter-agent contract and a small portability demonstration. |
| 14 | Agentic Interfaces & Human Review | Design a usable UI around asynchronous agent work: progress, evidence, approvals, corrections and failure states. Introduce A2UI/AG-UI through a focused integration. Project evidence: A human-review interface connected to the running project. |
| 15 | Production Deployment & Operational Readiness | Deploy the agent application to one reference cloud environment. Configure secrets, persistent storage, workers, health checks, environment separation and rollback. Gate release on evaluations, security checks and operating limits. Project evidence: A deployed staging system, operating runbook and release-readiness report. |
Part II / Sessions 16–19
Agentic SDLC.
Choose your own substantial, end-to-end application with detailed requirements, or co-develop an application with TSAI. Plan the work, coordinate coding agents, govern decisions and independently verify the release.
| 16 | Agentic SDLC: Specifications, Architecture & Delivery Planning | Deepen the project brief into executable specifications, API contracts, architecture decisions, milestones and acceptance criteria. Turn requirements into issues and testable work packages; record changes to scope. Project evidence: A delivery plan, dependency graph and traceable acceptance criteria. |
| 17 | Agentic SDLC: Parallel Coding Agents & Integration | Coordinate coding agents with scoped ownership, Git worktrees, branches and pull requests. Manage context and handoffs, dependencies, merge conflicts and integration tests; compare tool workflows on the same task. Project evidence: An integrated feature delivered through reviewable parallel workstreams. |
| 18 | Agentic SDLC: Engineering Control & Decision Governance | Connect bugs, issues, PRs and build results to project state. Track decisions, blockers and human approvals; generate proposed work items for review. Replan after failures without silently changing approved scope. Project evidence: A project control view, decision history and demonstrated recovery from a blocked workstream. |
| 19 | Agentic SDLC: Independent Verification & Release | Verify agent-written software with unit, contract, integration and end-to-end tests plus independent review. Keep software tests separate from agent-behaviour evaluations. Apply CI gates, security review, deployment checks and rollback. Project evidence: A release candidate with traceable evidence, regression results and a maintenance handover. |
Part III / Session 20
Show the evidence.
| 20 | Capstone Demonstration & Architecture Review | Demonstrate the end-to-end system against agreed acceptance criteria. Review architecture, task success, failure recovery, security boundaries, latency, cost and outstanding limitations. Discuss next steps; no new instructional content. Project evidence: A reproducible demonstration and evidence-backed capstone review. |
The review package includes requirements, architecture decisions, source and setup instructions, evaluation results, software tests, security boundaries, operating costs, failure recovery and known limitations.
Further exploration
Extend the core.
The core course emphasizes context engineering, durable execution, evaluation, security and delivery. Framework comparisons, deeper graph-based retrieval, advanced voice, vision workflows and agentic RL can form extension material or capstone choices.
Browser and desktop automation share a representative task. Voice is introduced within channels; cloud deployment uses one reference environment. Extensions are outside the core 20-session curriculum.