Home » claude code

Tag: claude code

Building the Tesseract: What Happens When an Archive Learns to Read Itself? Part 1

Building the Tesseract: What Happens When an Archive Learns to Read Itself? Part 1

6/10/26

Over the past week I’ve been working on something that started as a technical experiment and turned into one of the more interesting investigations I’ve done in years. The original idea was simple enough. I wanted to see what would happen if I gave AI access to my archive and allowed it to analyze twenty years of artwork, writing, teaching, experimentation, and documentation. Not a few selected images. Not a curated portfolio. The archive itself.

At the moment that archive consists of more than 1,000 published blog posts and essays, over 9,000 images in my WordPress media library, and work spanning roughly 2006 through 2026. What makes this even more interesting is that the public archive only represents part of the story. Sitting outside of WordPress are thousands of additional photographs, drawings, paintings, animations, source files, scans, installation images, videos, and documents spread across hard drives, cloud storage, old computers, and various digital graveyards accumulated over the last twenty-five years. The first version of the project became NET-ART OS, an archive intelligence system designed to ingest, organize, search, and analyze large collections of creative work. Initially I thought I was building a better archive search engine. Something that could identify relationships between artworks, surface forgotten projects, and help me navigate decades of material more efficiently. That alone would have been useful.

One detail that’s important to mention is that none of this happened inside a polished software platform. There was no development team, no research lab, and no enterprise infrastructure behind it. The entire project began on my MacBook Pro after installing Claude Code and pointing it at my own archive.

The workflow itself became part of the experiment.

Throughout the process I moved continuously between ChatGPT 5 and Claude Code. ChatGPT acted as a strategic collaborator, helping frame questions, challenge assumptions, identify blind spots, and suggest new directions. Claude Code operated inside the terminal as a builder, researcher, analyst, and implementation partner. Ideas often originated in one environment and were tested in the other. Discoveries made by Claude were challenged through conversations with ChatGPT. Questions raised by ChatGPT became new experiments executed by Claude. The process became less about using AI tools individually and more about orchestrating a conversation between multiple forms of intelligence.

The archive itself was powered by WordPress. Using the WordPress REST API, thousands of posts, images, metadata records, categories, tags, and media assets were ingested into a local archive intelligence system. Claude Code helped build NET-ART OS, transforming that material into a searchable and analyzable corpus. The system relied on Python, SQLite, embeddings, metadata extraction, clustering, statistical analysis, and archive retrieval pipelines running locally through the terminal. What I find most interesting is how accessible this process actually was. The entire experiment was conducted using a personal archive, a MacBook Pro, Claude Code, ChatGPT, WordPress, Python, and open-source tooling. No custom hardware. No venture funding. No specialized research environment. Just twenty years of accumulated work meeting a generation of tools that did not exist when most of that work was originally created.

What happened next surprised me.

The archive started revealing patterns that I hadn’t consciously recognized myself. Certain themes kept returning. Certain questions seemed to persist regardless of medium. Ideas would appear in one form, disappear for years, and then reappear through an entirely different technology. A drawing from one decade would unexpectedly connect to a GIF from another. A sculpture would echo a blog post written years later. The archive wasn’t behaving like a collection of files. It was behaving more like a system.

Somewhere along the way the project became what Claude and I started calling the Tesseract, borrowing inspiration from Interstellar, one of my favorite films. The idea was less about science fiction and more about navigation. What happens when an archive stops being chronological and becomes relational? What happens when twenty years of work can be explored through recurring questions, visual similarities, conceptual relationships, and unexpected connections rather than folders and dates? As the project evolved we expanded beyond text and began analyzing images. This became the Visual Tesseract. More than a thousand images were embedded and clustered. Visual motifs started appearing across years. Certain color relationships kept resurfacing. Similar compositional structures emerged between works that had never been intentionally linked. Some of the visual findings appeared to support discoveries that were already emerging from the textual analysis. For a brief moment it felt like the archive was beginning to describe itself.

This is also where things became dangerous.

AI is exceptionally good at generating convincing stories, and convincing stories are not the same thing as evidence. Some of the findings felt profound. Others felt suspiciously perfect. At that point the project shifted from discovery to skepticism. Instead of asking what new theories we could build, we started asking how many of our favorite ideas would survive being attacked.

What followed was probably the most valuable part of the entire process.

An adversarial audit was conducted across dozens of project documents. Every major claim was challenged. Contradictions were identified. Definitions were tested. Assumptions were dragged into the open. The project was effectively forced to argue with itself. The audit separated the work into three layers: methodology, theory, and philosophy. That distinction turned out to be critical.

One of the most interesting findings didn’t survive.

For several days we believed that experimentation represented the deepest invariant in the archive. The evidence seemed compelling. The word appeared across all nineteen years of published content. It looked like a throughline running across the entire body of work. Then we built a permutation-based null model and tested it.

The result was immediate and humbling..

The finding collapsed..

What looked like a profound structural truth turned out to be statistically indistinguishable from a common high-frequency word appearing throughout a large corpus. In short, the archive had fooled us. Oddly enough, that failure increased my confidence in the methodology. The system had just disproved one of its own favorite conclusions. That’s exactly what it should do. If every result confirms the theory, you’re no longer doing research. You’re doing mythology.

The more recent tests have been far more interesting. Some findings disappeared under scrutiny while others became stronger. The archive’s accessibility and deafness-related themes emerged as genuine long-term signals. The rise of AI and agent-based systems appeared as a measurable historical event within the archive itself. Even more interesting, thematic structures from earlier periods of the archive demonstrated an ability to predict aspects of later periods better than chance. In other words, some parts of the archive genuinely contain information about where the archive is likely to go next.

At this point I no longer think of NET-ART OS as a search engine, a product, or even an archive project. The best way I can describe it is as an instrument. A telescope pointed inward. Something capable of revealing structures that are difficult to perceive manually across decades of creative work.

There is still a tremendous amount left to do. The Visual Tesseract is only partially built. The larger unpublished archive remains largely untouched. The spatial computing, XR, VR, and mixed reality components exist mostly as ideas and prototypes. The methodology itself has only been tested against a small number of archives. There are more questions than answers. What surprised me most about this process is that the most valuable moments weren’t the ones where the system confirmed something I already believed. The most valuable moments were the ones where it contradicted me, challenged assumptions, or revealed relationships I had never noticed. Those moments are rare. They are also the reason I’m continuing.

The work already existed. The archive already existed. The questions already existed. What changed was the arrival of systems capable of reading that archive at scale. In many ways, the archive was simply waiting for the technology to catch up.

For now, I’m taking a short break from building and documenting what happened. The archive is still there. The questions are still there. The Tesseract is still there. The experiment continues.

Want more?

Relevant posts and follow ups:

Building a Semantic AI Archive System for a 20-Year WordPress Art Archive

AREMES HQ, Brooklyn, May 25th 2026

Today I spent nearly an entire day inside Terminal on my macOS building an experimental semantic archive intelligence system around my lifelong WordPress media library. This was raw terminal-based systems building in collaboration with my friend Sir Claude Code, running locally through Node.js, Ollama, WordPress REST APIs, vector embeddings, semantic clustering systems, and custom archive intelligence tooling.

The entire process unfolded live through hundreds of terminal operations, syntax checks, vector validations, ingestion passes, embedding pipelines, cluster analysis runs, semantic nearest-neighbor generation, static export systems, and archive intelligence reports.

At multiple points the machine appeared less like a search engine and more like an archaeological system excavating hidden structures from twenty years of accumulated visual output. For the last few years I have been thinking deeply about a strange problem that I feel almost nobody talks about, ever.. What happens when a person has been publishing creative work to the internet continuously for over twenty years? I cant even imagine that this much time has even passed.. but it has indeed.

This was not casually posting, not optimizing for trends, not building for algorithms. Actually publishing. Consciously.

Thousands and thousands of artworks, drawings, animations, experiments, scans, paintings, GIFs, photographs, sculpture, prints, collage, prototypes, motion studies, AR/VR tests, 3D models, abstractions, video art, Internet Art, installations, tutorials and fragments of process spread across WordPress, GIPHY, cloud drives, external hard drives, old websites, Tumblr-era internet culture, and multiple generations of digital platforms.

At a certain point the archives become too large for chronology to mean anything. I’m a WordPress guy. I fell in love with it from the day that I learned about it in 2004. I watched from the sidelines for a year and half and then I jumped in, launching my first site in 2006. I don’t believe that WordPress media libraries back in 2026 were designed to function as intelligent cultural systems. They are essentially giant chronological storage buckets. The deeper the archive becomes, the more invisible the work becomes. Search breaks down. SEO becomes increasingly unreliable. Older work disappears beneath newer uploads. Valuable relationships between works are never surfaced.

An archive eventually becomes unreadable. This became daunting. Im a high volume production kind of artist. Im constantly making new things, everyday. I document those things, everyday. Im also Deaf and Hard of Hearing and I learn almost everything from visually reverse engineering things into some tangible example. But again, the archive became an abstraction, a real problem and I wanted to solve it.

This is not “AI art”, “AI content generation”, or another chatbot.

I wanted to know if an AI system could semantically understand a lifelong creative archive? One with just under 10K worth of artwork images, multidisciplinary images..

And more importantly, can it reorganize the archive into something discoverable again?

That became the foundation of what evolved into the AREMES Archive OS.

The Archive

The test archive was my own WordPress media library from ryanseslow.com

The domain and site has been active for well over seventeen years and currently contains approximately:

  • 9,386 publicly accessible media records
  • 20 years of accumulated visual output
  • paintings
  • drawings / illustration
  • sculpture
  • animated GIFs
  • motion graphics / animation / video art
  • photography
  • 3D models (glb/usdz)
  • PDFs / docs / written suchness
  • visual fragments / Internet art
  • experimental AI works
  • spatial computing tests
  • AR/VR prototypes

The important thing is that the archive was real. This was not a clean startup dataset. This was not a curated museum database.
This was not a demo collection. It was a living archive with all the messiness that real creative production accumulates over decades.. a total mess.

The Goal

The goal was to build a local semantic archive engine capable of:

  • ingesting WordPress media libraries
  • generating embeddings
  • performing semantic search
  • clustering related works
  • identifying nearest neighbors
  • surfacing hidden relationships
  • generating archive intelligence reports
  • eventually powering licensing, discovery, and curatorial systems

Importantly, I wanted the system to remain:

  • read-only
  • local-first
  • resumable
  • portable
  • inexpensive
  • API-driven
  • WordPress-native
  • deployable without complex infrastructure

No giant cloud stack. No venture-funded infrastructure (though that would be so nice!) No dependency-heavy AI startup architecture. Just intelligent archival systems built directly on top of existing cultural output.

The Tech Stack

The system was built primarily as a Node.js CLI application.

Core stack:

  • Node.js
  • vanilla JavaScript
  • local JSON pipelines
  • WordPress REST API
  • Ollama
  • nomic-embed-text embeddings
  • cosine similarity vector search
  • static HTML/CSS/JS export architecture
  • Terminal / MacOS
  • Claude Code
  • Chat-gpt

The entire system intentionally avoided:

  • databases
  • vector databases
  • cloud GPU infrastructure
  • SaaS dependencies
  • server-side runtime requirements

Everything operated through local flat-file architecture.

The archive lived primarily inside JSON artifacts:

  • media_archive.json
  • media_embedding_corpus.jsonl
  • media_embeddings.jsonl
  • clusters.json
  • nearest_neighbors.json
  • archive_intelligence.json

The entire system was effectively building a semantic operating layer over a WordPress archive.

The First Breakthrough: Semantic Search Actually Worked

The first major validation happened during vector testing. A semantic query was run against embedded works:

“dimensional graffiti sculpture entity”

The lexical search results were terrible. Only literal keyword matches appeared. But once vector similarity was enabled using real nomic embeddings through Ollama, the system began surfacing semantically related works that shared no direct keyword overlap.

It pulled:

  • bronze/graffiti hybrid forms
  • volumetric character sculptures
  • 3D spatial abstractions
  • hybrid graffiti entities
  • sculptural motion studies

That was the moment the project became real. Excited! (I was already hours in!)

The archive was no longer searching by words. It was searching by meaning.

Embedding the Archive

The next stage involved embedding the archive itself.

The system successfully:

  • paginated through 97 WordPress API pages
  • ingested 9,386 media records
  • regenerated archive corpus files
  • preserved existing embeddings safely
  • resumed embeddings incrementally
  • validated semantic relationships

Initial semantic coverage:

  • 500 embedded works
  • 679 validated vectors across both ryanseslow + aremes
  • 75 semantic clusters
  • 3 large semantic “worlds”
  • multiple emergent series and collections

The system identified:

  • recurring visual motifs
  • medium transitions
  • temporal shifts
  • outlier works
  • semantic neighborhoods
  • 2D → 3D transformation relationships

One particularly fascinating discovery was how often photography re-emerged across decades despite enormous stylistic variation.

The archive was beginning to reveal patterns that were difficult to recognize chronologically.

The Clustering Experiments

One of the strongest moments of the process was the semantic clustering layer. Instead of manually tagging works, the system grouped works through vector proximity and centroid similarity.

Clusters began emerging naturally:

  • sculptural portrait systems
  • 3D spatial hybrids
  • animation worlds
  • museum/digital abstractions
  • collage systems
  • glitch structures
  • graffiti-derived volumetric forms

Some clusters were extremely coherent. Others collapsed into noise. That became one of the most important realizations of the entire experiment:

Semantic similarity does not automatically equal aesthetic coherence..

AI can recognize relationships. But curation still matters.

The Archive Intelligence Layer

The archive-intelligence mode became one of the most ambitious parts of the build.

The system joined:

  • archive metadata
  • embeddings
  • cluster relationships
  • nearest-neighbor systems
  • temporal analysis
  • semantic series
  • cross-medium relationships

It generated:

  • semantic collections
  • inferred exhibition titles
  • neighboring works
  • outlier detection
  • motif analysis
  • “world” structures
  • licensing potentials
  • spatial potentials

At this stage the system was no longer simply indexing media. It was beginning to behave more like a curatorial intelligence layer.

The Most Important Realization

After several hours of successful backend engineering, an important realization appeared:

A CLI has no buyer. (Funny.. and not funny!)

That sentence completely changed the direction of the project. (I had been slurped in, once again, but I love that!)

The engine worked. The semantic systems worked. The archive intelligence worked. But nobody could see it. Everything still lived in terminal windows and JSON files. The project had become an extremely sophisticated invisible machine.

That forced a much bigger question:

What is the actual public-facing surface?

The Export-Site Experiment

The next phase attempted to solve this problem. A static semantic archive site was generated directly from the JSON outputs.

The idea was powerful:

  • semantic discovery
  • related works
  • cluster navigation
  • curated series
  • licensing CTAs
  • semantic search
  • archive worlds

The system generated:

  • index.html
  • style.css
  • app.js

No backend. No runtime AI. No database. No server dependency (perhaps I try to deploy on wordPress Sandbox?) Just a static semantic archive generated from the intelligence layer. Conceptually, this was exactly the correct direction. Visually, however, the system immediately exposed another difficult truth.

The Failure That Mattered Most

The semantic engine worked. The visual orchestration did not!

The archive surface became visually unstable:

  • mixed image ratios
  • broken previews
  • inconsistent media sizes
  • GIF chaos
  • missing thumbnails
  • 3D objects
  • PDFs
  • wildly different eras colliding together

The result was technically impressive but aesthetically uneven. And honestly, that failure may have been the most important discovery of the entire day. Because it clarified something critical:

AI-generated archive systems still require human taste. Semantic relationships are not enough.

Museum-grade experiences require:

  • pacing
  • hierarchy
  • rhythm
  • restraint
  • spatial composition
  • curatorial intelligence
  • emotional sequencing

This was the exact point where the project shifted from backend engineering to art direction..

The Real Opportunity

The deeper realization is that the semantic engine itself is not the product. The archive IS the product.

The engine becomes:

  • the curator
  • the navigator
  • the merchandiser
  • the discovery layer
  • the licensing assistant
  • the relationship engine

That distinction changes everything.

Because suddenly:

  • older works become discoverable again
  • semantic relationships become visible
  • licensing becomes easier
  • collections emerge automatically
  • AI agents can traverse the archive meaningfully
  • archives stop behaving like dead storage systems

This is especially important for artists, museums, photographers, designers, institutions, universities, and cultural archives with decades of accumulated digital material.

Why This Matters Beyond My Own Archive

Most WordPress media libraries are dormant semantic archives. Millions of people have already unknowingly built enormous cultural datasets. The problem is, those archives are largely unreadable.

This experiment suggests another future:

  • semantic museum systems
  • agent-readable archives
  • intelligent licensing discovery
  • AI-assisted curatorial navigation
  • AR/VR semantic galleries
  • spatial archive interfaces
  • archive intelligence layers on top of existing cultural systems

The important thing is that none of this required rebuilding the internet.

The entire system operated on top of:

  • WordPress
  • JSON
  • local embeddings
  • static exports
  • open APIs

The architecture remained surprisingly lightweight.

What Happens Next

At this point the project has proven:

  • semantic ingestion works
  • embeddings work
  • clustering works
  • archive intelligence works
  • export systems work

What remains unresolved is -> visual orchestration..

That is now the real frontier. Not “more AI.” Not larger models. Not more embeddings.

The challenge now is: how to transform semantic intelligence into elegant cultural interfaces. Yes, aesthetics, we like pretty things to look at..

That is a design problem as much as a technical one. Im up for it!

 

Final Thoughts

This entire experiment started with a simple question:

Can an AI system understand a lifelong archive?

The answer appears to be: yes, partially. But another question emerged underneath it: Can intelligence alone create meaning?

The answer to that is much more complicated…

Semantic systems can identify relationships. They can surface hidden structures. They can organize massive archives. They can discover patterns humans overlook. But they still cannot replace curatorial sensitivity, restraint, pacing, and aesthetic judgment.. right? Yet? Hmm..

The machine can understand proximity.. The human still understands significance..

And maybe that balance is still the actual future, I don’t know, but Im excited to find out, and continue to tinker. I don’t want AI replacing archives, but I do want AI making archives visible again.

Forward we go! Onto to part 2!
Thoughts?