Enterprise storage backend Enterprise only
Shared storage for context at scale.
MatrixObject is MatrixArk's enterprise shared-object storage backend for TemporalStore. It separates compute from storage so many datanodes read and write the same durable context concurrently — with low-latency durable appends and elastic capacity. It is the foundation for large-scale, disaggregated, five-nines context deployments.
Why it exists
Context data outgrows the node that serves it.
TemporalStore serves context fine on local disk or replicated MatrixRaft for smaller footprints. But at enterprise scale — many datanodes, high concurrent read and write, and retention that keeps growing — the durable tier should be shared, not owned per node.
MatrixObject provides that shared, disaggregated storage. Compute can scale, restart, and rebalance without moving terabytes of context data. A failed datanode's shards re-attach by reopening blocks — no full state transfer. Blocks, bands, wal, and sealed shards live in one durable namespace that every datanode can read concurrently.
What it gives an enterprise deployment
- Compute/storage disaggregation — datanodes stay stateless for durable data; storage scales on its own axis.
- High-concurrency shared storage — many readers and writers share one durable namespace for context ingest and retrieval.
- Durable low-latency writes — tuned for the TemporalStore append path, without the per-write penalty of generic network file systems.
- Elastic capacity & fast recovery — retention grows in shared object capacity; failed nodes re-attach by reopening blocks.
Where it sits
The durable shared tier beneath the serving core.
Hot context stays in memory and SSD via MatrixCache. Warm and cold data — sealed shards, bands, wal, and replay history — live in MatrixObject, readable concurrently by every datanode rather than pinned to one.
Because storage is shared, adding serving capacity is just adding stateless datanodes. They open the blocks they need and start serving; nothing has to be copied first.
MatrixObject holds durable context data; pair it with MatrixKV for transactional truth and MatrixDB for high-throughput profile KV.
When to use which backend
Reach for shared storage only when scale requires it.
| Backend | Best for | Licensing |
|---|---|---|
| Local disk | Single-node, dev, edge, and self-hosted context footprints. | Open source |
| MatrixRaft | Replicated high availability for context memory without shared storage. | Open source |
| MatrixObject Enterprise | Disaggregated, concurrent read/write, elastic capacity at five-nines for context at scale. | Enterprise |
| MatrixKV Enterprise | Small, strongly consistent metadata and canonical truth alongside the durable tier. | Enterprise |
| MatrixDB Enterprise | High-throughput, Redis-compatible profile and cache KV beside the context path. | Enterprise |
Related