I’ve been quiet for a while. Not idle — working. Years of background work, mostly invisible, and it’s starting to surface now. First on the agenda, it’s time to introduce the Cognitive Commons Framework to the world.
I’ll say it plain, with all due honest humility: this is the first of several Great Big Ideas That Help The World that I’ve been grinding at for a considerable time.
It’s called the Cognitive Commons Framework. One sentence: Creative Commons, but for AI chat data flow.
It’s Opt-Out October — the month for deleting data, revoking permissions, leaving the thing. Everybody’s doing it by hand, one app at a time. This is the version that sticks: state your terms once, carry them everywhere, instead of begging thirty companies thirty times.
Right now when you use cloud AI of any kind, you get exactly one privacy choice, which is no choice at all: accept the terms, or don’t use the product. The terms are legalese nobody reads. The defaults are extractive. Enforcement is automated and often unappealable. And “delete” rarely means delete.
Meanwhile the systems invite you to talk about your life (and they’re designed to; the more information is available about you the more readily and effectively advertising can be targeted to you) and the boundary reveals itself mid-conversation, after the telling is already in the log. Chat interactions are becoming ad-targeting input industry-wide, often with no meaningful opt-out. Courts have ordered providers to preserve and produce chats that users thought they’d deleted, or never knew were being logged in the first place because if they were notified it was five feet deep in the middle of a Terms of Service agreement that everybody agrees to and nobody reads, which is also by design.
The systems are accumulating a working model of your life while the consent machinery is stuck in the chat-log era. Privacy is becoming geography, not principle: Meta carved out the EU, the UK, and South Korea from feeding AI chats into ads, plus excluding sensitive topics from ad targeting, which is the whole story in one headline. Your rights depend on your coordinates.
And none of this is in any way controlled or standardized or human-readable or avoidable, in most cases, if you want to use any kind of cloud-hosted AI.
So I wrote the thing I wish already existed: a framework for managing user privacy that is easy to understand, outrageously cheap to implement, and provides massive value-add for both server and consumer, all at zero-free-as-in-beer-cost.
Here’s what it actually is.
Five handling tiers, license-style labels, assigned per content class. UF — Use Freely. SO — Service Only: improve the service, keep it out of advertising. CO — Conversation-Scoped: help me right now, then forget it; the data grant expires at the conversation’s edge. NK — No Keep: transient processing only, seen to route, not retained, with an auditable discard path. NT — No Transmission: never leaves the device, local inference only. You assign them per class — identifiers, medical at three sensitivity levels, financials, personal conversation — and at every scope: conversation, domain, project, task, standing profile. Conflicts always resolve to the most private position. Default-deny, like a firewall.
A wire protocol where the privacy flags travel ahead of the content. The receiver checks the flag before reading the payload — sealed envelope, marking on the outside. On a flag it can’t honor, parsing halts: no buffering the remainder, no logging the partial, no peeking to classify. The payload goes back to the sender, and the audit log records the event without the content — the absence of content in the log is the proof of non-reading. Two-sided handshake, TLS-style, fails closed, with HTTP-style status codes so the audit log reads in entries like “202 raised, user chose hold.”
A portable profile you set up once and carry across providers. New platform, same you — it just asks “still this one?” User-held, in boring standard formats, never provider-held, because a provider-held “portable” profile is lock-in with an export button. You hold the profile; they check it on contact. Ambiguity always resolves to most-private, which makes post-setup laziness safe by construction.
The honest bits, because a spec without them is a sales pitch: NK doesn’t claim “we never saw it” — it claims “seen to route, not retained,” because the first is a lie and the second is checkable. No export proves the negative; the audit gives you proof of accounting, not proof of non-use. And the standard is descriptive, not normative — it enables your conscience, it never replaces it. The enforcement-vs-friction line holds: the system can hold the mirror and ledger the evidence, but the moral verdict stays with the human.
What this is and isn’t: it’s a spec, not a product. Whitepaper v1 is done — claims cited or softened, every citation live-verified — plus seven CCRFCs in RFC 2119 normative language with implementation notes I marked myself. It’s released under the Apache License 2.0. I don’t want to own this. I want it to become load-bearing: the standard is voluntary and descriptive by design, built to become mandatory by acclimation: so ubiquitous, so easy, so necessary that non-participation simply doesn’t make sense.
(As a side note, this pattern is intended to be implemented throughout the AI ecosystem by providers, users, app authors, etc. It will end up inside DeepGravity — the software platform, the OS assembly, the appliance, the idea. The framework comes first on purpose: antidote before product. And the forceful WIP disclosure, because you deserve it straight: DeepGravity is real, it’s in motion, it’s unfinished and the CCF is not “DeepGravity” nor in any way dependent on it. CCF is just a related idea I had and worked up properly because it’s a good idea that deserves the working, and now the specifications are written, tested, and published. This spec is v1 and public; the platform is roadmap. I’m telling you where it goes so you can see the trajectory, and to dispel confusion as to what DeepGravity is versus what this, the Cognitive Commons Framework, is.)
Where I most want technical eyes is the flag protocol. If flag-before-payload doesn’t survive contact with real implementers, I’d rather hear it now. The implementation notes are marked on the page, not buried. Tear into it — the repos are the venue:
- Framework: https://github.com/JohnHenryUS/ccf
- Reference server: https://github.com/JohnHenryUS/ccf-srs
Read it. Tear into it. Run it on a box under a desk. Fix it. Write your own version. If there’s a critical flaw, notify me via GitHub and I’ll do what I can — but the theme here is drop-it-and-let-it-live, so by all means write your own fix and release it under the same or similar terms. I’m not a software company and I have no interest in becoming one. This privacy problem needs fixing in a way that keeps the user’s privacy and rights first and foremost.
The pie is on the table. Fingers welcome.