Product >
The OcientAIQ™ Unified Data Platform brings AI directly to petabyte-scale enterprise data so agents, analysts, and applications get trusted answers without moving data across fragmented systems.
Solutions >
OcientAIQ™ Solutions deliver trusted, production-grade agentic AI outcomes described in the language of your industry, built for the scale your operations require.
Company >
Founded in 2016, Ocient delivers trusted agentic AI solutions through OcientAIQ™, for the organizations that can't afford to get AI wrong.
Resources >
Explore in depth resources and perspectives, and learn how to get started with OcientAIQ™.
Published October 5, 2026

CASA: Where your data sits matters more than ever in the age of AI agents

By Ocient Staff

Most of our cybersecurity blog series has been about what becomes possible once an organization can retain everything, index it well, and query it interactively at scale. This post is about the part of the platform that makes all of that physically possible in the first place: where the data actually sits relative to the processor that has to read it. 

At Ocient, several capabilities, including TimeKey Indexing® and Zero Copy Reliability™, help make this possible. But Compute Adjacent Storage Architecture™ (CASA) deserves a closer look because it takes a fundamentally different approach from the architecture much of the data industry has spent the past decade building. And that difference is becoming increasingly important as companies rely more heavily on AI agents.

Why does storage architecture matter more now that AI agents are running continuous queries? Because agents change the shape of the workload. A human analyst runs a handful of queries a day; an agent monitoring a network or running an investigation can issue hundreds an hour, many of them against years of full-resolution history. When each of those queries has to pull data across a network from a separate storage tier, that network hop becomes the bottleneck, and the delay compounds with every question the agent asks. Keeping storage physically next to compute removes the hop, which is what lets an agent work at the speed it was built for. 

The industry went the other way, for good reasons 

For most of the 2010s and into this decade, the dominant architectural trend in data platforms has been the opposite of what this post is about: decoupling compute from storage. Separate the two, the thinking goes, and you can scale them independently, buy cheap object storage for the data you rarely touch, and spin compute up and down to match demand rather than paying for it around the clock. IDC’s own market analysis credits this shift with fundamentally redefining enterprise data architecture strategy, moving the central design question from raw query speed toward long-term flexibility (IDC).  

For a large share of enterprise workloads, that trade was and remains the right one. 

It solved a real problem: elastic, low-commitment infrastructure for workloads that do not need to touch most of their data most of the time. The problem is what happens when the workload stops looking like that. 

Why decoupled compute and storage slows down on historical queries

Decoupling compute and storage works as long as a query only needs a small slice of the total dataset , — small enough to fit comfortably in memory or to be fetched over the network without the round trip becoming the bottleneck. Two things are changing that equation at the same time. 

The first is scale. IDC projects that the world will generate 527.5 zettabytes of data annually by 2029 (IDC), and organizations across industries we’ve written about are retaining more of their own data for longer, for exactly the reasons we’ve described elsewhere: dwell time exceeds retention windows, threat intelligence arrives late, baselines need years of history, petabyte-scale use cases keep surfacing new questions. The natural consequence of “retain everything, don’t sample” is that a growing share of queries stop touching a small slice of the data and start touching a large fraction of it, sometimes years of it, in a single pass. 

The second is AI agents. An analyst running a handful of queries a day can tolerate some latency. An agent issuing dozens or hundreds of queries an hour, continuously, as part of an automated threat investigation or security monitoring loop, does not have that tolerance, nor does it know when it’s asking an expensive question.  

Both trends push in the same direction: the “working set” a query has to touch is growing, and the number of times per day something asks a big question is growing too. 

What CASA actually does 

The OcientAIQ™ documentation describes the underlying problem precisely: when a query’s working set (the records that have to be considered, even if most are filtered out) becomes substantially larger than the DRAM available on the nodes doing the computing, systems that store data in a separate remote storage tier are structurally disadvantaged. They hit network bottlenecks moving data toward compute, and they suffer “cache thrashing,” repeatedly evicting and refetching data across the network as different parts of a large query get processed.

CASA is OcientAIQ‘s answer to that specific failure mode. The majority of the data lives on NVMe SSDs physically attached to the local PCIe bus of the same nodes doing the computation, not across a network link to a separate storage service. Independent reporting on the architecture puts a number on what that buys: OcientAIQ‘s design uses four PCIe lanes connecting each CPU core to each NVMe drive. This delivers roughly one-fifteenth the latency of a comparable decoupled compute-and-storage approach.  The practical consequences are clear: with a conventional decoupled warehouse, just checking a petabyte of data out of storage to run a machine learning job against it can take as much as an hour, before any actual computation happens (The New Stack).

Our documentation adds a second layer that most descriptions of “fast storage” leave out: the software path to the drive, not just the physical distance to it. Rather than going through a standard Linux file system and the usual kernel read/write calls, the storage layer talks to the NVMe drives directly over the PCIe protocol from user memory, skipping the system-call and kernel-memory-copy overhead that a conventional approach incurs on every I/O operation. One side effect noted in the documentation: because this path never goes through the standard kernel mechanisms that the Spectre and Meltdown mitigations had to slow down, OcientAIQ‘s storage layer was largely unaffected by the performance cost those mitigations imposed on more conventionally built database engines. 

The efficiency argument, not just the speed argument 

CASA is not only about raw speed. It also changes the economics of reliability at scale. Rather than the common approach of keeping multiple full copies of data for fault tolerance (3x replication being a typical baseline), OcientAIQ‘s storage layer uses a tunable erasure coding scheme applied at a granular level: self-contained storage units called segments, individually addressable down to a 4 KiB block. The arithmetic is straightforward, and it compounds with scale. To store 1 PB and survive two node failures, 3x replication needs 3 PB of raw capacity; OcientAIQ’s erasure coding needs roughly 1.2 PB:

At petabyte scale, the difference is a meaningful fraction of the hardware footprint, and it is one of the reasons total cost of ownership on a properly architected hyperscale platform tends to come in lower than organizations expect. 

Why storage architecture matters more when AI agents run the queries 

Tie this back to where our other writing in this series keeps landing: the right architecture for AI agents pushes the actual data analysis down into the query engine rather than asking the agent to reason over the raw data in its own context window. But that only works if the query engine itself can deliver an answer fast enough that pushing the work down doesn’t just introduce a different bottleneck. CASA is the specific engineering answer to that requirement at the storage layer: it makes it possible for an agent to ask a question against years of full-resolution history and get an answer on a timescale that fits inside an interactive workflow rather than a batch window. Pushing the work down also means no one has to copy petabyte-scale data into an AI tool: the data stays where it is, and only the answer moves. 

That is also, ultimately, the connective tissue between this post and our other writing. The multi-index architecture we’ve described in our detection-focused posts determines which records a query has to touch. The linear, independent scaling of ingest, storage, and compute determines whether the platform can grow to hold the workload at all. CASA determines how fast the system can actually get those records off the drive and into a computation once the query decides it needs them. All three have to hold at once for the capabilities described across our writing (including the multi-petabyte, AI-agent-driven workloads we cover in our post on what petabyte scale unlocks) to be something you can run today rather than something on a future roadmap. 

Side effect: This architecture is what makes on-premises deployment fast 

There’s a consequence of CASA that isn’t really about performance, and it comes up in almost every conversation with a prospective customer regardless: because compute and storage are physically co-located on hardware in a single deployment, rather than split between your infrastructure and a vendor’s remote object store, CASA runs the same way whether that hardware sits in a public cloud region, a private cloud, an organization’s own data center, or a fully air-gapped facility. The architecture doesn’t assume a network hop to somebody else’s storage service, because there isn’t one to assume. 

Often, organizations choose OcientAIQ specifically because it is deployable on infrastructure they already own and control, though the reason changes depending on who’s asking. For an institution operating across borders, it’s a data sovereignty argument: the legal jurisdiction question doesn’t arise in the first place if the data never has to leave infrastructure the institution already operates. For a US-based institution, that jurisdictional question is largely moot when data remains on domestic infrastructure. But the same architecture addresses a different set of concerns: third-party risk, cloud concentration risk, and whether data processed by an external AI provider could be used to train its models. These are the issues more likely to concern the institution’s regulators and risk committee.

OcientAIQ is hardware-agnostic and model-agnostic by design, which means adopting it doesn’t mean re-platforming onto a proprietary cloud or handing an AI vendor a copy of your most sensitive data to make their model better. You get the CASA performance characteristics and full visibility described above wherever you run it. Open architecture and deployment flexibility aren’t a separate feature bolted onto CASA: they’re a direct consequence of building compute and storage to live next to each other in the first place, instead of building around the assumption that “storage” means “someone else’s data center.” 

Ready to see what CASA can do for you? Contact us.