From Components to Technology

Which real tool builds each part of the loop

Day 1 · Phase 1 — Synthesis

You Know the Four Parts — Now What Builds Them?

You just took the agent apart: Perceive → Reason → Act → Remember.

That was the anatomy. This is the parts list — the concrete technology behind each box, and the layers that wrap all of them.

Keep this map in your head all weekend.
Every lab is you building one of these boxes.

The Map — One Box, One Technology

Component What it needs Built with
Perception see the current state the context window — file reads, tool results, the user's ask
Reasoning decide the next move the LLM + a precise system prompt
Action change the world MCP tools / function calling — the harness
Memory carry state forward a store: JSON today, SQLite tomorrow, + history
The loop repeat until done the host / runtime (Antigravity) that orchestrates

Four boxes plus the loop. That's every agent — yours included.

The Same Anatomy, the Industry's Words

Our four are capabilities — what an agent does (verbs). The names you'll meet in the wild (Google's Agents papers, Anthropic) are components — what you assemble (nouns). Same system, two lenses:

Our lens (verbs) Industry lens (nouns) Analogy
Reasoning Model the brain — you rent it
Action Tools the hands — you build them
Perception · Memory · loop Orchestration nervous system — assembles context, holds state, runs the loop
(where it runs) Deployment body & legs — host, serve, monitor

We teach the verbs because they're how you think; you'll read the nouns because they're how the field talks.
Note the 4th — Deployment — the box we don't build today, but production always needs.

Single Boxes — and Where StackLog Lands

Each box is one swappable piece. Change the store, the loop still runs. Change the model, the tools still work.

  • Lab 2 — you build StackLog's Action box (the MCP server) and its Memory box (the JSON store).
  • Lab 3 — you wire the whole loop and run it autonomously.
  • The host (Antigravity) is the orchestration you don't have to write.

Reasoning you rent (the model). The rest you design.

Cross-Cutting Layers — They Wrap Every Box

Some things aren't one component — they govern the whole loop, every turn:

  • Specification — the source of truth: what to build and why. Outranks the model's guesses. (Day 2)
  • Constitution — project-context.md / CLAUDE.md / AGENTS.md (the emerging cross-tool name): standing rules the agent re-reads every loop. The things that are always true.
  • Skills — named, reusable capabilities the agent can invoke. A packaged procedure, not a one-off prompt.

Components do the work. These layers decide whether the work is right.

Two Kinds of Tools — Task vs. Maintenance

Not every tool does the task. Some keep the system honest over time.

Task tools — get the job done:
search · create_entry · write_file · GET /entries

Maintenance tools — keep it correct as it grows:
code review · spec-drift check · tests · the Reviewer agent (Day 2)

A junior builds task tools. An architect also builds the tools that guard them.

The Loop Is Fractal

Here is the seed that grows all weekend:

Any Action box can itself be another agent.

A single tool call can hide a whole sub-agent — running its own perceive → reason → act → remember loop, and returning just the result.

  • One agent → a pipeline of tools (Lab 3)
  • One agent → a team of named sub-agents (BMAD personas, Day 2)

Zoom into any box and you may find the same loop again.

The Box We Build First: Action

Of the five, Action is where a chatbot becomes an agent — and it is the hardest to do safely.

The technology for the Action box has a name: MCP, the Model Context Protocol.

Next phase: how a model actually reaches out and
touches a real system — without breaking it.

Anchor This

The anatomy is four parts and a loop.
The technology is: a model you rent, tools you build,
a store you choose, a host that orchestrates —
all governed by a spec, and fractal all the way down.

Build the boxes. Wrap them in the layers.
Know when one box is secretly an agent.