> ## Documentation Index
> Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Course Wrap Up
> Overview of building agentic AI systems by composing six capabilities—query, tools, memory, skills, subagents, and MCPs—to deploy a production three‑tier web application
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](https://aws.amazon.com/architecture/well-architected/), designed the stack, and produced cost estimates.
* Network: the [VPC](https://learn.kodekloud.com/user/courses/aws-networking-fundamentals) 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](https://learn.kodekloud.com/user/courses/aws-rds) best practices.
* Web tier: [ECS](https://learn.kodekloud.com/user/courses/amazon-elastic-container-service-aws-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.
## 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
| Lesson | What it enables | Example in capstone |
| - | - | - |
| Query + Tools | Actionable intent and operations | Multi-turn planning client that issues provisioning commands |
| Memory | Context across steps | Keeps state for multi-step deployment and rollbacks |
| Skills | Reusable domain knowledge | RDS best practices packaged as a skill |
| Subagents | Parallelized, least-privilege work | Network and security specialists building the VPC |
| MCP | External services without custom glue | ECS provisioning via an external MCP server |
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.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.