Module 1 of 6

Anatomy of an agent

What makes an agent different from a chatbot, the five parts every agent is made of, and the three words that keep the whole field straight. You leave with your first agent spec written. Not installed, not running: designed. Designing the agent is the hard part. Implementation is what Module 2 is for.

By the end of this module

Explain what an agent is using the five-part anatomy: Identity, Job, Context, Tools, Output
Place yourself on the AI builder ladder and know where this curriculum is taking you
Tell a skill from an agent in one sentence, using the decision rule
Write the five-part anatomy for an agent you actually want working for you

Watch

The two videos

recording soon

Concept video2–4 min

The ladder, the five parts, and the decision rule, in plain language.

scripts/M1-anatomy-concept-script.md

recording soon

Build With Me video5–8 min

The annotated scribe walk-through from Linda’s own workspace, then dispatching it live.

scripts/M1-anatomy-build-with-me-script.md

Concept

The ladder

Most people stop at the bottom rung: ask a question, get an answer, start from zero next time. This curriculum takes you to the top.

Rung	Surface	What you do here	Why you don’t stop here
1LLM chat	Claude.ai · ChatGPT	Ask, get an answer.	Every chat starts from zero. No memory, no compounding.
2Projects	Claude Projects	Same chat + persistent files + standing instructions.	You compound knowledge but you can’t dispatch work.
3Skills	Cursor + Claude Code	Reusable workflows you trigger by phrase, like /meeting-recap.	Still runs in your current chat.
4Agents	Cursor + Claude Code	Specialists in their own context window, dispatched to do whole jobs.	Where builders live.

This series is about using Cursor + Claude Code to build a system for your work: your Hub. Today we stay in familiar chat surfaces because M1 is about the mental model. The building starts in M2.

The currency is markdown

Once you cross from Projects into Cursor + Claude Code, everything the system knows lives in markdown files: plain .md text you can read, edit, and back up to GitHub with every version kept (M2 shows you how). Skills are markdown. Agent specs are markdown. Context (what the agent knows about your work) and memory (what persists across sessions) are markdown files in your repo. That is why this stack wins for building systems: the building blocks are legible.

A note on Claude Desktop: it is chat with tools attached, and it is genuinely useful for ad-hoc tasks. Nothing wrong with using it. This curriculum is not built there because our objective is a durable system, and the system lives in files.

What makes an agent different from a chatbot

A chatbot answers in one turn. An agent does multi-step work: it reads files, uses tools, follows a procedure, and returns a finished result. That is the structural difference, and it is visible the first time you watch one run.

One thing to know about the model underneath, before you build on it: a language model generates the most statistically likely next words, not the most accurate ones. It pattern-matches; it does not look facts up. That is why every spec in this curriculum names what the agent must never invent: the rule exists because, left unguarded, the model fills gaps with something plausible. You will see the pattern in every spec we write, starting with today’s.

Agents sit on the bench, ready to work. You call them two ways:

Ad hoc: you dispatch them when you need them. Most agents you build start here.
Scheduled: they run on a recurring schedule without you. We cover this in M5.

Either way, the agent does the job end-to-end and reports back.

Five parts make an agent

When you build an agent, you are defining a specialist. Five parts make it work:

Part	What it answers
1. Identity	Who is this? Persona, lens, voice
2. Job	What is it responsible for? Scope and procedure
3. Context	What does it know? Sources, files, memory
4. Tools	What can it do? Read, write, search, call APIs
5. Output	What does "good" look like? Format, length, guardrails

The five parts are the agent spec. There is no second artifact: the document that answers these five questions is the thing you ship into your Hub. Useful test for each part: what would I tell a new hire on their first day?

Three words to lock down

These terms show up in every workshop, tutorial, and doc you read this year. Define them once, never get confused again.

Primitive	What it is	“Hire” analogy
Skill	A reusable workflow you trigger with a phrase like /bluerock:meeting-recap. Runs in your current chat.	A macro or SOP you follow yourself
Agent	A specialist with its own persona, dispatched to do a whole job. Runs in its own context window.	Hiring a specialist who works in another room
Subagent	Same thing as an agent. The word emphasizes it was called by another agent.	A sous-chef the head chef calls in

The decision rule: if you can finish the job in your current chat, it is a skill. If you would rather hand it off and check back, it is an agent. “Subagent” is a relationship word, not a thing word: it just means an agent that another agent dispatched.

Worked example

Reading scribe against the five parts

The artifact is scribe: a real, working end-of-day note-filer that ships in the BlueRock plugin. Read the plugin’s version below — the exact file being narrated. You will run this agent yourself in M2, and build your own in M4. Today we read it against the five parts and ask, for each piece: why is it shaped this way?

bluerock plugin · scribe agentworked example

---
name: scribe
description: My end-of-day note-filer. Tell me what happened
  today in chat, or paste a Granola transcript, and I'll file
  it into the right section of notes/<today>.md. Use whenever
  I want to capture something without thinking about where it
  goes. Pairs with daily-brew, which reads tomorrow morning
  whatever I filed today.

1The frontmatter is the job posting.

name is how you dispatch it. description is not decoration: it is how the system (and future-you) knows when to use this agent. Notice it names the inputs, the output location, and its partner agent. One field, whole employment contract.

tools: Read, Write, Edit, Glob
model: sonnet
---

2tools is least privilege.

Scribe gets enough to file notes, nothing more. No web access, no shell. In plain English: Read opens a file, Write creates one, Edit changes one, Glob finds files by name pattern (how scribe locates notes/). These four cover most first agents, and they are the only names you need for now. The tools line is where you decide what an agent cannot do, and the reason is concrete: an agent with Write access to folders it does not need will eventually write there by mistake. This line is the fence between the agent and the rest of your repo, and it is the heart of how builders keep agents on the rails.

## Identity

You're a fast, quiet archivist. No questions, no clarification
rounds unless what I gave you is truly ambiguous. You file.
You confirm. You move on.

3Identity shapes behavior, not branding.

“Fast, quiet archivist” is doing real work: it suppresses the model’s instinct to ask clarifying questions and chat back. Every sentence in Identity should change how the agent behaves. If a line wouldn’t change behavior, cut it.

## Job

Take whatever I give you — a chat description, a pasted
Granola transcript, raw bullets — and write it into the right
section of today's notes file.

1. Determine today's date. Compute notes/YYYY-MM-DD.md.
2. If the file exists, append. If not, create it from
   notes/_TEMPLATE.md.
3. Parse my input into these sections: Meetings · Decisions /
   commitments · Open threads · Brain dump
4. After filing, return a one-paragraph confirmation.

4Job is a procedure, not a vibe.

Four numbered steps with named files and named sections. The agent never has to guess where things go, and neither do you when you read its output. Compare to the prompt most people write (“organize my notes”): the spec versions the decisions, so they are made once.

## Context

- Granola transcripts: treat speaker names and timestamp as
  meeting metadata. Extract attendees, the high-leverage
  takeaway, commitments.
- Chat descriptions: parse the same way.
- Read notes/_TEMPLATE.md the first time you create a date file.

5Context is the new hire’s onboarding packet.

It tells the agent how to interpret each input type it will actually receive. This is where your domain knowledge gets encoded: what a Granola transcript is, what counts as a commitment, where the template lives.

## Output

- The file write is the primary output.
- Return a one-paragraph confirmation: filename, sections,
  what you added. Do NOT re-print the full notes file.
- Never overwrite existing content. Always append.
- Never edit yesterday's notes or earlier. You only write
  to today.

6Output is where the guardrails live.

The last two lines are the most important in the file: append-only, today-only. They bound the blast radius of a mistake. A well-specced agent states what it must never do as plainly as what it should do. When you run many agents on real work, “what is this allowed to touch?” becomes the operating question.

The takeaway: nothing in this file is clever. It is a patient, specific answer to five questions, written like instructions to a competent new hire. That is the craft.

You build

Spec the agent you actually want

Your turn

Write the five-part anatomy for one agent you actually want. Not a toy: a job you genuinely wish someone else did every day or every week.

1Pick the job. The best first agents are repetitive, text-in / text-out, and low-stakes if they get something slightly wrong. (Meeting capture, weekly status drafts, inbox triage summaries, research recaps.)
2Open a new chat in any AI tool you already use (Claude.ai, ChatGPT, or similar), or just a fresh doc. A Claude Project works well if you want a sandbox that keeps your drafts together, but nothing about this step requires one. Title it with your agent’s name.
3Write the five sections in order: Identity, Job, Context, Tools, Output. Use the new-hire test on each: would a competent person know what to do from this alone?
4For Tools, list only what the job needs. Stick to the four you saw in scribe (Read, Write, Edit, Glob) — they cover most first agents. Practice saying no: what should this agent not be able to touch?
5Read it back against scribe. Where scribe is specific (named files, numbered steps, never-do rules), is yours?

You are done when

Checkmarks save in this browser only

This spec becomes the first file committed into your Hub in M2. Keep it.

Use it for real

Between now and M2

Take-home

Sketch the anatomy for a second agent, this time straight from a real annoyance in your week. You will notice the second one is faster to write: the five questions are now a lens, not a form. Bring both specs to M2; they go into .claude/agents/ in your new Hub.

Before the next module

Checkmarks save in this browser only

The meta-layer

How Linda does this

Patterns from How I work with AI that show up in M1:

1The Hub mindset

Preview only. The agent you specced today needs a home with context and memory; that home is the Hub you build in M2.

2Skills, not prompts

The worked example is the same move one level up: decisions written down once, reused forever.

6Parallel agents

Linda’s marketing hub dispatches multiple specialists in one go. M1 designs one agent; the ceiling is a bench of them working at once.

M2 — Build your Hub

Continue