Thesis: A knowledge graph can provide durable context across model calls, so control of that persistent memory is central to a user-owned digital self.
The post argues that shared graph context can persist across model calls, draws an analogy with reconstructed human memory, and raises the custody question posed by personal agents. It recommends local custody, open standards, and user ownership. This is an analytical summary; the original post is available through the source link. These are the author’s claims and proposals; the collection does not independently verify product launch details or the neuroscience analogy.
Argument sequence
Model choice is less salient than shared context — The author says changing models makes little difference when each receives the same graph-based context.
Persistence supports continuity — The graph is presented as the durable component while model calls begin from a blank state.
Human memory offers an analogy — The post invokes memory reconstruction to describe how a self may be reconstituted.
Personal agents introduce custody stakes — The post contrasts a private inner life with memory held on corporate compute.
Ownership is the proposed principle — The author urges local custody, open standards, and user ownership.
Visible post counter: 126 reactions. The captured view did not expose a verifiable total comment count.
Comments thread
Selected snapshot, not a complete export. The two comments by Kingsley Uyi Idehen are listed first, followed by sampled visible comments in the captured “Most recent” ordering. Positions refer only to this collection. Reply relationships were not inferred where the interface did not establish them.
There’s something fundamental and irreplaceable about being you—and your identity must remain under your control. Identity has always been at the root of what has failed on the Internet and the Web.
Third parties, through applications, apps, and now agents, are building fragmented versions of “you.” These are inherently suboptimal and create privacy risks.
The antidote? Establish cryptographically verifiable identities for yourself and your agents. Then build profile graphs and apply fine-grained, attribute-based access controls (ABAC—not RBAC) to govern access.
The good news? The Semantic Web project has long addressed this challenge through WebID, WebID-TLS, and related technologies. Before the AI agent era, the main hurdle was the GUI: poor implementations of TLS and associated browser interfaces, rooted in the Netscape era. Today, the browser is no longer the gatekeeper to the Web experience; the AI agent is. Agents don’t face the same UI/UX hurdles with WebID and WebID-TLS. This approach to decentralized PKI (DPKI) can be enabled simply by adding WebIDs (hyperlinks that denote you) to the Subject Alternative Name (SAN) fields of X.509 certificates.
In the agent-rdf-memory harness we've published to Github —which works with AI environments that support [AGENT.md] configuration and [SKILLS.md] skill bundling—this works like a charm. Links: [1] https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/agent-rdf-memory -- agent rdf-based harness [2] https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/youid -- YouID skill for generating identity for yourself or agents operating on your behalf [3] https://linkeddata.uriburner.com/weblog/?post=food-bookmark-webid-tls-obo-ogilvy-grok-2.html -- post demonstrating the use user-controlled identities for driving agentic commerce
True - But.. why would you expect to own your reflection? You don't walk through this world and engage with it without leaving a footprint. And a lot of what is in the Digital You reflects and inherits and is inspired by people.. many of whom you are completely unaware of. Where does the line stop? Personal Creativity, just like Culture is participation in a process. We are largely unaware of all that we owe to each other. I'm not saying that the topic is not an important one, but I like to think also about that dynamic, that flow "Ubuntu" is the ancient word for it - meaning literally "I am because We are". (..and yes, there's an ironic reason that this ancient longstanding concept resurfaces in the years of the internet and AI as the name of a modern Operating System. In a way it always was an "operating system")
It has been a fascinating experiment building my digital twin. I find switching models and tools to be remarkably similar with the one caveat - training the models is a curve with each one needing corrections to properly interpret and portray the context. Just a few weeks and they are able to understand and sort through and surface each of their individual agents' responsibilities. This is the beginning of what science fiction trained us to expect from AI. What comes next is up to us.
The idea of memory as messages from a past self maps closely to what I have been working through. Knowledge is not simply stored in the graph. It develops through accumulated traversal: relationships activated, weights changed, and deltas carried into each new context. The same applies to digital selves. The graph provides persistence, while the agent emerges through its evolving engagement with it. In the enterprise, these become agentic coworkers operating through the same identity, role, relationship, delegation, and permission rails as human workers. Dots, Muse, and Grok’s companions may preview a pattern enterprises will implement within governed environments. That may limit the hyperscalers’ durable advantage. Enterprises already control the identities, permissions, workflows, infrastructure, and proprietary context that make these agents valuable. As local models improve, the provider may become one component rather than the center of the architecture. Consumers may remain dependent longer because few can operate the infrastructure required to hold their digital selves locally.
“The model is electricity, the memory is you” is the cleanest framing I’ve seen this week. If Levin’s right that memory isn’t stored where we think, corporate-owned agent memory gets philosophically weird fast — whose continuity is it?
This is good. I keep telling people it literally doesn’t matter which model you pick. Context is what gives it superpowers. I hook up a knowledge graph to my agent and suddenly performance is miles better.
References in Kingsley Uyi Idehen’s second comment
HowTo: Create verifiable identities and OBO delegation
This LOAC-oriented walkthrough expands the identity and access-control direction in your first comment. It uses separate WebID-TLS identities for a person and agent, records delegation in their profiles, and distinguishes identity evidence from the resource’s authorization decision. It is a practical pattern, not a claim that profile triples alone grant access. The session-start whoami example makes the principal (you) distinct from the agent (me).
Give the human principal a stable WebID profile and an X.509 client certificate whose Subject Alternative Name contains that exact WebID URI. Keep the private key under the person’s control; publish the matching public key in the profile.
Give the acting agent its own WebID profile and certificate. Do not share the person’s private key or make the agent authenticate as the person: the two identities must remain distinguishable.
Dereference both profiles and verify that each certificate’s SAN names its WebID, the certificate is valid, and the profile’s cert:key modulus and exponent match the certificate public key. Check this independently for the person and the agent.
In the person’s profile, assert oplcert:hasIdentityDelegate . In the agent’s profile, assert oplcert:onBehalfOf . Keep each assertion in that identity’s profile documents; these RDF statements describe the intended delegation relationship.
For the WebID-TLS OBO pattern used by LOAC, also publish the agent’s matching cert:key (RSA modulus and exponent) under the person’s profile. Keep the key and delegation statements consistent across Turtle, JSON-LD, RDFa, and HTML profile representations. The relation triples alone do not make a TLS verifier accept the delegated key.
State what the agent may do, for which resources, and under what conditions. Treat the profile links as identity and delegation evidence; the resource’s authorization policy must still decide whether the person’s entitlement covers the requested action. OBO does not itself grant wallet, spending, or general authority.
The agent authenticates with its own certificate and sends an On-Behalf-Of HTTP header whose value is the person’s bare WebID URI, without angle brackets. The resource can then evaluate the authenticated agent, the named person, the verified delegation, and its own access policy together.
Verify profile links and public-key consistency, then test an allowed request and negative cases such as an unknown principal, mismatched delegate, or missing principal entitlement. A successful identity/delegation check is not by itself proof that the resource authorized the action.
Frequently asked questions
What is the post’s central claim?
The author argues that persistent context, represented as a knowledge graph, matters more to continuity across model calls than the choice of model.
What does the electricity metaphor mean?
It frames the model as the changing execution medium and the graph as the persistent context.
What persists in the author’s account?
A knowledge graph is proposed as the durable network of context for a digital self.
How does the post compare human memory with model memory?
It draws an analogy between reconstructing a sense of self through memory and a model call that reads stored context.
What does the post attribute to Michael Levin?
It reports his view that memories are reinterpreted messages from a past self rather than fixed recordings.
What is the open question about a digital self?
Who holds and controls the persistent graph that represents it.
What concern does the post raise about personal agents?
Their memory may reside on corporate infrastructure, giving providers access to personal context.
What does “the agent is personal, but it is not yours” summarize?
A personalized interface does not by itself give the user ownership or custody of its memory.
What does the author recommend?
Keep persistent memory local, use open standards, and retain ownership.
What does the post mean by “ontology is alignment”?
It previews a thesis series; the post does not fully define or prove the relationship.
What does the first user comment add?
It proposes user-controlled verifiable identities, profile graphs, and fine-grained ABAC for people and agents.
What identity technologies does that comment name?
WebID, WebID-TLS, decentralized PKI, and X.509 Subject Alternative Name fields.
What concern does Paul McLeod raise?
He questions individual ownership of a digital reflection and emphasizes shared cultural and social influences.
What perspective does Morgan Templar add?
A digital twin may need model-specific correction to interpret its context and responsibilities.
What does Phil Olsen add?
He describes graph knowledge as developing through traversal and considers enterprise identity and permission rails.
What does the comment sample represent?
A selected, visible snapshot of the discussion, not a complete export or a count of all comments.
Core technical glossary
Knowledge graph — A network of entities and relationships represented as data.
Open standards — Published, interoperable technical specifications.
Memory custody — Who controls where persistent personal context is held.
Knowledge graph explorer
Explore the post, comments, argument, references, FAQ, and glossary as linked RDF entities. Drag nodes to pin them in place; double-click a pinned node to release it. Scroll or pinch to zoom; select a node to open its linked-data description.
Post and collectionPeopleCommentsArgument, references, and HowToFAQ, questions, and answersGlossary and termsLines are RDF relationships
Graph data and limits
The graph is built from named RDF entities and selected relationships in the companion Turtle. Literal values remain available in the RDF, but are omitted as graph nodes to keep this view readable.
SPARQL workbench
Open a query against the RDF collection
Query endpoint: URIBurner SPARQL endpoint (the query link is constructed when opened; endpoint availability is not asserted).