An "agent" is not a bigger chatbot — it is a language model wrapped in a loop that can plan, call tools, read and write memory, and take actions toward a goal without a human in every step. A June 2026 reference, "The Hitchhiker's Guide to Agentic AI" by Haggai Roitman, makes the case that building one well means understanding the whole stack, not just the model: the LLM substrate (transformers, fine-tuning, inference), the alignment and reasoning layer (RLHF, DPO, GRPO, chain-of-thought, test-time scaling), and then the agentic layer proper — the harness and context management, memory systems, retrieval-augmented generation, agent design patterns, and inter-agent coordination through protocols like MCP and Agent-to-Agent. This guide walks that stack in plain language: what each layer does, why "every layer matters" is the central thesis, how agents actually coordinate and get evaluated, and what a working applied agentic system looks like once it leaves the paper and has to ship real output on a schedule.
Two years of "AI agents" hype have made the word mushy, so start with the concrete distinction. A chatbot takes one prompt and returns one answer. An agent takes a goal, then runs a loop: it decides on a step, uses a tool to carry it out — a web search, a code execution, an API call — reads the result of that action, updates what it remembers, and decides the next step, repeating until the goal is met or it gives up. The language model is the reasoning core, but the agent is the model plus the loop plus the tools plus the memory. That extra machinery is what lets it act in the world rather than just describe it.
In June 2026, Haggai Roitman published a reference titled "The Hitchhiker's Guide to Agentic AI: From Foundations to Systems" (arXiv 2606.24937) that lays out how these systems are actually built, and its organizing argument is worth keeping in mind for the rest of this guide: building a good agentic system requires understanding every layer of the pipeline, not just the model at the center. This explainer walks that pipeline in plain language — the LLM substrate underneath, the alignment and reasoning layer that makes the model steerable and capable of multi-step thought, the agentic layer proper where the loop and the memory and the tools live, and how separate agents coordinate. It ends with the part the paper leaves to practitioners: what an agentic system looks like once it has to ship real output on a schedule.
The overloaded term hides a simple idea. Agency, in this context, is the capacity to take actions toward a goal and adapt based on their outcomes. A model that only produces text has no agency; a model given tools, a loop to use them in, and a goal to pursue has some. The interesting systems sit on a spectrum — from a single tool call inside an otherwise normal chat, up to a long-running system that decomposes a task, delegates sub-tasks, checks its own work, and recovers from errors with no human touching any individual step.
Four ingredients turn a model into an agent. The model supplies reasoning and language. The loop — often called the harness or the agent runtime — is the control structure that keeps calling the model, feeds it the results of its actions, and decides when to stop. Tools are the hands: functions, APIs, and external systems the model can invoke to do something it cannot do by generating text alone, like retrieving a document, running code, or posting to a platform. Memory is what carries information across steps and across sessions, so the agent is not starting from a blank slate each turn. Remove any one of the four and you have something less than an agent: a model with no tools is a chatbot, a model with no memory forgets its own plan, a model with no loop cannot take a second step.
It would be convenient if you could treat the model as a black box and only learn the agent layer on top. Roitman's central thesis is that you cannot, and the reason is that agent behavior is shaped by decisions made all the way down. How a model was fine-tuned and aligned determines whether it follows a plan or wanders. How it was trained to reason determines whether chain-of-thought and test-time scaling actually help on a hard task. Inference cost and latency — set at the substrate level — decide whether a multi-step loop is economically viable at all. The layers are not independent; a weakness low in the stack surfaces as flaky agent behavior high in it. That is why the reference starts at transformers and GPUs before it ever gets to agents.
The foundation is the language model itself, treated in the guide as essential background rather than the main event. The transformer architecture is the base — the attention mechanism that lets a model weigh relationships across a sequence. On top of a pretrained base model, several techniques adapt and shrink it. Supervised fine-tuning (SFT) teaches it to follow instructions from labeled examples. LoRA (low-rank adaptation) makes that fine-tuning cheap by training small adapter matrices instead of the whole network. Mixture-of-experts (MoE) architectures route each token through only a subset of the model's parameters, buying more capacity without proportionally more compute per token. Then model compression and inference optimization — quantization, batching, and caching — bring the cost and latency down to where running a model dozens of times inside a single agent loop is affordable. None of this is agent-specific, but all of it sets the ceiling on what the agent above can do and what it costs to do it.
A raw pretrained model predicts likely text; it is not reliably helpful, and it does not natively think step by step. The middle layer of the stack is where both of those get fixed, and it is the layer most directly responsible for whether an agent is trustworthy.
Reinforcement learning from human feedback (RLHF) is the classic method: humans rank model outputs, those rankings train a reward model, and the language model is then optimized against that reward — historically with PPO (proximal policy optimization). The guide traces the lineage past RLHF to the methods that now dominate because they are simpler or cheaper to run: DPO (direct preference optimization), which skips the separate reward model and optimizes directly on preference pairs, its several variants, and GRPO (group relative policy optimization), a technique that has become prominent in training strong reasoning models. The practical point for agents is that alignment is what makes a model steerable — able to follow a system prompt, respect constraints, and stay on task across a long loop instead of drifting.
The other half of this layer is reasoning. Chain-of-thought is the finding that models solve harder problems when they generate intermediate reasoning steps before an answer rather than answering immediately. Test-time scaling generalizes it: spend more computation at inference — longer reasoning traces, multiple sampled attempts, self-checking — to get better answers on hard tasks without retraining the model. Reinforcement learning applied specifically to large reasoning models trains them to produce those useful reasoning trajectories reliably. This matters enormously for agents, because an agent's planning step is a reasoning step. A model that reasons well decomposes a goal into sensible sub-tasks and catches its own mistakes; a model that does not produces confident, wrong plans that the loop then dutifully executes.
The second half of the reference is agentic AI itself — the machinery that sits on top of a capable, aligned model and turns it into a system that acts. This is where most of the practical engineering lives.
The harness is the loop and everything around it: the code that calls the model, parses its requested actions, executes tools, feeds results back, and manages the context window across many turns. Context management is the hard part. A model has a finite window, and a long agent run generates far more information — tool outputs, intermediate reasoning, prior steps — than fits in it. The harness has to decide what to keep in context, what to summarize, and what to offload to external memory, on every turn. Get this wrong and the agent either forgets its goal or drowns in irrelevant history. Much of what separates a robust agent from a fragile demo is context management, not model quality.
The guide splits memory into four kinds, and the distinction is useful. In-context memory is whatever currently sits in the prompt window — immediate, but finite and expensive. External memory is a store the agent reads from and writes to, typically a vector database, that holds far more than fits in context and is queried on demand. Episodic memory is a record of past interactions and events — what the agent did, what happened, what worked — so it can learn from its own history. Semantic memory is durable factual knowledge, the stable body of things the agent can rely on. A capable agent uses all four: it reasons over what is in context, retrieves relevant facts from external and semantic memory, and consults episodic memory to avoid repeating a mistake.
Retrieval-augmented generation (RAG) is the mechanism that connects the model to external memory: instead of relying only on what the model learned in training, the system retrieves relevant documents and injects them into context before generating. Classic RAG does this once, up front. Agentic RAG makes retrieval part of the loop — the agent decides when it needs more information, formulates a query, retrieves, evaluates whether the result is good enough, and retrieves again if not. That turns retrieval from a fixed preprocessing step into an action the agent takes deliberately, which is what lets an agent research a question it cannot answer from memory alone.
Across all of this sits a taxonomy of recurring patterns. Planning decomposes a goal into ordered steps before acting. Reflection has the agent critique its own output and revise, catching errors a single pass would ship. Tool use is the pattern of choosing and invoking the right external capability for a sub-task. Combinations of these — reason, act, observe, repeat — are the backbone of most working agents. The value of naming them as patterns is that you can compose them deliberately rather than rediscovering them per project, the same way software design patterns let you reuse a known-good structure.
A single agent with tools is powerful; systems of agents are where the field is heading, and coordination is its own discipline. The reference covers it through two protocols and a set of architectural choices.
The Model Context Protocol (MCP), introduced by Anthropic in late 2024, is an open standard for connecting a model to external tools and data sources through one consistent interface, rather than hand-coding a bespoke integration for every tool. It defines how an agent discovers what capabilities are available and how to call them, which is why it was adopted quickly as a common substrate for agent tool use. "Agent skills" and tool use, in the guide's framing, are the capabilities an agent draws on; MCP is a standard way to expose and invoke them.
When separate agents need to work together, they need a way to talk. The Agent-to-Agent (A2A) communication protocol addresses that layer — how one agent advertises what it can do and how another delegates work to it. On top of a communication protocol sit architectural choices about how the agents are organized. Centralized topologies route everything through a single coordinator that delegates to workers. Decentralized topologies let agents communicate peer-to-peer with no single controller. Hierarchical topologies nest the two — a top-level coordinator over sub-coordinators over workers — which is how most complex multi-agent systems are actually structured, because it scales while keeping control legible. The right topology is a genuine design decision with tradeoffs in reliability, cost, and how easy the system is to debug.
The reference closes on the parts that decide whether an agent is usable rather than merely impressive: development frameworks, agentic UI design, evaluation methodology, and production deployment. Evaluation is the quiet hard problem. A chatbot answer can be graded against a reference; an agent's work is a trajectory of actions with many valid paths and many ways to fail partway, so measuring whether it actually succeeded — reliably, not just in a cherry-picked demo — requires task-level evaluation of the whole run, not a single-output score. Deployment adds the usual production concerns plus agent-specific ones: cost control on multi-step loops, latency, guardrails on what tools the agent may call, and a way for a human to observe and intervene. This is the gap between a system that works in a notebook and one you can put in front of users.
The paper describes the components; a shipping product has to assemble them into something that produces a specific, reliable result on a schedule, with a human able to check the work. That constraint is why most useful agentic systems are not open-ended autonomous minds — they are the same loop of planning, tool use, memory, and coordination, narrowed to one job and wrapped in a review gate. [Kompozy](/) is a concrete instance of exactly that, applied to content, and it is a cleaner way to see the abstract stack than any diagram: it is an AI content generation and multi-platform publishing engine whose [Autopilot](/glossary/autopilot) is an agentic system in the precise sense this guide has been describing.
Map it onto the layers. The substrate and reasoning layers are the models Kompozy orchestrates — Claude and OpenAI for copy and planning, Google Gemini for face-locked avatar images, HeyGen for avatar video, plus image and B-roll providers — chosen per sub-task rather than forcing one model to do everything. The harness is its orchestration layer: an input arrives from a source, gets processed into raw content, is planned into a set of outputs, generated, and moved through a schedule to publishing, with the long-running steps run on durable workers so the loop survives interruptions instead of dropping a task midway. Memory shows up as governed brand knowledge: a [Persona Brief](/glossary/persona-brief) holds the durable, semantic memory of voice, claims, and banned words, and every generation reads from it, so the system stays on-brand across formats the way a semantic memory keeps an agent consistent. Tool use is the set of generation and publishing capabilities the engine invokes — render an avatar short, compose a carousel, fan a post to a platform's API.
Two design choices make it the applied, trustworthy kind of agentic system rather than the open-ended kind. First, the goal is fixed and narrow: produce on-brand content and publish it, not "do whatever seems useful." That is what makes evaluation tractable — success is a finished post that meets the brief, which a person can judge. Second, there is a human review gate. Kompozy fans a single approved output to nine social platforms plus email and blog on autopilot, but a per-post review sits in the loop exactly where the deployment section of any serious agent discussion says it should — a checkpoint where a human observes and can intervene before an irreversible action ships. That is the difference between an agent you can run a business on and a demo. For the broader trend of agents moving into content pipelines, see [AI agents for content workflows](/guides/ai-agents-for-content-workflows); for the architecture of the automated engine itself, [automated social content engines](/guides/automated-social-content-engines).
Agentic AI is a language model turned into an actor: wrapped in a loop, given tools, equipped with memory, and pointed at a goal it pursues over many steps. "The Hitchhiker's Guide to Agentic AI" is a useful map because it refuses to treat the agent layer in isolation — it insists that a good agent depends on the substrate beneath it (transformers, fine-tuning, cheap inference), the alignment and reasoning layer above that (RLHF, DPO, GRPO, chain-of-thought, test-time scaling), and only then the agentic machinery itself (the harness, memory, retrieval, design patterns, and coordination through MCP and A2A). The lesson for anyone building or buying one is the same: the impressive autonomy at the top is only as reliable as every layer under it, and the version that survives contact with production is the narrow, tool-using, memory-governed, human-checked kind — not the open-ended fantasy. An applied engine like Kompozy is what that looks like when the goal is content and the output has to ship every day.
Agentic AI is a system built around a language model that can pursue a goal over multiple steps on its own — it plans, calls external tools or APIs, reads and writes memory, observes the results of its actions, and decides what to do next, rather than just answering a single prompt. The distinction from a chatbot is the loop and the ability to act: an agent takes actions in the world and adapts based on what happens.
A chatbot maps one input to one output — you ask, it answers, the exchange ends. An agent runs a loop: it decides on a step, uses a tool to carry it out (search, code, an API call), reads the result, updates its memory, and repeats until the goal is met or it fails. The model is the same kind of thing under the hood; the agent adds planning, tools, memory, and autonomy on top.
The reference "The Hitchhiker's Guide to Agentic AI" organizes it in three parts. First, the LLM substrate — transformer architecture, fine-tuning (SFT, LoRA, MoE), and inference optimization. Second, the alignment and reasoning layer — RLHF, PPO, DPO, GRPO, reward modeling, chain-of-thought, and test-time scaling. Third, the agentic layer proper — the harness and context management, memory systems, retrieval, agent design patterns, and inter-agent coordination.
MCP is an open standard, introduced by Anthropic in late 2024, that gives an AI agent a consistent way to connect to external tools and data sources — files, databases, APIs — without a custom integration for each one. It standardizes how the model discovers and calls capabilities, which is why it became a common building block for agent tool use. The companion Agent-to-Agent (A2A) protocol handles communication between separate agents.
Through memory systems the guide splits into four kinds: in-context memory (what fits in the current prompt window), external memory (a store the agent reads from and writes to, often a vector database), episodic memory (a record of past interactions and what happened), and semantic memory (durable facts and knowledge). Retrieval-augmented generation is the mechanism that pulls the right external memory into context at the right moment.
A paper describes the components; a production system has to deliver a specific, reliable output on a schedule with a human able to check it. That means a fixed goal, a defined set of tools, a review gate, and error handling — not open-ended autonomy. Content engines like Kompozy are a concrete example: the same loop of orchestration, tool use, memory, and multi-step planning, narrowed to the job of producing and publishing on-brand content.
Agentic AI is a system built around a language model that pursues a goal over many steps on its own — it plans, calls tools, reads and writes memory, observes results, and decides the next action, instead of answering one prompt. The 2026 reference "The Hitchhiker's Guide to Agentic AI" frames it as a full stack: the LLM substrate, an alignment and reasoning layer (RLHF, DPO, GRPO, chain-of-thought), and the agentic layer proper — harness, memory, retrieval, design patterns, and coordination via protocols like MCP and A2A. Its thesis: building a good agent means understanding every layer, not just the model.
Get started → · ← All guides · Compare Kompozy vs other tools