Andrew G. Stanton – July 4, 2026
Over the past few weeks I've been thinking less about storing information and more about remembering relationships.
Continuum already stores identities, notes, articles, drafts, profile metadata and media (metadata) locally.
That's useful.
But as the amount of content grows, another question becomes far more interesting.
How are these things connected?
This week that question led to what initially looked like a small enhancement to Continuum's media library.
It turned out to be something much more significant.
More Than a Media Library
Every uploaded image in Continuum can now answer a simple question:
Where is this image used?
If an image appears in a published article, a note, or even my profile metadata, Continuum can tell me.
Instead of manually searching through articles or trying to remember where I embedded a particular image, I simply ask the software.
Clicking Used In expands a list of every matching reference.
Each result links directly back to the original article or note.
What began as a media library is gradually becoming something else.
It's beginning to understand the relationships between the content it manages.
Protecting Published Content
Knowing those relationships immediately makes the software safer.
If an image is referenced by published content, Continuum marks it as in use.
Instead of allowing me to accidentally delete the file, the interface prevents it.
Delete — In Use
A simple feature.
But an important one.
The software isn't simply managing files anymore.
It's protecting the relationships between those files and the content that depends on them.
Local Knowledge
One of the more interesting aspects of this feature is that none of these relationships are part of the Nostr protocol.
Nostr stores the article.
Today, Cloudflare R2 happens to store the image.
Continuum simply learns that the two are connected.
That relationship belongs to me.
It isn't something that needs to be published or something that requires a new NIP
It's simply local knowledge that Continuum builds while managing my own archive.
The storage backend is almost beside the point.
Today it's Cloudflare R2.
Tomorrow it could be Blossom, Amazon S3, a self-hosted object store, or something else entirely.
The relationship remains the same.
Building Relational Memory
Today the relationship is straightforward.
Image
├── Article
├── Note
└── Profile Metadata
The image is no longer just an object sitting in storage.
It has context, history and relationships.
Once those relationships exist, entirely new questions become possible.
- Where is this image used?
- Can I safely delete it?
- Which images have never been used?
- Which article used this header image?
- Which profile still references this avatar?
Those aren't questions about storage.
They're questions about memory.
Beyond Images
Although this week's work focused on images, the underlying idea is much broader.
The same approach could eventually apply to many different kinds of content.
Imagine asking questions like:
- Which articles reference this article?
- Which notes mention this identity?
- Which drafts quote published work?
- Which links appear throughout my archive?
- Which conversations have I participated in?
Each of those is really asking the same question:
What is this connected to?
Once Continuum begins remembering relationships instead of simply storing objects, entirely new ways of exploring your own content become possible.
A Different Kind of Memory
One thing I've noticed while building Continuum is that the most useful features aren't always the biggest ones.
Sometimes they're the ones that quietly remove uncertainty.
I no longer have to wonder whether an image is safe to delete or have to remember which article used a particular header image.
Continuum remembers that for me.
That's a subtle shift.
Instead of simply storing my content, it's beginning to accumulate knowledge about my content.
Not knowledge that belongs on the network or knowledge that needs to be published.
Just knowledge that helps me work more effectively.
That's what I mean by relational memory.
It's not about remembering more.
It's about remembering how everything fits together.