Agent memory vs skills vs context is not a terminology debate. It is an ownership decision about what an AI workflow carries forward, where it lives, who can change it, and which source wins when two layers disagree.
Frontier AI companies are moving in the same broad direction through different products:
- OpenAI Dreaming synthesises memory across ChatGPT conversations.
- Claude can search past chats and maintain user- or project-scoped memory.
- Microsoft Copilot carries preferences and work context while grounding responses in organisational sources.
- Amazon Bedrock AgentCore can form episodes and reflections from completed interactions.
- Gemini can personalise responses from past chats and connected personal information.
These capabilities reduce the cold start between sessions. None removes the need for explicit skills, current source retrieval, operator-owned project history, or authoritative business records.
The five persistence layers
The cleanest operating model gives each layer a distinct job.
| Layer | What should persist there | What should not silently persist there |
|---|---|---|
| Context window | Current request, retrieved evidence, tool results, working reasoning inputs | Durable policy or project truth merely because it was mentioned once |
| Agent memory | Useful preferences, recurring goals, ongoing context, and retrievable past experience | Unreviewed authority, secrets, or the only copy of a consequential decision |
| Agent skill | Versioned procedure, trigger, resources, checks, stop conditions, and review boundary | Mutable business state, broad personal history, or credentials |
| Operator-owned repository | Accepted software intent, code, tests, plans, tasks, skills, evidence, and Git history | Every raw conversation or operational record regardless of purpose |
| Business system of record | Authoritative customer, employee, financial, compliance, operational, or transaction data | General agent recollection or unapproved workflow inference |
The boundaries can overlap in implementation. Their authority should not.
Context is temporary working material
The context window contains what the model can use during the current interaction. It may include conversation history, documents, repository files, retrieved memories, database results, and tool outputs.
More context is useful until relevance falls. A large window can still contain stale instructions, conflicting versions, unnecessary private data, or distracting detail. It also does not decide what should be available next month.
Treat context as a deliberately assembled workbench. Load what this task needs, preserve provenance, and discard what has no continuing purpose.
Memory carries adaptive continuity
Agent memory reduces repeated explanation. It may remember a preferred communication style, an ongoing initiative, a recurring difficulty, or a pattern learned from past episodes.
The current products expose different control models:
- OpenAI makes its synthesised memory available through a memory summary and conversational correction.
- Claude exposes remembered categories, past-chat citations, project separation, and memory controls.
- Microsoft provides user memory management and work-data grounding.
- AWS lets builders choose memory strategies and namespaces.
- Google's Gemini memory guidance lets eligible users enable past-chat personalisation, ask whether past information was used, correct it in chat, and manage the underlying activity.
Memory is adaptive because it selects and synthesises. It must therefore be correctable and subordinate to current evidence.
Skills carry reusable method
A skill answers “how should this agent perform this repeated job?”
It can preserve:
- a precise trigger
- required inputs and prerequisites
- a step-by-step procedure
- scripts, templates, and examples
- allowed tools and permissions
- validation expectations
- stop and escalation conditions
- the human review boundary
Skills should be versioned because changing a procedure can change every future execution. They should remain portable where possible so the working method is not trapped in one model's memory.
Read AI agent skills: the new workflow layer for that foundation and How to design an agent skill for the practical method.
The repository carries accepted software memory
The repository is the long-term memory of the software the operator is building.
Its current tree records the accepted implementation. Git history records how that implementation changed. Plans and tasks preserve intent and decomposition. Skills and instructions preserve working methods. Tests describe expected behaviour. Reports and evidence show what was checked. Reviews and commits create an accountable transition from proposal to accepted state.
That makes repository memory:
- operator-owned
- explicit rather than inferred
- inspectable through ordinary files and diffs
- portable across compatible agents
- reviewable by people
- reversible through version history
- testable against the actual software
- durable beyond a single provider account
It is not automatically intelligent. An agent still needs retrieval and reasoning to find the relevant history. That is where frontier memory can add enormous value.
Systems of record carry governed operational truth
SwarmCraft can help the operator build both owned surfaces. The repository holds the software's intent, source, schemas, migrations, controls, tests, and change history. The deployed application and its database can become the business system of record for operational records deliberately brought inside the agreed boundary.
A payroll engine, accounting ledger, identity system, CRM, regulated register, or customer platform may retain authority for adjacent facts left outside the owned operation. Memory can help the agent locate those facts. Tools can retrieve them. A skill can explain how to use them. The context window can hold them temporarily. None of those layers becomes authoritative merely by seeing the data.
What this means for SwarmCraft
SwarmCraft's opportunity is to combine the best qualities of adaptive agent memory, owned repository memory, and an operator-owned software operation that can include its own authoritative business records.
The agent should arrive with useful continuity. It should recognise what the operator has been building, retrieve likely relevant work, and avoid repeating resolved questions. It should then ground that understanding in the repository, load the applicable skills, inspect current records and evidence, and show the operator the resulting change.
A productive loop looks like this:
- Memory identifies potentially relevant prior context.
- Repository retrieval finds the current implementation and accepted history.
- Skills provide the repeatable working method.
- The owned application's system of record—and deliberately retained external systems—provide current operational facts.
- The agent performs bounded work with explicit tools.
- Tests and checks produce evidence.
- The operator reviews the diff and consequence.
- Git records the accepted change.
- Later reflection proposes improvements grounded in completed outcomes.
This can improve productivity because less context has to be rebuilt manually. It can improve quality because accepted learning becomes a reviewable project asset rather than remaining an invisible impression inside one assistant.
A persistence decision test
For every piece of information an agent may carry forward, ask:
- Is it only needed for the current task? Keep it in context.
- Is it a useful preference or ongoing topic? Consider memory with user control.
- Is it a repeatable method? Put it in a versioned skill.
- Is it accepted software intent, implementation, or evidence? Commit it to the repository.
- Is it an authoritative operational fact? Keep or deliberately migrate it within the owning operation.
- Is it sensitive, irrelevant, or unsupported inference? Do not persist it.
- Can the operator inspect, correct, export, and remove it?
- Can a future agent trace the evidence behind it?
The answer is rarely “remember everything.” The aim is to preserve the smallest useful form in the layer that can govern it properly.
The best of both worlds
Frontier-company memory makes assistants more continuous, personal, and adaptive. Operator-owned repositories make software history explicit, portable, testable, and accountable.
Together they can produce a better kind of agentic workflow: one that remembers enough to move quickly, retrieves enough to remain grounded, follows versioned methods, and leaves the operator with source code and history they continue to own.
Start the series with OpenAI Dreaming: AI beyond the context window, then follow Claude memory, Microsoft Copilot memory, and AWS episodic memory.
