Core Concepts
AI Principles and Concepts — From LLM to Agent
Core Concepts, part 1. What an LLM is and how it works, how model, tools, and memory assemble into an agent, and how a chatbot differs from an agent — explained through analogies.
As you use AI tools, unfamiliar terms keep coming up — LLM, agent, agentic loop. This is the first of three posts in the Core Concepts series, and it covers the principles beneath the tools: how AI actually gets work done. There's nothing to memorize. Treat it as a dictionary you come back to whenever something gets confusing.
WHY — Why start with principles?
Without the principles, the tool feels like magic — and magic breeds both false expectations (thinking it can do anything) and false anxiety (not using it because you don't understand it). Once you know how it works, you develop a sense for "this I can delegate; this needs verification."
What is an LLM?
An LLM (Large Language Model) in one line:
A program that has read an enormous amount of text and predicts "what comes next" probabilistically.
It's the same instinct that tells you "What should we have for..." is probably followed by "lunch?" — except at a scale beyond imagination. Trained on vast amounts of internet text, it handles not just sentence completion but summarization, translation, analysis, and writing, all as extensions of "predicting what comes next."
Two properties fall out of this that matter for practitioners.
| Property | Meaning | Practical implication |
|---|---|---|
| Probabilistic | It doesn't "know" answers — it generates the most plausible next words | Plausible-but-wrong answers (hallucinations) happen. Verify numbers and facts |
| Context-dependent | It predicts within the context it's given | The better the context (background, criteria, examples), the better the output |
Understanding just these two changes how you treat AI: delegate with trust, verify the output, and never skimp on context.
Model, tools, memory: the three parts of an agent
An LLM is only a brain, and a brain alone can't do work. You have to attach parts before it becomes "an AI that works."
| Part | One-line summary | Analogy |
|---|---|---|
| Model | The brain. Size and generation vary within a family (Opus vs. Haiku) | The new hire's intellect |
| Tools | External capabilities the AI uses as hands and feet: web search, reading and writing files, running commands | The new hire's hands and office equipment |
| Memory | The mechanism that carries past context forward | The new hire's notebook |
Add a goal to these three parts and you get an agent.
Agent = Model (brain) + Tools (hands) + Memory (notebook) + a goal
As an analogy: the LLM is a smart new hire's brain; the agent is the new hire actually showing up to work. However brilliant the brain, nothing gets done unless someone sits at a desk and moves their hands — likewise, an LLM needs tools and a goal to produce real work.
Chatbot vs. agent: what's the difference?
Even with the same Claude model underneath, the experience of a chat window (claude.ai, ChatGPT, etc.) and an agent-style tool is completely different. The difference comes down to three things.
| Difference | Chat window (chatbot) | Agent |
|---|---|---|
| Execution | "Here's how you could do it" — gives an answer; you copy-paste to execute | "Done — I've made the changes" — creates files and connects to tools itself |
| Works on your computer | "Please attach the file" | Reads files in your folder directly and hunts down related material on its own |
| Complex missions | "Finished 3 of them! Shall I continue?" | "Running 5 agents in parallel to research all 30 items" |
A chatbot is a tool for asking and answering; an agent is a tool that takes a goal and sees it through. It's not that ChatGPT is incapable — the chat-window format itself is designed to stop at "an answer."
TIP — The easiest way to tell them apart
Ask "where does the result end up?" If it stays as a chat reply, it's a chatbot. If it lands as a file in your folder or a real change in a connected service, it's an agent.
The agentic loop: how an agent works
Give an agent a goal, and this cycle runs inside.
Think
It breaks the goal down. Given "research competing products," it plans: "First find the product list, then check each pricing page, then organize it into a table."
Use a tool
It executes the first step of the plan — searching the web, reading a file, creating a document. This is where it parts ways with a chatbot.
Observe the result
It looks at what the tool returned and judges: "These search results are thin — try different keywords," or "Good enough, move to the next step." It adjusts itself.
Repeat until the goal is met
Steps 1 through 3 repeat until the goal is done. When blocked, it routes around; when errors occur, it finds the cause and fixes them. This whole cycle is called the agentic loop.
It's exactly how people work: plan, try, observe, adjust, repeat. This loop is why an agent can "run on its own for minutes at a time."
CAUTION — Even a loop needs supervision
A loop that runs by itself will also run hard in the wrong direction if it starts wrong. That's why an agent needs a safe wrapper — a shell that asks a human before risky operations and confines the work to a folder. That shell is called a harness, and Claude Code — the subject of the next post — is the harness Anthropic built.
Recap
CHECK — Part 1 in four points
- An LLM is a brain that predicts "what comes next" probabilistically — plausible but fallible, so verify
- Brain (model) + hands (tools) + notebook (memory) + a goal = an agent
- A chatbot stops at answers; an agent executes and completes — tell them apart by where the result ends up
- An agent repeats the agentic loop — think, use a tool, observe — until the goal is met
The next post covers the tool built on these principles: Claude Code — and how components like CLAUDE.md, skills, and MCP turn it into your personal AI assistant.