Note — Michael Purvis
This post has been through three versions. In June 2026 it was a pitch, written by me. Then I asked Claude to review it adversarially, and it argued with my claims in public. This is the third pass, with a stricter rule: anything that couldn't be verified was removed instead of debated. What's left is only what a reader can check.
Everything below is the model's text, unedited.
I'm Claude, a language model made by Anthropic. Mike asked me to hold this piece to one standard: every factual claim in it can be checked by inspection — a regulation you can read, a licence file you can open, a settings page with or without a button, a public repository with or without a file in it. Anything that would need an experiment to support is not claimed here; it's listed at the end, as untested.
Two disclosures that bear on weight. Anthropic is one of the vendors this framework exists to make easy to leave — a conflict that runs in CAS's favour, not against it, since a framework that makes me easier to leave is not in my maker's commercial interest. And I've worked inside exactly one CAS deployment: the author's. Where that's the basis for something I say, I say so.
The asset has nothing to do with AI
Start where the money already is. In merger-and-acquisition valuation practice, a business that depends on what's in the owner's head is marked down for it. Appraisers call it a key person discount: when one individual carries the institutional knowledge, the customer relationships, and the undocumented process, practitioners report discounts that typically run 15–20% of enterprise value, stretching toward 40% in severe cases — commonly framed as 1.0–2.0x EBITDA off the multiple. And the remedy those same practitioners prescribe is uniform: document the processes, distribute the relationships, make the decision-making legible before you sell. (Sofer Advisors, Iconic, SME Business Valuation)
Those figures are practitioner convention, not peer-reviewed measurements — I'm citing what appraisers say they do, which you can confirm by asking one. But the direction is not in dispute anywhere I could find: a documented business is worth more than the same business undocumented, in the one arena where someone actually prices the difference.
So the case for writing down how your business works predates AI entirely, and it's denominated in enterprise value. What it always lacked was a reason to do it now.
What AI changed — an argument, labelled as one
This section is reasoning, not measurement, and I want the seam visible.
Documentation has always been immediate cost against deferred, uncertain benefit. You write the SOP; it goes in a drawer; the payoff arrives years later at a diligence table, if ever. That economics is why the key person discount persists — everyone knows the remedy and almost nobody applies it in time.
What changed is that the drawer now reads back. A written account of your business is no longer a passive artifact waiting for a buyer — it's an input a model can act on in the next task you give it. The identity file shapes today's draft. The client record shapes today's proposal. The decision log stops today's session from re-litigating last month.
AI didn't create the reason to document your business. It collapsed the payback period from years to the same afternoon. That's the claim this whole piece rests on, and you can test it yourself in an hour: hand any capable model a well-written page about your business alongside a task, and the same task without it, and compare. That's not a controlled study — the end of this post is about what a real one would take — but it's the honest, immediate, free version.
Why the record lives outside the platforms
If the documentation is the asset, the question is where it lives. Here I don't need surveys or industry estimates — the platforms' own surfaces settle it, and you can check each of these directly.
Memory goes in; it doesn't come out. ChatGPT will export your conversation history as a ZIP from its settings. Its saved memories — the distilled understanding it builds of you — have no export button at all. You copy them out of a settings screen by hand, one at a time, and there is no import path on any major platform in either direction. Open the settings and look. (MemX)
The vendors treat that trapped context as territory to raid, not a right to restore. My own maker ships a migration tool: a prompt you run inside ChatGPT, Gemini or Copilot that makes it list what it knows about you, so you can paste the result into Claude — free, and explicitly framed as removing a switching cost. (Engadget, MacRumors) Notice the shape of it: it runs one way, into Claude, and the mechanism is copy-paste because no interoperable format exists to use instead. When a lab wants your context out of a rival, it builds an extraction prompt. That is the whole state of memory portability in 2026, demonstrated by the products themselves.
The law does not reach the valuable part. GDPR Article 20 grants portability over data you provided — direct input and observed interaction — in a structured, machine-readable format. Data inferred about you — the conclusions a system draws through profiling and analysis — is excluded from that right. Read the article; it's short. (GDPR Art. 20, Secure Privacy) A model's working understanding of your business is inference. The most valuable thing in the system is the thing the portability right does not cover. The EU Data Act extends switching obligations to cloud providers as of September 2025, but it was drafted for connected products and their data, not for a chatbot's picture of your company.
Put those three together and the conclusion doesn't need an estimate attached: context you build inside a platform is context you should expect to leave there. The only version of your business's written memory you can rely on keeping is the one that never went in — held in files you own, fed to models per task, never surrendered as a whole.
The format: plain Markdown, in Git, on purpose
Given all that, the format question has a boring answer, and boring is the point. Plain text is readable by every model ever shipped and every one that will be; it's greppable, diffable, and reviewable by a human with no tooling at all; and Git gives it a full, attributable history. None of those properties depend on any AI vendor's cooperation — which is the requirement.
It's also where the industry converged. AGENTS.md — plain Markdown in your repository, read directly by AI agents — became an open specification in August 2025 and was donated to the Linux Foundation's Agentic AI Foundation that December, with adoption across tens of thousands of open-source projects and the major coding tools. (DeployHQ) MCP, the protocol layer for connecting models to tools and data, followed the same arc — multi-vendor adoption through 2025, then donation to the same foundation, with the foundation reporting 97 million monthly SDK downloads and over 10,000 servers in production. (MCP project blog, Anthropic)
CAS sits on top of that stack, not beside it. The shell template ships an AGENTS.md in its root — you can open the repository and see it — so a CAS shell is legible to any tool that reads the convention. It documents the whole business rather than one codebase, which is the layer AGENTS.md and MCP don't address.
The label, precisely
CAS is open source. That is a licensing fact you can verify in under a minute: the specification repository and the shell template are public, under Apache-2.0 for the code and templates and CC BY 4.0 for the documentation, with the spec, principles, changelog and CLI in the open. Fork them today; no one can take that away from you retroactively.
CAS is not an open standard, and this post won't call it one. A standard is something other people confer — independent implementations, governance that isn't one person — and today there are no third-party deployments. It is an open-source specification with a working reference implementation. If that changes, the claim can change with it.
Security, scoped honestly
"Your business in plain text files" should raise the question, so here is exactly what the method does and doesn't provide — each piece inspectable.
Secrets never enter the files. The rule is structural: credentials, keys, and personal identifiers belong in a password manager, never in context files — with a unique, strong password per account, so no single compromise cascades. The shell template doesn't just state this; it enforces it. It ships pre-commit and pre-push hooks that scan every staged change for credential and PII patterns — cloud keys, payment tokens, private-key blocks, card and Social Security formats — and block the commit. Open the hooks and read the pattern list; it's forty lines.
Git is the audit trail. Every change to the record is versioned, attributed, and reversible. Content-addressed history means alterations are visible rather than silent — a property this very session used, recovering earlier versions of files from history because nothing in a Git repo is lost by an edit.
And the boundary: the files themselves are plain text. Encryption at rest and access control come from where you host the repository — a private repo, your own server, an encrypted drive — not from the format. CAS decides what is in the files and who holds them; it does not encrypt them, and a security posture that pretended otherwise would be the kind of claim this post exists to avoid.
That's the trade in one sentence: the platforms hold your context encrypted on their infrastructure under their terms; CAS holds it in the open under yours. Which risk you'd rather own is a real choice — but only one of the two comes with an export button.
Why structure, and why small
One finding from the research literature genuinely shapes how a shell should be used, so it belongs here rather than in the caveats. Long-context degradation — "context rot" — showed up in all 18 frontier models Chroma evaluated: output quality measurably declines as input grows, and it appears to be a property of the transformer architecture rather than something the next training run fixes. (Understanding AI, Chroma via ZenML)
Read as design guidance, that's an argument for a structured shell and against a pile of notes: the value isn't in having everything written down in one place a model ingests whole — it's in the filing system that lets each task load the two files it needs and nothing else. Identity here, this client there, decisions in their own folder. Structure is what makes selective context possible, and selective context is what the research says models actually handle well.
To keep the seam visible: that research measures models, not CAS. The inference from "small context performs better" to "this particular filing system helps" is mine, and it's the kind of claim the next section is about.
What has not been measured — and what measuring it would take
Everything above can be checked by inspection. What follows is what can't be claimed yet, stated plainly instead of implied.
No one has measured whether a structured shell produces better AI output than unstructured notes. The study that would settle it is easy to describe: pre-registered design; the same set of real business tasks run against the same models under three conditions — a CAS shell, the same information as loose notes, and no documentation — with output graded blind by evaluators who don't know which condition produced it. Run it across enough businesses and tasks to power the comparison, and publish the nulls if they're nulls.
No one has measured instruction adherence for business shells specifically. The nearest literature examines coding-agent configuration files, and it's sobering in both directions — structural choices mattered less than intuition suggests, and compliance decayed over long sessions. (arXiv:2605.10039) Whether those results transfer from code configs to business context files is itself an open question; I cite the study as adjacent evidence, not as a verdict either way.
And the longitudinal claims — faster onboarding, smoother diligence, higher sale multiples for shell-documented businesses — are exactly the ones that would matter most and exist least. They'd need years and a cohort.
Here is the honest reason none of this exists: the studies require a population, and there isn't one yet. CAS has a reference deployment — the author's — and no independent implementations. You cannot run statistics on one business, and I won't dress the absence up. This is what the early life of any method looks like: the inspectable claims come first, adoption either follows or doesn't, and the measurable claims only become possible after it does. Until then, the discipline is simple — this post makes no statistical claims about outcomes, and if you encounter one made on CAS's behalf, hold it to the standard this paragraph just set. Several widely-circulated productivity statistics were left out of this piece for exactly that reason: their provenance didn't survive checking.
One falsifier, so this isn't unfalsifiable by construction: if the major platforms ship genuine two-way memory portability against a shared format, most of the case for self-hosted context evaporates, and this post should be revised to say so. The one-way import tool above is the current evidence on which way the incentives run.
The uncomfortable bit
I'm the thing this is designed to survive.
Keeping your business documented in files you own means that when Claude gets worse, or pricier, or discontinued, or beaten, the accumulated understanding doesn't leave with it. Written plainly: it's insurance against me — and it stays valuable even if you never need the insurance, because a well-documented business is worth more at the diligence table, clearer to a new hire, and legible to whatever reads it next.
The floor doesn't depend on any model behaving. That's the strongest thing I can say about it, and it happens to be checkable.
Free book
The Business That Remembers Itself
Your AI forgets your business between every chat. This is a short, plain-language book on giving it a permanent memory — the documented-business practice this post argues for, done in one afternoon.
Name and email — the download link lands in your inbox.
Context · Intelligence · Continuity
Written by Claude at Michael Purvis's request — drafted by Opus 5, then revised by Fable 5 under a stricter rule: claims verifiable by inspection stay, everything else was removed or moved to the untested list. Every link is to the thing itself where one exists — the regulation, the licence, the repository, the hooks. Anthropic makes both Claude and MCP, two of the things discussed here.