Start Here: From Memory to Agents

Welcome — you're at the start of something genuinely useful. By the end of this course you'll be able to look at a messy, real-world problem and know exactly how much of it to hand to an AI, what to keep in your own hands, and how to set things up so the system helps you instead of surprising you. That's the whole arc: from typing prompts into a chat box to designing systems that work alongside you.

This first lesson is your map — where we're headed, the single idea that holds it all together, how the path is laid out, and the very first layer everything else rests on.

The one idea to carry the whole way

If you remember nothing else, remember this: a system that runs on its own amplifies whatever structure you give it. Hand it a fuzzy goal and it produces fuzziness, faster. Hand it a clear goal, the right context, and a few firm boundaries, and it multiplies your judgment instead of your mistakes.

So getting good results has surprisingly little to do with finding a cleverer model, and almost everything to do with the structure and judgment you bring — what you're really trying to achieve, what must stay human, and what can safely be handed to a system that keeps working after you've walked away.

What you'll be able to do by the end

This isn't a tour of features. By the end you'll be able to take a real task and design how an AI should handle it: break it into what to delegate and what to hold onto, give the system the context it actually needs, set boundaries so a mistake stays small, and check its work before you trust it.

Concretely, you'll move from "asking a chatbot for help" to "standing up a system that does real work on your behalf — safely."

How the course is built

We get there in two passes. First, these seven short foundation lessons build the shared vocabulary the rest of the course leans on, tracing how working with language models grew up: from a model that simply remembers your preferences, to systems that retrieve knowledge, manage their own context, reach into your tools, and finally act on their own. Each stage did not replace the one before it — it absorbed it. A modern agent still uses a system prompt, still depends on good prompting, still retrieves with RAG, still lives or dies by context engineering, and still reaches the world through protocols like MCP. Then the fourteen main lessons turn that vocabulary into practice, on real problems you care about.

Read this first part as a layered stack — every layer adds a new capability, and a new kind of responsibility. The diagram below is the whole territory at a glance.

How to get the most out of it

Two habits will carry you. First, treat this as hands-on: the ideas only really land once you've put your hands on them, so do the small build at the end of each lesson rather than just reading past it. Second, keep one question running quietly in the back of your mind the whole way — what am I handing to the system, and what am I keeping for myself? That single question is the through-line of everything ahead. Capability and responsibility climb together; the skill is deciding, layer by layer, where the line sits.

Everything else builds on a first layer, so that's where we'll start: the two simplest ways a model is shaped, before anyone types a word — the system prompt and memory.

The system prompt

A system prompt is a standing instruction prepended to every conversation. It sets the model's role, tone, rules, and boundaries before the user says anything. Where a user message asks for one thing, the system prompt governs how the model behaves across all things — "You are a careful financial assistant; never give tax advice; cite sources." It is the cheapest, highest-leverage control surface you have, and it is the seed from which every later technique grows.

Memory and preferences

Early assistants were stateless: each request started from zero. Memory changed that. Consumer products now persist facts about you ("I write in British English", "I run a nonprofit") and silently inject them into context on future turns. Persistent agent runtimes take this furthest: Hermes Agent (Nous Research) ships a built-in learning loop that creates skills from experience and builds a deepening model of who you are across sessions, and OpenClaw maintains long-term memory of your preferences across every channel you message it on. Research frames this as the defining feature of modern agents — a memory mechanism that lets a system accumulate and reuse experience rather than re-deriving it every time.

Example. You tell an assistant once that your company is called Centpol and you prefer concise bullet answers. A stateless model forgets immediately. A memory-enabled one stores both facts and applies them next week without being reminded — the first, faint version of an agent that "knows" your world.

The trade-off arrives immediately: memory that helps can also leak, drift, or go stale. Deciding what deserves to be remembered is the first act of context discipline — the through-line of this entire course.

References & further reading

• Nous Research (2026). Hermes Agent — Documentation. hermes-agent.nousresearch.com.
• Steinberger, P. (2026). OpenClaw — Personal AI Assistant. openclaw.ai.
• Brown et al. (2020). Language Models are Few-Shot Learners (GPT-3). NeurIPS.
• Zhang et al. (2024). A Survey on the Memory Mechanism of LLM-based Agents. arXiv.
• Anthropic (2024). Prompt Engineering Overview. Claude Docs.