Why Agent Skills Aren't Memory — and What to Do About It (2026)

Agent Plugins 1.0.0 landed on August 6, 2026, announced on the Google Developers Blog. It's a package format that bundles Agent Skills and MCP servers into a portable directory structure with fixed locations for each. The backing list is the interesting part: Amazon, Cursor, Microsoft, OpenAI, and Vercel, with Google joining as a Core Maintainer. Support already spans the Agents CLI — which covers Antigravity, Gemini CLI, Claude Code, and Cursor — plus the Data Agent Kit, with a compatible-client list maintained at agent-plugins.org.

The problem it solves is stated plainly in the announcement: "Plugin authors shouldn't have to choose between reaching every client and using what makes each client good." The goal is that a plugin's components are "portably available across any compatible client."

Then comes the sentence that matters for anyone thinking about memory. The spec draws its own boundary: Agent Plugins v1 "is a package format and nothing more. It defines no install mechanism, no distribution protocol, no permission model, no sandboxing requirements, no trust or provenance verification, and no user experience."

That's not a criticism — a tight scope is why specs ship. But read the list of what's out of scope and notice what isn't even on it. Memory and persistent state aren't excluded; they were never in the conversation. The format standardizes the capability layer, and the capability layer is a different thing from your accumulated context.

The research points the same way. A preprint titled SkillOpt: Executive Strategy for Self-Evolving Agent Skills (arXiv 2605.23904, submitted May 22, 2026, and picked up in industry coverage on August 5) treats a skill document as trainable external state for a frozen agent: an optimizer model turns scored rollouts into bounded add/delete/replace edits on a single skill file, and an edit is accepted only when it strictly improves a held-out validation score. Across six benchmarks, seven target models, and three execution harnesses — direct chat, Codex, and Claude Code — the authors report their method best or tied on all 52 evaluated (model, benchmark, harness) cells, lifting GPT-5.5's average no-skill accuracy by +23.5 points in direct chat, +24.8 inside the Codex loop, and +19.1 inside Claude Code.

The line worth holding onto is the transfer result: optimized skill artifacts retain value when moved across model scales, between Codex and Claude Code execution environments, and to a nearby math benchmark without further optimization. A procedure trained in one harness keeps working in another.

Two caveats before that becomes a thesis. It's a preprint, not peer-reviewed work. And the paper is from May 2026 — the August date is when the coverage circulated, not when the research appeared. What's genuinely new this week is the packaging standard; SkillOpt is the evidence that the thing being standardized is in fact transferable.

One is general, the other is yours

A skill encodes a repeatable procedure. That's precisely why it transfers: nothing in "how to audit a spreadsheet for broken references" depends on which spreadsheet, which company, or which quarter. Strip the specifics out and you get something publishable — which is what a package format assumes you have.

Memory is the specifics. Your chart of accounts, the naming convention you enforce, the vendor whose API returns 200 on failure, the decision you made in March and the reason behind it. There's no version of that which is useful to anyone else, and no version of it that can be authored once and installed. It has to be captured from your work, and it grows.

One is authored, the other accumulates

You write a skill deliberately and it holds still. You can review it, version it, ship a 1.1. It's an artifact with an author.

Memory has no authoring moment. It's produced as a side effect of working — a correction here, a decision there, a constraint discovered at 6pm. Which means the failure mode is completely different: skills fail by being wrong, memory fails by never being written down at all. A package format can't fix the second problem because there's nothing to package yet.

A skill tells the agent how; only memory tells it about here

This is where the confusion gets expensive. Install a well-optimized code-review skill into your agent and it will review code well — generically. It will flag the missing null check and miss that your team deliberately allows that pattern in the adapter layer because of an upstream quirk. The procedure was excellent. The context was absent.

Teams read that outcome as "the skill needs tuning" and iterate on the skill. The skill was fine. What's missing is the layer that would have said here, we do it this way, and here's why — which is also why retrieval over your docs isn't the same as memory: finding a document that mentions the adapter layer is not the same as the agent knowing the standing decision.

Portability makes the gap more visible, not smaller

Here's the slightly counterintuitive consequence. The easier it becomes to move skills between Claude Code, Cursor, Codex, and the rest, the more often you'll actually move — and every move resets the knowledge side to zero while the capability side arrives intact. The standard removes friction from half the stack. The half it doesn't touch is the half that took you six months to accumulate.

Putting project context inside the skill. The obvious move, and it works until it doesn't. You've now made the skill unpublishable, unversionable across projects, and stale the moment a decision changes. You also can't share it, which was the point of a package format.

Stuffing everything into the instructions file. AGENTS.md, CLAUDE.md, .cursor/rules — these are genuinely the right home for standing rules, and Cursor's own documentation recommends keeping rules under 500 lines for good reason. Instruction files are loaded on every task, so they're a per-request tax. They're for rules, not for the accumulated record.

One giant plugin per client. Some teams solve portability by maintaining a per-tool bundle with context baked in. That's three copies of the same knowledge drifting apart, which is worse than one copy nobody can move.

Re-explaining at the start of each session. Universal, and it degrades — the version you type on Thursday is shorter than Monday's, because you're summarizing from memory and the exclusions are the boring part.

Letting each tool's built-in memory handle it. Reasonable, and worth enabling where it exists. The catch is that these stores are per-tool, usually per-machine, and non-exportable, so they reproduce the exact problem the plugin spec was written to solve — one layer down, where no standard exists yet.

Split the layers on purpose and give each one the storage it deserves.

Skills go in plugins. Author them clean and general, keep them free of anything that identifies your codebase or your client, version them, and let the new format carry them to whatever harness you're using this quarter. That's what it's for and it now works.

Context goes in a memory layer that lives outside any single tool and that every tool reads. Not a bigger instructions file — a store holding the documents, decisions, and constraints your work produced, retrieved when relevant rather than loaded on every request. MemoryLake is built for that side of the split: one store your agents read from over MCP or the API, so switching harnesses changes a config entry rather than restarting your institutional knowledge.

One honest boundary. A memory layer doesn't make an agent follow what it reads — attention and instruction-following are model behavior, and no storage layer guarantees compliance. What it changes is that the relevant context is available and short at the moment it matters, rather than absent or buried in a file that grows until the model stops attending to the middle of it.

Step 1: Create an API key

Generate a key and make your first request in about 30 seconds. Keep it in your environment or a secret manager — note that Agent Plugins v1 explicitly defines no permission model, so nothing about the packaging standard is going to protect a credential you baked into a bundle.

Step 2: Upload your first memories

Drop in the documents, images, and files that hold the specifics: the architecture decisions, the conventions doc with its reasons, the client brief, the postmortem. Upload sources rather than summaries where you can. This is exactly the material that can't go in a shareable plugin, which is why it needs its own home.

Step 3: Connect your AI & agents

Give Claude, Codex, OpenClaw, and other AI agents access to memory via MCP or the API. Since plugins already bundle MCP servers with a fixed configuration location, the memory layer slots into the same wiring your skills use — the capability layer and the knowledge layer arrive through the same door, from different stores.

The skill you install starts behaving like your team wrote it. Same generic procedure, now applied to a codebase whose conventions and exceptions are retrievable — so the code-review skill stops flagging the adapter-layer pattern your team deliberately allows.

Tool switches get cheap in both directions. Skills move because the format moves them; context moves because it was never inside the tool. That's the first time both halves of an agent setup have been portable at once, and it's the practical reason running Codex and Claude Code side by side stops requiring two maintained copies of the same conventions.

Your instruction files get smaller. Once the accumulated record has somewhere to live, AGENTS.md goes back to being a short list of standing rules instead of a growing archive — which is better for cost and better for compliance, since a 500-line rules file is one the model attends to unevenly.

And skills become shareable. Most teams can't publish their internal skills today because context is welded into them. Separate the layers and the skill is publishable by construction.

Apply the "could a competitor use this?" test

Write a skill, then ask whether a company in your industry could install it unchanged and benefit. If yes, it's a skill — keep it general and package it. If no, you've written context wearing a skill's clothes, and it belongs in the memory layer where it can be updated without shipping a new version.

Keep instruction files for rules, not records

Anything loaded on every request should be short, imperative, and stable. Decisions, history, and reference material belong in a store queried on demand. Mixing them is how you get a file that's expensive on every task and still doesn't contain the thing you needed.

Version skills, date memories

Skills get semantic versions because they're authored artifacts. Memory entries get effective dates because they're records of decisions — and a superseded decision has to stay readable, or you can't interpret last quarter's work. Different storage disciplines for different failure modes.

Don't wait for a memory standard

MCP standardized how agents reach tools; Agent Plugins standardized how capabilities are packaged. There's no equivalent agreement for portable user memory, and the plugin spec's own scope statement makes clear it isn't attempting one. Choosing a store that any client can read over MCP or an API is the available answer, and it's the one that survives whatever standard eventually arrives.

August 6 was a real milestone: six vendors agreeing on one package format for skills and MCP servers is how ecosystems stop being per-tool. And the spec's own boundary statement is the most useful sentence in the announcement — it's a package format and nothing more, which means the layer holding your specifics was never in scope.

So treat them as two problems. Author skills clean and general, and let the standard carry them. Keep the accumulated record — decisions, conventions, reasons — in a store your agents read and you can edit, so it outlives the harness you happen to be using. The capability layer just got portable. Making the knowledge layer portable is still your call, and it's the half that took you six months to build.