AI's next bottleneck may not be the model. It may be the information architecture feeding it.
Models are improving at extraordinary speed. They can reason across language, images, audio, code and tools. Yet before a model produces its first token, another system has already decided what reality it is allowed to see.
That system finds a document, looks up a row, follows an edge, searches an embedding, checks a timestamp and applies a permission. It then compresses those results into a context window and asks the model to reason over the residue.
We have invested heavily in intelligence while leaving the information layer underneath it largely unchanged.
The result is a structural mismatch. AI is multimodal, relational and temporal. It must reason over evidence with history, uncertainty, provenance and policy. Most data infrastructure still breaks that evidence into model-specific copies: a record here, a document there, an embedding in another system, a graph edge somewhere else and an authorization rule wrapped around each service.
The model never sees the information itself. It sees whatever survived the translations.
Some of the hardest failures attributed to AI begin here—before inference—with stale projections, conflicting identifiers, missing lineage, flattened relationships and policy that did not travel with the data.
8DB is built around a different premise: the same information should remain the same information everywhere it is computed. A row, a vector, a graph relationship, a time series, a media object and an AI citation should be projections of one protected identity, not independent versions of truth.
That is a database idea. It is also a claim about what the next era of computing will require.
The model can only reason over what the substrate can express
Every computational system has a representational ceiling.
If the substrate can express rows, software becomes excellent at transactions. If it can express graphs, it becomes excellent at traversing relationships. If it can express vectors, it becomes excellent at finding statistical similarity. Each representation makes some questions natural and others expensive, indirect or impossible.
This specialization has been enormously productive. The database community rejected the idea that one physical engine should dominate every workload long ago; the argument is captured in the influential paper “One Size Fits All”: An Idea Whose Time Has Come and Gone. Polystore research such as BigDAWG subsequently explored how applications could use multiple specialist engines together.
But AI changes the unit of work.
An intelligent application rarely needs only similarity, only transactions or only graph traversal. It may need to find semantically related material, restrict it to a person or project, establish what was known at a particular time, distinguish observation from inference, verify who produced it, exclude revoked information and return the smallest authorized body of evidence—all in one operation.
That is not a vector query with metadata attached. It is a cross-modal information problem.
Today's AI stack manufactures context
Consider a single photo on a phone.
The image bytes may live in object storage. Capture metadata lands in a database. Detected text and faces enter search indexes. An embedding goes into a vector index. People, places and events become graph relationships. Edit history, synchronization, backup, permission and deletion state create still more records.
By the time an AI assistant asks, “What was the name of the restaurant where I met Sam after the conference?”, one experience may depend on half a dozen representations of the same underlying event.
The application now has to manufacture context by reconciling them:
- Does the face identity refer to the same person as the contact record?
- Did the embedding come from the current image or a previous edit?
- Is the location inferred, observed or user-entered?
- Has the message that named the restaurant been deleted?
- May this model see the photo, the derived text, both or neither?
- Can the answer point back to the evidence that produced it?
Retrieval-augmented generation improves a model by giving it relevant material. But relevance is only one dimension of usable evidence. An answer may also depend on whether information is current, attributable, permitted, causally connected and sufficiently reliable.
When those qualities live in separate metadata systems, every retrieval pipeline must reconstruct them. When a fact is copied into a new representation, the system must preserve them again.
The hidden tax is not just infrastructure cost. It is loss of meaning.
Move truth below modality
8DB moves the canonical unit of information beneath the data model.
At the center is a typed, identity-bearing atom. It can carry or reference content, participate in relationships and retain the properties that determine how the information may be trusted and used:
canonical information atom
├── stable identity and type
├── content or payload reference
├── provenance and confidence
├── policy and cryptographic authority
├── time, causality and lifecycle state
└── computational projections
├── relational and document
├── graph and higher-order topology
├── vector and text
├── temporal and spatial
└── media and binary objects
The atom is not forced to behave like a row, a vector or a graph node. Those are ways of seeing and computing over it.
A vector projection can use a vector-native index. A graph projection can preserve adjacency and higher-order relations. A temporal projection can optimize time windows. The physical structures remain specialized; the information does not acquire a new identity every time the application needs a new way to understand it.
This is the heart of 8DB's model-independent architecture: modality becomes a projection, not an ownership boundary.
That distinction matters because a multi-model API can unify developer access while leaving several representations underneath. A data lake can colocate files while leaving their semantics to external catalogs and pipelines. A vector database can make similarity searchable while treating the source, relationships and authority as metadata. A knowledge graph can connect entities while the media, transactions and policy remain elsewhere.
8DB is designed to preserve identity, topology and trust at the substrate itself.
A substrate is not a universal data structure
The strongest objection is also the easiest to resolve: graph traversal, nearest-neighbour search, media streaming and transactional updates have different physical requirements. No single layout should pretend otherwise.
8DB's proposition is not that one generic algorithm defeats every specialist. It is that specialists should operate as projections of a shared information substrate instead of becoming separate sources of truth.
The difference can be stated simply:
| Architecture | What it unifies | What can still fragment |
|---|---|---|
| Specialist stack | Best-in-class execution for each workload | Identity, policy, provenance, lifecycle and recovery across systems |
| Multi-model database | APIs, queries and often transactions | The deeper semantics of information as it changes representation |
| Vector-first AI stack | Similarity retrieval and model context | Source authority, causality, uncertainty and non-vector structure |
| 8DB substrate | Canonical identity and trust across projections | Specialized execution remains free to evolve underneath each view |
This reframes the benchmark. Peak performance inside one kernel still matters. So does the complete cost of producing, synchronizing, authorizing, recovering and deleting all the representations an application needs.
The relevant question is not, “Can one engine beat every database?” It is, “How much machinery disappears when every specialized view still refers to the same protected fact?”
What changes when identity survives every projection
The architectural payoff is larger than reducing service count.
AI context becomes queryable evidence. A retrieval can combine similarity with time, relationships, provenance, confidence and policy before information enters a prompt. The system can return not only a plausible passage, but the source identity and authority behind it.
A new modality no longer creates a new truth. Adding a spatial, biometric, causal or future computational view expands what the system can ask without requiring another canonical copy of the underlying information.
Policy follows the information. Authorization, privacy state and deletion do not have to be independently recreated around every derived representation. A projection inherits the governance boundary of the identity that produced it.
Corrections propagate conceptually. When an observation is superseded, confidence changes or a source is revoked, the lifecycle event attaches to the same identity used across the other views.
Reasoning can preserve structure. Instead of flattening every relationship into text chunks or pairwise edges, a system can retain causal order, multi-party relationships, competing claims and typed absence as information the query engine may use.
This last point is especially important. Today's AI pipelines are good at finding what resembles a question. The next generation must also know what evidence can support an answer, what contradicts it, what is unknown and what the system is not permitted to infer.
An Apple device is the sharpest proving ground
A personal device turns architectural overhead into a visible product constraint.
Another copy or index on a server is often an operating expense. On a phone, tablet or watch, it competes with the foreground experience for memory, CPU time, storage writes, thermal headroom and background execution.
Local AI intensifies the pressure because a model needs durable context, not just model weights. Apple's Foundation Models framework gives applications access to on-device language intelligence and tool calling. Apple's guidance on managing the on-device model's context window makes clear that context remains a finite resource. Private Cloud Compute is designed to process requests that need larger models without turning the cloud into a permanent store of personal data.
That leaves an essential job on the device: maintain the user's durable, governed information; decide what evidence a task is allowed to use; and assemble only the context the model needs.
A protected multimodal substrate could give that job one coherent home. The device would not need to forget that a photo, detected text, person relationship, timestamp, embedding, permission and AI citation are views of the same event.
Apple is a compelling example, not the boundary of the idea. The same architecture matters wherever intelligence must operate over sensitive, distributed or intermittently connected information: vehicles, robots, industrial systems, scientific instruments, health platforms and sovereign infrastructure.
Signals from the running implementation
8DB is not only an architectural sketch. The current Rust implementation includes a typed-atom store, canonical encoding, provenance, protected search, durable write paths, temporal and causal indexing, graph and other modality primitives, and device-oriented experiments.
Several measured component results show why the substrate approach is worth pursuing:
| Signal | Measured result | Architectural implication |
|---|---|---|
| Cost of composing protected operations | On an iPhone 15 Pro Max, one warm native path measured 596 ns, while separately measured storage, encryption, integrity, audit and confidence components summed to 3,969 ns. | Preserving one invariant below several layers can remove real coordination work even before service and network boundaries are counted. |
| Bounded media working set | A bounded-window path used 30.47 MB peak resident memory on a 1.68 GB iPhone ProRes file, versus 684.33 MB for warm mmap: 22.5× lower peak RSS. | The substrate can choose a memory-bounded execution path when local models and foreground work need the headroom. |
| Scoped recovery | Protected state containing 50,000 items reopened in approximately 0.098 ms, versus 110.6 ms of measured WAL replay in the comparison path. | Recovery can be organized around affected state rather than replaying an entire history. |
| Protected retrieval | A sealed index opened and searched 2,000 records in 19.0 ms, versus 36.4 ms for decrypt-and-scan. | Search can remain attached to the protected representation instead of requiring a separate plaintext side index. |
| Durable concurrency | An eight-writer grouped durable path sustained 348 commits/s, versus 192 commits/s for the measured WAL comparison. | Carrying richer invariants does not inherently rule out useful concurrent durability. |
| On-device protected media | A sealed, content-addressed path stored 64 unique 1 MiB blobs at 175.3 MB/s on an iPhone 15 Pro Max. | Protection and canonical identity can remain inside a capture-class data path. |
These signals do not all describe the same workload, and they should not be multiplied into a synthetic system-wide claim. Their value is directional: they show working mechanisms for identity-preserving composition, bounded memory, protected retrieval, recovery and durable concurrency on the path toward a complete application benchmark.
The difference is not feature count
Rows, graphs, vectors, encryption, provenance and policy all exist elsewhere. Several products combine many of them. The interesting claim is not that 8DB invented each ingredient.
The differentiation is their composition around one canonical identity.
If provenance is only a field, an application may omit it. If policy exists only at the API, a copied representation may escape it. If confidence lives in a model-specific sidecar, a query may not use it. If vectors have a separate identity from their sources, an AI answer must trust application code to reconnect them correctly.
In 8DB, these are intended to be substrate invariants: created with the information, preserved through projection and synchronization, available to queries, enforced below the application boundary and recoverable with the data.
That creates a new design objective for AI infrastructure. The database is no longer merely the place where an agent stores memory. It becomes the layer that determines whether memory retains meaning as the agent reasons across it.
Evidence notes
The measurements above are project-run component results, not an independent end-to-end comparison of an entire Apple data stack. They were collected across different workloads and boundaries; each number stands on its own. The bounded-memory media path deliberately traded runtime and measured CPU energy for a much smaller resident set. An earlier modeled battery claim was withdrawn after direct measurement contradicted it; an affected write path was subsequently improved, but its post-fix energy rerun remains outstanding. Mature specialist engines will remain the right answer when one modality dominates or when their operational ecosystems matter more than cross-modal identity.
8DB is built by 8Braid Inc. Apple is not affiliated with this work. This article describes 8DB's architecture and measured components, not Apple's internal implementation or an announced Apple product.
Sources
- “One Size Fits All”: An Idea Whose Time Has Come and Gone
- Version 0.1 of the BigDAWG Polystore System
- Apple Foundation Models framework
- Managing the on-device foundation model's context window
- Private Cloud Compute Security Guide
- Apple Platform Security
The questions this opens
What if an AI system could retrieve evidence without first flattening it into disconnected representations?
What if every generated answer could traverse back through provenance, confidence and policy to the information that supported it?
What if adding a new modality expanded how a system could reason without creating another database, pipeline or source of truth?
What if a personal device could carry a durable, governed understanding of its user's world across models, applications and hardware generations?
And what kinds of software become possible when information can preserve its identity while changing its computational form?
The next era of computing will not be unlocked by larger models alone. It will also require an information layer as expressive, protected and computationally native as the intelligence built above it.
Continue the technical conversation
Bring the workload, boundary and objection.
8Braid can map the article’s claims to an acceptance plan for your security, data and platform teams.
Discuss this work