The first time someone uses an AI, it looks like a chat interface. The person types a question, the model answers, the conversation ends. That interaction — one prompt in, one answer out — is the simplest unit of AI interaction. It is also, in most important ways, the wrong mental model for what an agent is.

This piece is the bridge between the two. It explains what changes when the move is made from "I sent a message to an AI" to "I have an agent doing work for me." The move is not a single jump. It is five small additions, each of which makes the system more capable and more complex. Understanding the additions is what lets the operator add them deliberately, one at a time, with each step working before the next is added.

What a prompt is

A prompt is a single instruction sent to a language model. It is the thing a user types into a chat box. The model reads it, produces an answer, and the interaction is complete.

The key properties of a prompt are worth naming precisely. A prompt is disposable — the model does not remember it after the session ends. A prompt is bounded — it contains only what was typed in that turn. A prompt is stateless in the sense that the model has no memory of prior prompts unless they are included in the current context.

The mental model that fits: sending a text message to a stranger. The stranger answers the question asked. They do not remember the conversation, they do not know who sent it unless you told them, and they have no way to do anything except answer the question.

Most early AI interactions look like this. The user asks a question, the model answers, and both parties move on. This is a useful starting point, but it is a long way from what an agent is.

What an agent is

An agent is a persistent system. It holds a set of operating instructions, reads and writes files, calls tools, maintains memory across sessions, and produces output over time. The session does not end after the first answer.

The key properties of an agent follow from this. An agent has a system prompt — a set of instructions that persist across every session. An agent has a workspace — a directory it can read from and write to. An agent has tools — capabilities it can invoke beyond just generating text. An agent has memory — a way to record what happened so future sessions can use it. An agent has a loop — it reads, thinks, acts, observes, and continues until a condition is met.

The mental model that fits: hiring a contractor who has a job description, a notebook, and a phone. The job description is the system prompt — it tells the contractor who they are and what they are supposed to do. The notebook is the memory — it records what was decided, what was done, what is pending. The phone is the tool layer — it lets the contractor call someone, send a message, or take an action rather than just describe one. The contractor does not do one thing and stop; they keep working until the job is done or they are told to stop.

The first step: a system prompt

The first addition is the system prompt. This is the set of instructions the agent sees on every call, regardless of what the user typed. Where a user prompt is what you type in a chat box, a system prompt is what the agent always sees whether you type it or not.

The system prompt is the agent's job description. It sets persona — how the agent sounds, what it assumes about the user, what it considers its role. It sets rules — what the agent is allowed to do and what it is not. It sets defaults — what the agent does when the user does not specify. And it sets constraints — what the agent must not do regardless of what the user asks.

Without a system prompt, every session starts from zero. The model sees only what the user typed in that turn. With a system prompt, the agent has a persistent identity and a persistent set of instructions that survive across sessions.

The piece on context management and system prompts covers how to assemble a system prompt well — what to include, what to leave out, and how to structure it so the agent can actually follow it.

The second step: a workspace

The second addition is a workspace. The agent needs a place to read files from and write files to. Without a workspace, the agent can only produce text. With a workspace, the agent can read project files, write notes, produce deliverables, and maintain continuity across sessions.

The workspace is the agent's notebook. It typically contains operating instructions (an AGENTS.md file that explains the operator's preferences and constraints), long-term knowledge (a MEMORY.md that records what the agent needs to know across sessions), and project-specific files (folders for specific work, client files, reference materials).

The workspace is not just a directory. It is a contract about what the agent is allowed to touch. A well-designed workspace tells the agent exactly where its files live, where it should write new files, and where it should not go. The piece on getting started with workspaces covers the setup in detail.

The third step: tools

The third addition is tools. Tools are capabilities the agent can invoke that go beyond text generation. A tool might read a file, run a shell command, search the web, send a message, or call an API. Tools turn the agent from a thing that talks into a thing that does.

The distinction between a tool and a user prompt is important. When a user says "read the file and summarize it," the agent without tools can describe what it would do. The agent with a file-read tool actually reads the file. The difference is not cosmetic. The agent with tools produces work; the agent without tools produces descriptions of work.

The piece on tools, skills, and plugins covers the full taxonomy of what tools are, how they are defined, and how to evaluate whether a tool is worth adding.

The fourth step: memory

The fourth addition is memory. The agent writes things to durable storage — a decision, a preference, a fact about the workspace — and reads them back in a future session. Without memory, every session starts cold: the agent has no record of what was decided last week, what the operator's preferences are, or what work is in progress.

Two kinds of memory matter. Short-term memory is what the agent writes during a session — session notes, logs, the current state of a project. It survives the current session but not the next one unless it is written to long-term storage. Long-term memory is what survives across sessions — a MEMORY.md file, a project knowledge base, an indexed set of documents. The piece on memory: short, long, and semantic covers the three-layer model and why each layer has a different job.

The operator's job is to decide what gets written to memory and in what format. A common mistake is writing too much — the agent fills its memory with trivia that slows retrieval. Another common mistake is writing too little — the agent forgets what it decided and the operator has to re-explain it every session.

The fifth step: a loop

The fifth addition is a loop. The agent does not just respond once. It reads, thinks, acts, observes the result, and continues. The loop is what turns a single prompt-response exchange into a system that can make progress on a goal over time.

The loop is what makes an agent an agent. Without a loop, the system is a sophisticated autocomplete. With a loop, the system can take one step, observe what happened, and decide what to do next. The piece on what is a loop covers the mechanics in depth.

The loop introduces a new problem: when to stop. A loop that never terminates wastes resources and may produce increasingly erratic output. A loop that terminates too early produces incomplete work. The termination condition is part of the agent's design.

The honest picture

The move from prompt to agent is five small additions, each changing what the system can do and what can go wrong.

System prompt adds identity and rules — too vague and the agent cannot act, too long and it attends to the wrong things. Workspace adds file access and continuity — too open and the agent touches what it should not, too closed and it cannot find what it needs. Tools add action — a wrong tool call or a looping call wastes resources and may produce wrong output. Memory adds persistence — too much and retrieval slows, too little and the agent forgets, wrong format and it cannot find what it wrote. Loop adds repetition and autonomy — too long and the agent drifts, too short and it gives up before the work is done.

The right pace is one addition at a time. Each working step before the next is added is a step debugged in isolation. Adding everything at once means debugging everything at once.

What this is not

This piece is not an argument that prompts are inferior to agents. A single well-formed prompt is the right tool for many tasks. For one-shot work with no follow-up, a prompt is the right shape. For work that requires persistence, file access, tools, memory, and iteration, an agent is the right shape.

This piece is not a recipe for building a full agent in one session. The five steps are the conceptual additions. The actual implementation involves choices about model selection, tool design, memory format, loop architecture, and error handling that each have their own complexity.

See also