Blog ·
Collapsing 50 Years of Data Architecture
So, he was just at his computer a lot. He didn't sleep very much... He would just keep saying, "How is this possible?" He'd walk into the room, say, "I know this doesn't make any sense to you but these benchmarks are insane." There was a lot of talking about linear algebra.
Here in the jungle of Costa Rica, a few hours north of the Panamanian border, I spend most of my hours building and researching technology.
I have been building software products and backend technologies for over 13 years, working in various roles throughout the technology department. Making software always came easy for me, and I especially enjoyed building holistic and secure systems.
By the time this story starts, I had already been using LLMs to code for well over a year. I had built some machine learning APIs with my own custom architecture, a database privacy proxy system, and LandScope using AI-generated code.
This is the story of how a foray into GPU efficiency led from LLM inference to graph mathematics and a different way of representing and retrieving data. The clues that connected ideas from linear algebra, geophysics, and graph theory; the experiments that became TETRA; and the Data Matrix at the center of it. How the people who showed up helped turn the prototype into a company, what testing has shown us, and where we want to go next.
If vibe-coding could help anyone build SaaS apps, I figured, it could help me research deep tech.
Along the way, I tried to make GPUs more efficient -- only 20% of most GPUs gets used. To improve efficiency, I figured multiple APIs should be able to send their inference needs to the GPU. Too technical -- sorry. What I am trying to say is that I got into working on the internal math parts of GPUs.
I encountered a lot of interesting research. Much of it turned out to be AI-grandiosity, but a few people's research stood out. In particular, I found Lorenzo Moriondo's work on ArrowSpace compelling.
There was just one problem. I did not get it. He kept talking about Laplacian this and Lanczos that.
That was not my style. I did operations and engineering. I understood plenty about algorithmic complexity, but the squiggly lines they use for math? Count me out.
But... Before I got into tech, I worked as a technical writer. We did scientific location and analysis of tiny underground events. These events usually got triggered by oil-and-gas operations.
Anyways, my mentor/boss/teacher for that role, he impacted my career in ways I cannot explain. He taught me so much about science, writing, work, people... so many things. He was also a geophysicist and strong mathematician.
He would talk with me for hours about waves and structures and propagations and partial differential equations (PDEs). I recall getting a bit indignant when he would matter-of-factly tell me I did not have the background to appreciate the mathematics of wave propagation, velocity modeling, etc. I learned the math.
And inside of these LLMs, in the transforms for attention and kernels, something there felt familiar. Relevant.
What the hell was a Laplacian, though?
The Clues.
Back when I got into tech, I followed the grey-bearded old-school geeks outside on their smoking breaks, and I would talk with them.
And I did this again. I Googled what I did not know, and I used LLMs to explain the math to me. When I started looking up Laplacians, I read:
... of course any graph can be represented as a matrix.
I had heard that before, but that had been long before I worked on the LLM transforms and learned about the structural analysis of LLM weights -- see WeightWatcher.ai by Dr. Charles H Martin. Why would LLM weights behave like spun glass?
Aside, again -- this author is unapologetically parenthetical -- where do LLMs hold their data? "Oh, it's latent representation in the tensor space from pattern recognition forming an idealized formula in multidimensional space." I CALL BS. Give me a mechanism.
Then it struck me. Graph-as-matrix. Spun glass. Graph Laplacians. Resonant frequencies, spectral analyses. Wave equations.
LLM weights are a graph. A graph?
Not like a bar chart or anything -- a set of "nodes" (aka entities) and "edges" (aka relationships).
Things-and-how-they-connect.
It turns out, in high-performance compute, this kind of vector math often gets used to simulate fluid dynamics, calculate trajectories... Some databases use vector math libraries to make parts of queries run faster.
But... well... I cannot explain the hubris of the typical software engineer. We see something has been done before and we say, "hold my coffee."
But I'm glad I decided to build my own.
Hold My Coffee.
Having worked on some knowledge graph + LLM projects, and having seen the token savings and improved alignment that come from the right context with the right connections, I made several new connections in the graph data space.
One of them, David Knickerbocker, showed me how he was using graphs to pull incredible, near-realtime results from the internet using LLMs and open source intelligence (OSINT) data sets. His work blew my mind, but also, watching him use a graph database, I thought to myself: this cannot scale.
So I set out to build a new graph database. I profiled everything, applied my SRE years and targeted prompting, and made good progress. Choosing all the best open source systems, I quickly got an algebraic matrix working.
But wait... why was it still slow? It only performed as well as graph databases that use matrix algebra but mostly act like graph databases. Slow to operate and scale, hard to manage concurrency... just... normal.
The parts of the queries that went fast were driven by this matrix algebra. The parts that went slow? No matrix. They had to be pulled from... memory, disk, somewhere.
So... why did we not stay in the matrix? Well, to store information and compare data points with one another, you have to have the data points you're comparing.
But how do LLMs do it? LLMs do it with trained vectors, which are lossy and get derived from many exposures to the same... *yawn.* Hold up... could we make our own vectors? You know, but... not lossy.
Well, yes. Yes, we could. And doing so resulted in something I did not expect at all. Thinking back to it now still astonishes me: the simplicity, the ease, and the complete disregard for the entirety of Computer Science as I understood it.
The path to exact vectors led to a new -- or at least heavily adapted -- type system.
And this is where we break some rules.
Separation of Concerns.
In 1970, a hugely influential paper about how information should be stored and organized swept the computer science world. "A Relational Model of Data for Large Shared Data Banks," by E. Codd, would influence the design of Oracle and Postgres.
Even some strong engineers and technical people may not fully understand or appreciate the process of saving data to a machine and getting it back again.
This fundamental behavior of computers has, believe it or not, largely stayed the same as we moved data across magnetic tape, spinning disk drives, solid state drives, and even memory (RAM).
Data gets stored to a location on the disk, identified by memory addresses. Most systems use the default types from the operating system that do this work. Databases do the same, but they add the ability to look up what you saved with a query language.
Nearly all databases do this per Codd's architecture from over 55 years ago. "Where the data is stored" gets separated from "how the data gets looked up." This meant copying data to index it, making it faster to look up. This meant we had two different systems to maintain: the lookup system and the storage system.
TETRAbase abandoned this perspective. But we had a good reason. When we look at an LLM, where does it keep its data?
In its weights, along with its relationships. In the same file.
So, LLMs broke Codd's rules. I could work with that.
Indices and Information Theory.
In short, I created an end-to-end geometrical database entirely composed of sparse and dense vector and matrix algebra. That's a mouthful. But here's where it gets interesting.
The system converts words and numbers, as well as query expressions and parameters, into vectors and matrix representations. Bitmasks over topology.
Current systems use B-tree indices and hash lookups; sometimes they use linear algebraic matrix "adjacency lists" to hop faster. But they mostly copy data to look it up. Back in the 50s, these limits were explored by some of the greatest computer scientists ever.
John von Neumann, Alan Turing, Claude Shannon -- they determined these must be the bounds of how much information can be stored and retrieved with which mathematical representations.
None of these theories got informed by functional vector mathematics. TETRAbase does.
TETRAbase uses the "shape" of data to look things up, not their "instance." We do not copy data. We relate it.
So now, we end up with a compressed representation of information that we are able to query in place. Queryable compression.
Relationships means graphs. So TETRAbase was born as a graph database, speaking the popular openCypher query language.
Things get weird here. The claims we make push (but don't break) the rules of information theory. This works because of the very math von Neumann himself helped pioneer: matrix lattice and wave forms.
In the intro quote above, my wife provides testimony to my state of self-doubt and disbelief. This sounds fringe. I sound crazy.
But the benchmarks, they kept holding up. Under concurrent load. Unexpected shutdowns. I threw every bit of skepticism and self-doubt I could at this -- all the stress tests I ran as a Site Reliability Engineer (a software engineer who focuses on operations and automation). And it kept working too well to be true.
The New Company.
Around April of 2026, I met George Anadiotis. He offered to advise and help take the graph database to market. He helped write some initial whitepapers and spent many hours consulting with me.
I'm grateful that he saw the opportunity for TETRA early; he would become a very important figure in TETRA's trajectory.
Reid Johnson and I had met several times around the community via shared friend groups. Our board chair, Bonnie Bogle, and I met because our kids were fast friends at a local school.
I had talked about projects and ideas regarding software before, but this time everyone immediately understood that TETRA was different. Reid had recently transitioned out of a leadership role at an early-stage startup, and he wanted to jump back in.
He came over when I presented TETRA at a community AI symposium hosted by Jill Henault.
This symposium included several early-stage startups presenting their demos "shark tank" style. I went last. I shared a slideshow about matrix data, then presented the data system in real time, running on my laptop, against a 10 GB raw data set.
The room went silent. One man said, "My only piece of advice is this. Take down your website and get to work on your Intellectual Property." So we did that.
We took down the site and formed a Public Benefit Corporation in the State of Delaware. We leveraged our network, connected with a law firm, filed our paperwork, and got the provisional patent.
The benchmarks have grown steadily better. We learned that the tech extends beyond databases -- we can make APIs and RPCs more efficient, too. The Data Matrix often operates way more efficiently than current systems, resulting in massive infrastructure savings.
And here we are. Ready to help you. Data made simple.
The Data Matrix.
What separates a Data Matrix from a linear algebraic index (e.g., adjacency list)? The Data Matrix "recurses."
The relationship between two entities can be represented by another Data Matrix. It recurses because the entities within each Data Matrix relate to each other via other Data Matrices.
This means that all data, everything that the engine needs to know, is stored in the same matrix. The performance on queries and the space efficiency are unparalleled. I've been an engineer for most of my adult life, and I've never seen anything like it.
But the foundations go deeper.
Through some lucky posting on LinkedIn, I met Hunter Horne, founder of HorneSci. He has been studying the math behind graphs-and-matrices for most of his life. He's an applied mathematician and computer scientist, and we met as struggling deep-tech entrepreneurs.
We decided to work together: he validated TETRA's architecture, provided accuracy-preserving technology and feedback loops, and we shared misadventures in startup space. Because of all this, TETRA shares Data Matrix attribution with HorneSci.
This Data Matrix, it uses the same math-and-physics that I learned as a scientific writer in geophysics. And it uses the same weights-and-transforms architecture that LLMs exhibit. But what IS it?
This sounds insane, but it's the way the universe learns. I mean nothing mystical by this whatsoever.
It turns out the golden ratio, Phi, emerges from the Fibonacci sequence: the famous sequence of numbers where each number equals the sum of the previous 2 numbers, like 1, 1, 2, 3, 5, 8, 13, 21... x = x[t-1] + x[t-2].
Every state depends not only on the previous state but the one before that. Or, information lays out as efficiently as possible when you do not know what comes next. But you know what came before.
In other words, these relationships come about because of the nature of change and growth; the nature of states depending on past states. Wow, ok, so Fibonacci and... what's this got to do with databases?
Building technology that closely follows laws of nature yields better efficiency.
Data Made Simple.
I write this 7 months after I started the initial "edgeglider" (TETRA) prototypes.
We have secured our initial "Friends and Family" fundraising goals. We are going to the Connected Data London conference shortly after these words get published. We even have a sponsor page!
And we never cost customers more than we save them on infrastructure.
TETRAbase is available via on-your-premises licensing per-instance + graph size. No per-query costs. No resource allocation limits.
As TETRAbase expands and starts to generate revenue for the company, we will build more hosted options for data access. We will build Data Matrix workflows that store, retrieve, process, and transmit data more than 3x faster and more efficiently than the systems that exist today. We will explore new technologies, approaches, and design partnerships.
Infrastructure and data efficiency matter. They matter now more than ever. And yet we allow LLMs to churn out highly inefficient systems that require massive data storage facilities to operate. We invest in building out infrastructure before we optimize or even understand the technology.
TETRA CA PBC exists because I discovered something remarkable. Everything we have built and talked about here works on today's CPU chips. We don't need customers to install or configure advanced machines or hire fleets of engineers.
We took nearly 7 months to discover our tagline, and it's the right one: Data made simple.