From Chat to Agent series cover — hand-drawn capability ladder with seven rungs between 'Chatbot' at the bottom and 'Agent' at the top, each labeled with a plain-English annotation
Series in progress

From Chat to Agent

A step-by-step tour of the seven capabilities that turn a language model from a chatbot into a true agent. Plain-English map for engineers and curious non-engineers alike.

9 parts 1h 32m total
Begin with Part 1

In this series

  1. 1 From Chat to Agent: Why the Leap Matters 9 min read

    A chatbot answers. An agent finishes the job. The gap between them is not one feature — it's a stack of seven capabilities, built one rung at a time. This series walks that stack in plain English, for engineers and curious non-engineers alike.

  2. 2 The Chat Baseline: What You're Starting With 9 min read

    Every AI product in the world starts as the same small, strange thing — a stateless function that turns tokens into tokens. Understand that substrate clearly and every capability above it stops looking like magic.

  3. 3 System Prompts & Personas: The Cheapest Control Surface 9 min read

    Before RAG, before tools, before agents — a well-written system prompt is still the single highest-leverage knob you have. Here's what it actually does, why most people misuse it, and what its honest limits are.

  4. 4 RAG — Giving the Model a Library 11 min read

    Your company's docs, this morning's tickets, yesterday's deploy notes — none of it is in the model. Retrieval-augmented generation hands it the right page, right before it answers. Here's the two-phase pipeline, honest failure modes, and what 'embeddings' actually are.

  5. 5 Tool Use — Giving the Model Hands 11 min read

    Text in, text out — until you let the model call functions. This is the moment a chatbot stops explaining how to do things and starts actually doing them. Here's what function calling really is, the typed contract that makes it work, and why this is the hinge rung of the whole ladder.

  6. 6 The Agent Loop — ReAct, Plan-Act-Observe 10 min read

    One tool call is an API. A loop of tool calls with reasoning in between is an agent. This post walks through the four-step cycle that turns one-shot chat into step-by-step work — and the surprisingly tricky question of when to stop.

  7. 7 Memory — How Agents Build Continuity 10 min read

    Context windows forget. Production agents don't. The difference is a layered architecture: working memory, session memory, and long-term memory split into facts, events, and skills. Here's how real agents remember — and why forgetting on purpose matters.

  8. 8 Multi-Agent Systems & Production Platforms 12 min read

    One agent is a worker. A team of agents with a supervisor, evals, tracing, guardrails, and cost control is a platform. Here's when multi-agent actually helps, when it hurts, and the four pieces of scaffolding that turn a demo into a product you can run.

  9. 9 Skills — Giving an Agent a Playbook 11 min read

    Bonus post. Skills are not a new rung on the ladder — they're a way of packaging the rungs you already have, so an agent can pull a mini-playbook off the shelf on demand instead of carrying every instruction in its head. Here's the concept, the mechanism, and when to reach for one.