AI Agents 101: A Glossary

You’ve used ChatGPT. You’ve probably seen demos of agents that browse the web, write code, and fix their own mistakes. The terminology gets used loosely, and most explanations assume you already know the pieces. Here are the terms, defined plainly.

LLM

Text in, text out. An LLM takes a prompt and returns a completion. No memory of last session. No ability to open a file. If the answer isn’t in the input, the model is guessing.

Agent

An agent is an LLM wired into a loop. Instead of answering once and stopping, it decides what to do next, calls a tool, gets a result, and keeps going until the task is done.

Three things make that work. The model has to decide which tool to call and when to stop - that’s the thinking part. It has to actually invoke something: run a command, read a file, search the web. That’s function calling, sometimes called skills or tools. And it has to know what’s relevant - which means loading the right information into its context before it acts.

The loop

Context → Agent → Skills → back to Context.

The agent reads what’s in its context, picks a tool, gets a result, that result goes back into context, and the cycle repeats. Most agent frameworks are different ways of managing this loop.

Memory

Memory just means what’s in the context window. But that context gets filled from different places.

Conversation history is the back-and-forth so far, including tool results. Instruction files - things like CLAUDE.md or AGENT.md - get loaded at the start of a session and set the rules. RAG (Retrieval-Augmented Generation) pulls in external knowledge at runtime: instead of loading everything upfront, you retrieve relevant chunks when they’re needed.

Skills / Function calling

Skills are the things an agent can actually do. At the low level, these are functions the model can invoke: run a shell command, read a file, search the web, execute Python. MCP (Model Context Protocol) is a standard for connecting agents to external services - GitHub, Slack, databases. Plugins and connectors are the same idea under different names.

Subagents

Agents can spawn other agents. A common pattern: one agent plans, one implements, one reviews. Each subagent gets a focused task and its own context window. This keeps complex work from overloading a single session.

Hooks, triggers, schedules

Ways to start an agent without a human typing a prompt. A hook fires when a file changes or a command finishes. A schedule runs an agent on a timer. A trigger wakes an agent when something happens in an external system.

Where to go next

Watching an agent work is more useful than reading about one. Claude Code is a good starting point - it’s an agent running in a real workflow, and the Claude Code documentation explains how the loop, memory, and tools fit together in an actual system. The Model Context Protocol spec goes deeper on skills and connectors if that’s the direction you’re headed.

To build something yourself, start with function calling in the Anthropic API. Get the loop working. Memory and subagents can wait.

If you want to see how all these terms play out in a real system, Inside Claude Code: The Architecture Behind Tools, Memory, Hooks, and MCP walks through each piece with concrete detail - it picks up exactly where this glossary leaves off.