Agentic Architecture: Enterprise AI Agent Systems Design

Name: Agentic Architecture: Enterprise AI Agent Systems Design
Rating: 4.5 (4 reviews)

Architect production AI agents: patterns, memory, multi-agent, HITL & evals — hands-on with LangGraph

New

Created byDr. Amar Massoud

Last updated 7/2026

English

English [Auto],

What you'll learn

Choose deliberately between workflows, single agents, and multi-agent systems
Apply ReAct, plan-and-execute, and reflection patterns — and know when each fits
Design typed tool contracts and integrate enterprise systems via MCP
Architect short-term session state and long-term memory with deliberate forgetting
Decompose monolithic super-agents into orchestrator/worker topologies and weigh the tradeoffs
Design human-in-the-loop approval gates, autonomy tiers, and audit trails
Build the Agent Development Lifecycle: evals, tracing, versioning, CI gates
Produce a reference architecture and ADR set for an agent platform

Course content

9 sections • 45 lectures • 4h 32m total length

Set Up Your Lab Environment4:42

Welcome - Why Agentic Architecture Is an Architect's Problem7:29
Design production-ready AI agent systems that survive real enterprise, not toy demos. Own autonomy, state, topology, and human oversight as architectural decisions framed by Meridian Atlas.
What Makes an Agent - The Agentic Loop (Perceive → Reason → Act → Observe)5:16
Workflows vs. Agents - Choosing Autonomy Deliberately6:03
A Reference Architecture - Model, Tools, Memory, Orchestration, Guardrails6:55
Meet Meridian & Atlas - Your Enterprise Lab System (Lab 1 walkthrough)6:19
Lab 1 Demo - Build the Agentic Loop (watch it run)2:17
See how an agent uses the perceive, reason, act, observe loop to read context, call tools, and use results. Atlas' demo explains tool execution and agent trace debugging.
Quiz 1: Foundations: From LLM Calls to Agentic Systems
Assignment (Lab 1) — Add the Fourth Tool & Map the Loop
Assignment — Workflow-or-Agent Decision Memo

ReAct - Interleaved Reasoning and Acting, and Its Limits6:16
Explore the ReAct interleaved reasoning and acting loop, its thought-action-observation cycle, strengths in adaptivity and traceability, and its limits without a plan or a reviewable artifact.
Planning Patterns - Plan-then-Execute, Replanning, Plan Critique6:35
Reflection & Self-Correction - When to Pay the Extra Tokens6:37
Pattern Selection - A Decision Framework (Task Shape × Risk × Latency × Cost)7:12
Anti-Patterns - Chatbots with Tools Bolted On (Lab 2 walkthrough)6:51
Lab 2 Demo - Pattern Shootout (watch it run)1:48
Quiz 2: The Agentic Loop & Core Design Patterns
Assignment (Lab 2) — Pattern Shootout on a Fraud Check
Assignment — Pattern-Selection Matrix

Tools Are Your Trust and Integration Boundary - Typed Contracts, Idempotency7:20
Define a tool layer as the trust and integration boundary, using four-layer contracts—typed schema, semantics with idempotency and side effects, model-friendly errors, and narrow verbs for safe, bounded calls.
Wrapping Enterprise Systems - APIs, Databases, Legacy, and Error Semantics7:26
Wrap legacy systems with a five-stage pipeline: agent to facade to adapters to systems, as an anti-corruption layer that normalizes results and defines retryable versus permanent errors.
MCP - A Standard Integration Layer for Enterprise Tools7:07
Tool Failure Design - Retries, Timeouts, Fallbacks, Compensation (Lab 3)7:49
Lab 3 Demo - Tool Failure Design (watch it run)1:36
Quiz 3: Tool & Integration Architecture
Assignment (Lab 3) — Typed Tool, Idempotency & a New Fault Mode
Assignment — Tool-Contract Design

Short-Term State - Context Windows, Session State, Checkpointing5:52
Long-Term Memory - Episodic, Semantic, Procedural; Vector Stores6:27
State Architecture - What to Persist, Where, and Who Owns It6:27
Continuity Across Interactions - Compaction, Summarization, Forgetting (Lab 4)6:33
Atlas preserves continuity with a memory architecture of compaction, selective retrieval, threat identity, and deliberate forgetting. It uses checkpointer and Chroma to keep threads resumable without repeating the customer.
Lab 4 Demo - Memory Across Sessions (watch it run)1:46
Demonstrates how to equip an agent with real short-term and long-term memory, preserving state across sessions by checkpointing to disk and memory store, enabling continuity.
Quiz 4: Memory & State Design
Assignment (Lab 4) — Procedural Memory & Kind-Aware Forgetting
Assignment — State-Architecture Map

The Monolithic Super-Agent - A Failure Mode, Not a Milestone7:23
Teams accumulate tools and prompts sprint by sprint, creating a twelve-tool monolith that degrades reliability and debugging becomes hard, underscoring the need for deliberate decomposition and an orchestrator-worker pattern.
Orchestrator-Worker - Supervisor Patterns and When They Apply6:25
Coordination Tradeoffs - Shared Context, Handoffs, Cost, Debuggability7:20
Multi-Agent Topologies - Hierarchical, Peer, Pipeline; Frameworks Compared8:17
Decomposition Heuristics - When One Agent Is Still the Right Answer (Lab 5)8:15
Lab 5 Demo - Decompose the Super-Agent (watch it run)1:50
Quiz 5: Single-Agent vs. Multi-Agent Architecture
Assignment (Lab 5) — Add a Fourth Worker & Re-measure
Assignment — Decomposition Proposal

Autonomy Levels - From Suggest to Act; Designing the Autonomy Ladder6:35
Approval Gates & Interrupts - Architecting the Human Checkpoint7:19
Escalation, Overrides & Audit Trails - The Compliance View7:15
Guardrails Beyond Humans - Input, Output & Action Policies (Lab 6)8:21
Lab 6 Demo - HITL Gate & Bypass Test (watch it run)1:47
Quiz 6: Human-in-the-Loop & Guardrails
Assignment (Lab 6) — Second Gate, New Tier & Richer Audit
Assignment — Autonomy & Oversight Policy

The ADLC - Why Agents Break Traditional SDLC Assumptions6:46
Evaluating Agents - Task Success, Trajectory Evals, LLM-as-Judge6:18
Tracing & Observability - Seeing Inside the Loop7:18
Versioning - Prompts, Tools, Models, Graphs; Regression Safety7:27
CI-CD for Agents - Eval Gates, Canary Rollouts, Feedback Loops (Lab 7)6:58
Implement ci-cd for agents by wiring evals and traces into four gates—pre-merge, pre-deploy, canary, and feedback loops—to catch regressions before shipping.
Lab 7 Demo - Eval Gate Catches a Regression (watch it run)1:53
Quiz 7: Evaluation & the Agent Development Lifecycle
Assignment (Lab 7) — Extend the ADLC Gate, Catch a Second Regression
Assignment — Fraud-Screening Eval Plan

Deployment Architecture - Runtimes, Scaling, Cost Envelopes7:39
Security & Governance Touchpoints - Least Privilege, EU AI Act View7:42
Explore four governance touchpoints—least privileged tools, data protection, EU AI Act obligations, and change governance—integrated into Atlas architecture to ensure secure, compliant agent systems.
The Architecture Decision Record for Agents - Documenting Your Choices8:07
Explore how architecture decision records preserve Atlas' design choices by documenting loop patterns, integration layers, state ownership, topology, and autonomy with evidence, review, and a living index.
Capstone Briefing - Assemble and Defend Your Atlas Architecture7:34
Lab 8 Demo - Capstone Atlas End-to-End (watch it run)1:43
Quiz 8: Production Architecture & Capstone
Assignment (Lab 8) — Capstone: Reference Architecture & ADR Set
Final Exam — Agentic Architecture (30 Questions, 70% to pass)

Requirements

Working Python knowledge and command-line comfort; Docker Desktop
No machine-learning background and no paid API keys required — all labs run locally

Description

This course contains the use of artificial intelligence.

AI agents are moving into production, and someone has to architect them. This course is for that person. Instead of teaching one framework's API, it teaches the architecture decisions that determine whether an agent system survives contact with the enterprise: when to use a workflow instead of an agent, which loop pattern fits which task, where the tool boundary sits, what state to persist and who owns it, when one agent should become many — and when it absolutely should not — where humans must stay in the loop, and how agents are tested, traced, and versioned like real software.

You learn by building. Across 8 hands-on labs (LangGraph + Ollama, all local, no API keys), you design and evolve Atlas, the agentic claims platform of Meridian Insurance Group — a realistic enterprise with legacy systems, compliance obligations, and impatient stakeholders. You implement ReAct and plan-and-execute side by side and measure the difference, expose enterprise systems through typed tools and MCP, give your agent durable memory across sessions, refactor a monolithic super-agent into an orchestrator/worker crew, add interrupt-based human approval gates, and build the eval suite and tracing that catch a regression before it ships. The capstone assembles everything into a production-shaped system defended before an architecture review board — with a reference architecture document and ADR set you can reuse at work.

By the end you'll have a decision framework for every major agentic design choice, a working reference implementation, and the vocabulary to review any agent design with confidence.

Who this course is for:

Software architects, solution and enterprise architects, and tech leads
Senior engineers moving into AI platform / agent system design
Anyone who must design, review, or approve AI agent systems for production

Agentic Architecture: Enterprise AI Agent Systems Design

What you'll learn

Explore related topics

Course content

Getting Started — Set Up Your Environment1 lecture • 5min

Foundations: From LLM Calls to Agentic Systems6 lectures • 34min

The Agentic Loop & Core Design Patterns6 lectures • 35min

Tool & Integration Architecture5 lectures • 31min

Memory & State Design5 lectures • 27min

Single-Agent vs. Multi-Agent Architecture6 lectures • 40min

Human-in-the-Loop & Guardrails5 lectures • 31min

Evaluation & the Agent Development Lifecycle6 lectures • 37min

Production Architecture & Capstone5 lectures • 33min

Requirements

Description

Who this course is for: