Skip to main content
Look how far you’ve come. This page walks the entire journey — from a single-turn query to a full production deployment — and ties each lesson into a practical mental model you can reuse. You learned six capabilities, each building on the last, and then combined them in the capstone to deliver a three-tier web app.

​
The six core lessons (in order)

  1. Query (single-turn)
    • The foundation: ask a question and get an answer. This establishes identity and intent for the agent.
  2. Tools (action surface)
    • Give the agent real abilities (read, edit, run Bash) so it can operate systems rather than only describe them.
  3. Memory (stateful client)
    • Persist conversation state so the agent can build multi-step workflows across turns.
  4. Skills (reusable expertise)
    • Package domain knowledge and procedures as files or modules the agent can discover and reuse.
  5. Subagents (specialists)
    • Decompose complex work into focused agents, each with only the tools and permissions it needs.
  6. MCP (external tool servers)
    • Plug in third‑party or hosted tool servers (MCPs) so tooling can be consumed without custom glue code.
Each step depends on the previous: query and tools form the base, memory links steps, skills provide the knowledge, subagents organize work, and MCPs supply external services.

​
A compact mental model

Use these lenses when designing agentic systems:
  • Foundation: Query + Tools — how the agent thinks and acts
  • Scope: Skills — what the agent can reach for
  • Assignment: Subagents — which specialist does the work
  • Sourcing: MCP — where external tools and services come from
  • Continuity: Memory — when context and history matter

​
Capstone recap — a production deployment

In the capstone you combined every capability to provision a three-tier web application. Each component had a specific responsibility:
  • Planning: a multi-turn client researched the Well-Architected Framework, designed the stack, and produced cost estimates.
  • Network: the VPC wrapped the system and was constructed by parallel subagents (network and security specialists).
  • Database: the database tier was provided by a skill encapsulating AWS RDS best practices.
  • Web tier: ECS behind an application load balancer was provisioned via an MCP server, avoiding custom orchestration glue.
  • Observability: monitoring (CloudWatch and related agents) tied every tier together and validated health, performance, and cost.
One system, every capability pulling its weight.
A dark-themed infographic titled "Every Power, One System" showing a VPC layout with stacked Web, App, and Database tiers. Each tier lists components (Web: ALB, ECS, nginx; App: app servers/private subnets; DB: RDS PostgreSQL Multi‑AZ) and a CloudWatch monitoring row with assorted badges.

​
Why composition matters

The biggest insight is composition: small, well-defined capabilities — a tool, a memory store, a skill file, a specialist subagent, a plugged-in server — are not powerful in isolation. Combined, they plan, build, and verify real infrastructure while you review the results instead of typing every command. This is the core of Agentic AI: compose focused components so the system reliably produces outcomes you can audit and approve.

​
Quick reference table

A simple mental model to use when designing agentic systems: foundation (query + tools), scope (skills), assignment (subagents), sourcing (MCP), and continuity (memory). Use these five lenses to decide what to implement and where to plug components in.
You’re ready: pick a real task in your environment and start composing. Design the plan, wire the skills, assign subagents, plug in any needed MCPs, and let the system execute while you verify outcomes.

Watch Video