The parts of an agent: goals, guardrails, memory

An agent is a loop with six things attached. You can point at each one in a template you downloaded, and name it in a tool you are reading about.

The loop is the seventh thing, and it is not a file: look, decide, act, look again, until the job is done or the agent stops. Arize calls it the foundation, and everything else is what the loop can reach (April 2026).

A template's quality is mostly a question of how much thought went into parts two to six. Anyone can write a goal. The work is in the guardrail and the report.

Instructions say what the job is and how the agent should sound. In our packs they live in SOUL.md, as a goal, a style line and an authority line.

Other tools draw the same three things differently. CrewAI gives an agent a role, a goal and a backstory (docs). Claude Code writes one markdown file per subagent with a description and a prompt (docs). Codex reads a repository's AGENTS.md (docs).

The test is the same everywhere: if you cannot tell whether the job was done, it is a wish rather than a goal. What's inside an agent template shows a goal that passes and one that drifts.

A skill is a folder with a short file in it: when the skill applies, the steps to take, and the mistakes worth a warning. Anthropic published that format as an open standard on 18 December 2025, and it is now used well beyond its own tools (specification).

The clever part is what a skill does not do. Only a short description of each skill sits in front of the model by default, and the full file loads when the skill is needed, which keeps a large library cheap (Agent Skills overview).

This is where a pack stops being generic. Your invoice shapes, your supplier names, the table your finance team actually reads: all of that belongs in a skill.

Two things get called memory, and the difference decides what you configure.

• The conversation in front of the agent right now. Finite, and it does not survive the session.
• The notes it keeps between runs: what it learned about your files, and which approach failed last time.

The first one runs out. Anthropic's docs call the limit a working memory, and put some current models at a million tokens and others at 200,000 (context windows).

When a conversation approaches that limit, the agent shortens it: it writes down what mattered and lets the rest go. Anthropic defines that as compaction, taking a conversation near the limit, summarising it, and starting again from the summary (compaction).

Compaction is lossy by design, and the MemGPT paper says so plainly: repeated summarisation eventually leaves holes in what the system remembers (arXiv:2310.08560). So a good template says what is worth keeping, and writes it down before the summary has to decide.

A guardrail is any rule that keeps an agent inside a boundary, and every harness implements one somewhere. The strongest version is enforced by the program rather than asked of the model.

Claude Code takes three lists, allow, ask and deny, and reads them in that order of severity, so a rule that denies wins over a rule that allows (permissions). Its own docs warn that instructions in a prompt do not change what the tool permits, which is the point.

OpenAI's Agents SDK puts the same idea in code as input and output guardrails that trip a wire when a rule is broken (guardrails). Codex separates the sandbox, what the agent can reach, from the approval policy, when it must ask (agent approvals).

In our packs the same thing is one line of English in SOUL.md. What to let your agent touch turns that line into settings.

An agent that runs while you sleep needs to leave a note. The format is settling around OpenTelemetry's conventions for generative AI, which describe spans for invoking an agent, calling a tool and using tokens (semantic conventions). Those conventions are still marked in development, so treat them as the direction rather than a finished standard.

For a person rather than a dashboard, the useful shape is shorter: what ran, what it changed, what it flagged, what it recommends changing next time. That is what a reporting skill in a pack produces, and it is why What's inside an agent template puts reporting next to memory.

This stops being optional in some places. Europe's AI Act requires high-risk systems to record events over their lifetime (Article 12). Most agent work is nowhere near that line, and a wheel of log files is not a record either: the record is the part somebody reads.

Self-improvement is a real mechanism with a boring shape: the agent writes down a lesson, the lesson carries a status, and the next run reads it before starting. Reflexion showed in 2023 that keeping a written reflection and replaying it lifted results by about eight points (arXiv:2303.11366).

Voyager went further in the same year, building a library of skills the agent wrote itself, indexed so it could find them again, and only keeping a new one after checking it worked (arXiv:2305.16291). That is the closest published ancestor of a template that improves its own skills.

Two honest caveats. All of it depends on a reliable signal that the work succeeded, which is exactly what a fuzzy job lacks. And a template that claims to improve without showing you the notes it keeps has shown you nothing.

Keep this table open the first time you read an unfamiliar tool's documentation. Every row is one of the six parts, renamed.