Hello, Oxid: where it started
The origin of Oxid-DB: how a frustration with vector embeddings (long lists of numbers that know what's similar, not what anything means) grew into a neurosymbolic database that keeps intuition and logic in one engine.
Where Oxid started
Oxid started with a wall we kept hitting. If you've built anything with vector embeddings, you know it: embeddings feel magical, but underneath they're really just long lists of numbers. They know what's similar, not what anything actually means.
We wanted more than that. More control, more structure, more meaning. We wanted the floats to be more than floats, so we started a small test project to see how far the idea could go.
Roughly six months of near-non-stop Rust later, that test had become something we're genuinely proud of: Oxid-DB.
We wanted the floats to be more than floats.
What we built
Oxid is a neurosymbolic database, and as far as we can tell the first of its kind. It holds two ways of thinking in a single engine: a vector index for intuition (what's similar) and a reasoning layer over an ontology for logic (what's true, what follows, what conflicts). Underneath both sits a JSON document store, so every node holds your actual data: the record itself, not just a pointer to it. Same data, one identity space, no glue service quietly drifting between two stores.
It's built in Rust to do the thing most vector stores quietly avoid: serve datasets larger than the memory they run on. Scaling up shouldn't mean renting a machine big enough to hold every vector in RAM, so we made sure it doesn't have to.
Sensory: the senses
Oxid-DB is the mind, but a mind is only as good as what it can perceive, and the world doesn't arrive neatly structured. It shows up as source code, PDFs, and email. Sensory is the perception layer we built to read that raw material and turn it into ontology-aware, vector-searchable knowledge the database can reason over. We started it because grounding has to begin at ingest: if meaning isn't captured as the data comes in, no amount of reasoning later can recover it.
Surface: the voice
A mind that can't be questioned isn't much use. Surface is the interface we built for how AI agents actually think: natural language in, reasoned answers out, and every step of the reasoning visible rather than hidden behind a black box. It exists because an agent shouldn't have to trust an answer it can't inspect: Surface makes the path from question to grounded result something you can follow and check.
Forge: the agent
Memory, perception, and a voice are three capabilities, but on their own they're still three separate tools. Forge is the harness that binds Oxid-DB, Sensory, and Surface into a single agent: one that remembers, perceives, speaks, and reasons over verified knowledge instead of guessing. We built it because the whole point of the stack is to act as one mind: Sensory perceives, Oxid reasons, Surface speaks, and Forge is what makes them move together.
None of this is all-or-nothing. Oxid-DB stands on its own, and Sensory, Surface, and Forge are entirely optional. Use all of them, some of them, or just the database. We provide the building blocks; you decide which ones to snap together and which to leave in the box.
Oxid is young, and single-node by design. We build in the open and label everything honestly (what's shipped, what's experimental, and what's still just an idea), so you always know exactly what you're standing on.
This is the start
Over the next few weeks we'll introduce Oxid properly: what it is, why we built it, and the problems it solves. It's in closed beta today; if a database that reasons over your data sounds like your kind of problem, you can apply for early access. This is just the beginning.