The Core Relationship
Brain & Exoskeleton
A model is raw intelligence — it reasons, generates, and understands, but it cannot act. An agent wraps that brain in a body: identity, tools, memory, connections, and governance. The model is the brain. The agent is the exoskeleton.
Core Components
What the Agent Is
The foundational layers that define the agent's identity — its instructions, its reasoning engine, and the window of information it can work with at any given moment.
System Prompt
The agent's standing instructions — who it is, how it behaves, what it must and must not do. The persistent identity layer that shapes every response.
foundationalconstrainingpersistent
Model
The reasoning engine underneath. General-purpose intelligence — language understanding, generation, analysis — invoked on demand. The agent is built on top of this.
general-purposeon-demandfoundational
Context
The working memory — the window of information the model can see right now. Includes the conversation, retrieved documents, tool results, and anything loaded into the current session.
finitedegradingmanaged
Capabilities
What the Agent Can Do
The extensions that give the agent reach beyond pure reasoning — knowledge it can reference, actions it can take, and external services it can connect to.
Skills
Declarative knowledge packages — instructions, examples, domain expertise, and best practices that the agent can reference. Skills tell the agent what to know, not what to execute.
declarativemodularreusable
Tools
Executable capabilities — functions the agent can call to take action in the world. Read files, query databases, call APIs, run code. Tools give the agent hands.
executablescopedcomposable
MCP
Model Context Protocol — a standard interface for connecting agents to external services. Instead of building custom integrations, MCP lets agents discover and use tools and data sources at runtime through a shared protocol.
standardizeddiscoverableruntime
State & Continuity
What the Agent Remembers
How the agent maintains continuity — the short-term thread of a conversation and the long-term knowledge that persists across interactions.
Sessions
A single conversation thread — the back-and-forth between the user and the agent. When the session ends, the context is gone unless explicitly persisted. The whiteboard that gets wiped.
ephemeralconversationalscoped
Memory
Information that persists across sessions — facts, preferences, decisions, patterns learned over time. The filing cabinet that survives after the whiteboard is wiped.
persistentcross-sessionstructured
Orchestration
How Agents Are Governed
The mechanisms that keep agents in check — automated interventions that trigger on events, and hard boundaries that cannot be overridden.
Hooks
Code that runs automatically when specific events occur — before a tool is called, after a response is generated, when a session starts. Hooks observe and intercept without modifying the agent's core behavior.
event-drivenobservableextensible
Guardrails
Hard constraints that the agent cannot override — content filters, permission boundaries, rate limits, output validation. The non-negotiable rules enforced by the system, not the model.
restrictivelayerednon-negotiable
Components at Runtime
How They Work Together
Each task activates a different set of components. These sequence diagrams show what actually happens when an agent does something.
Task 1 — Answer a Question
The system prompt shapes every response. Context is the bottleneck — it's finite and must be managed.
Task 2 — Take an Action
Skills told the agent what to do. Tools and MCP give it the hands to do it. The model reasons, the tools execute.
Task 3 — Remember Across Sessions
Sessions are the whiteboard — wiped when you're done. Memory is the filing cabinet — it survives. Without memory, the agent starts from zero every time.
Task 4 — Governed Action
Hooks observe without blocking. Guardrails enforce hard limits. Together they make autonomy safe — this is where governance comes from.
Key Distinctions
Concepts That Are Easy to Conflate
Skills vs Tools
Skills are declarative — they tell the agent what to know. Domain expertise, best practices, formatting rules, decision frameworks. A skill is a reference document.
Tools are executable — they give the agent something to do. Read a file, query an API, run a calculation, send a message. A tool is an action.
A skill says: "When handling refund requests, follow these criteria..."
A tool says: "Call process_refund(order_id, amount) to execute the refund."
Sessions vs Memory
Sessions are the whiteboard — the current conversation, visible right now, wiped when you're done. Everything the agent knows in the moment lives here.
Memory is the filing cabinet — information that persists after the session ends. Facts, preferences, decisions, context that should survive across interactions.
The session tells the agent: "The user just asked about their Q4 report."
Memory tells the agent: "This user prefers charts over tables and works in the EMEA timezone."
An agent is not just a model with a prompt. It is a situated system — shaped by its instructions, extended by its capabilities, grounded by its memory, and bounded by its governance. Understanding the components is the first step to designing agents that actually work.
Prepared by Alex Collet & Akhil Aryanv9 · February 2026