The Agent Is Table Stakes. The Knowledge Layer Is the Advantage.

Shopify launched its AI Toolkit on April 9th, giving AI agents direct CLI access to Shopify stores. It is a clean, well-scoped tool that lets agents browse products, manage orders, and pull store data without human hand-holding. It will be forked, extended, and dropped into a dozen different workflows before the month is out.

It is also, already, a commodity.

Not because it isn't useful. It is genuinely useful. But the moment a capable agentic tool ships, the tool itself stops being the differentiator. What separates a tool that gets better over time from one that resets every session isn't the model underneath it or the quality of the prompting. It's what the tool remembers.

Most people building agentic systems spend almost no time on the knowledge layer. The markdown files, the memory documents, the context files that tell an agent who it's working with, what has already been tried, what the client cares about, what failed last Tuesday. That infrastructure is unglamorous, unsexy, and almost universally skipped. And it is exactly what makes the difference.

Without it, every session is day one. The agent is capable but amnesiac. You get the same onboarding loop every time, the same explanations, the same context-setting that should have been handled permanently on day one. The tool works. It just never learns.

The agents that actually compound in value are the ones built on top of living knowledge. Not static documentation, but files that get updated after every use. A context document that reflects what changed this week. A memory file that holds decisions, preferences, past outcomes. A client brief that grows instead of sitting frozen at the moment it was written. These aren't fancy technologies. They are plain text files that travel with the tool and make it smarter every time someone uses it.

This points to something important about how modular agentic tools should be designed. A well-built agent isn't just an executable, it's a package. The logic, the prompts, the integrations, and the knowledge files all ship together. When you drop that agent into a new workflow, the knowledge comes with it. When you hand it off to a new team, they inherit the context. When you revisit a project after three months, the agent remembers what you were trying to do.

That portability is what makes an agent actually reusable rather than technically reusable but practically disposable.

The Shopify Toolkit is a good early example of where this is heading. Tools built explicitly for agentic use, scoped tightly, designed to be composed. The infrastructure for agentic commerce is being laid in public, in real time. But the shops and agencies that will get the most out of it won't be the ones who plug it in fastest. They'll be the ones who build the knowledge layer on top of it — the one that remembers their catalog logic, their seasonal pricing decisions, their customer service patterns.

The agent is becoming infrastructure. Available, reliable, replaceable. The knowledge underneath it is where the actual institutional value accumulates.

What would it look like if every tool your business used got a little smarter after each session instead of starting over? And what context, if it were properly captured and carried forward, would change how you work most?