In Applied AI, agents are the successor to chatbots. Instead of just answering questions, they reason, plan, and take action. This post covers the key terms you’ll encounter in the agentic AI space.
An AI Agent is a system that uses an LLM as its reasoning engine to autonomously plan and execute multi-step tasks. Unlike a chatbot that responds and waits, an agent:
┌─────────────────────────────────┐
│ AI Agent │
│ │
│ Goal ──> Plan ──> Act ──┐ │
│ │ │
│ Observe <─────────┘ │
│ │ │
│ ▼ │
│ Done? ──No──> Re-plan │
│ │ │
│ Yes │
│ │ │
│ ▼ │
│ Result │
└─────────────────────────────────┘
The broader paradigm of building AI systems that act autonomously rather than just respond. Agentic AI emphasizes:
Agentic AI is the design philosophy — building AI that acts autonomously. AI Agent is what you actually build following that philosophy.
Think of it like: “Agentic AI” is to “AI Agent” what “object-oriented programming” is to “a Java class.” One is the approach, the other is the artifact.
Real-world examples: Amazon Q Developer Agent and GitHub Copilot Agent mode are AI Agents — they autonomously plan, edit files, run commands, and iterate. Grammarly or Copilot’s inline autocomplete are AI-assisted but not agentic — they suggest, they don’t act on their own.
Before diving into individual components, here’s what an agent definition typically looks like. While frameworks differ in syntax, they all define an agent with the same core pieces:
Agent
├── Identity — name, description, version
├── Model — which LLM powers it (e.g., Claude, GPT-4)
├── Instructions — system prompt that defines the agent's role/persona and behavior rules
├── Tools — what it can call (APIs, MCP servers, functions)
├── Knowledge — context files, skills, documents it can reference
└── Orchestration — workflows, SOPs, routing logic
Think of this as the agent spec — a declarative blueprint that says who the agent is, what it can do, and how it should behave. The components below are what fill in each of these slots.
An AI Agent is made up of modular pieces that define what it knows, how it behaves, and what it can do. These are the building blocks you’ll assemble when creating an agent.
A modular, reusable capability an agent can invoke. A skill encapsulates domain knowledge and instructions for a specific task. A skill is typically composed of:
Examples: “search code,” “create a PR,” “diagnose a build failure”
Think of skills as what the agent knows how to do.
A structured, step-by-step workflow written in markdown that guides an agent through a complex task. SOPs define:
Think of SOPs as recipes the agent follows.
Skills and SOPs are composable — they can reference each other:
Think of it like: a Skill is a toolbox (contains knowledge, procedures, scripts). An SOP is a recipe (may pull tools from different toolboxes).
An older term for Agent SOP. Same concept — a predefined procedure an agent executes. The community is converging on “SOP” as the standard term.
A defined sequence of tasks an agent executes, often with dependencies between steps. Workflows can be:
┌─────┐ ┌─────┐ ┌─────┐
│Step1│────>│Step2│────>│Step4│
└─────┘ │ └─────┘ ▲ └─────┘
│ │
│ ┌─────┐ │
└─>│Step3│──┘
└─────┘
(2 and 3 run in parallel)
An SOP tells the agent how to do one thing. A workflow tells the agent what things to do and in what order — and may invoke multiple SOPs along the way.
Think of it like: an SOP is a recipe for one dish. A workflow is a meal plan that sequences multiple recipes.
A child agent spawned by a parent agent to handle a specific subtask. The parent delegates, the sub-agent executes, and returns results to the parent.
┌──────────────┐
│ Parent Agent │
│ │
│ "Research X"│──────> ┌────────────┐
│ │ │ Sub-Agent │
│ (waits) │<────── │(researches)│
│ │ └────────────┘
│ "Now build" │──────> ┌────────────┐
│ │ │ Sub-Agent │
│ │<────── │ (builds) │
└──────────────┘ └────────────┘
A system where multiple agents collaborate, each with a specialized role. They can work:
┌──────────┐ ┌──────────┐ ┌──────────┐
│Researcher│───>│Implementer│───>│ Reviewer │
└──────────┘ └──────────┘ └──────────┘
(pipeline: research → implement → review)
| Term | What it is |
|---|---|
| AI Agent | LLM + reasoning + tools + autonomy |
| Agentic AI | The paradigm of autonomous AI systems |
| Skill | A reusable capability an agent can invoke |
| SOP | A step-by-step procedure guiding an agent |
| Agent Script | Older term for SOP |
| Workflow | A defined sequence of tasks with dependencies |
| Sub-Agent | A child agent handling a delegated subtask |
| Multi-Agent | Multiple specialized agents collaborating |