5.52M observations/sec
Lock-free ingestion captures the live event stream agents need to reason over: telemetry, logs, trades, tool calls, and sensor data.
ZeptoDB
Operational memory for AI agents running on live systems. ZeptoDB captures event streams, recalls evidence in microseconds, reduces repeated model calls, and leaves a replayable trail from signal to decision.
Time-series data becomes agent memory
Section titled “Time-series data becomes agent memory”AI agents fail in production when they cannot see the latest facts, remember what worked last time, or explain why they acted. Most teams patch that gap with a time-series database, a vector store, a prompt cache, and a separate observability stack.
ZeptoDB makes that one operational path. The time-series engine stores the raw operational truth: ticks, sensor readings, traces, incidents, tool calls, robot state, and market events. The Agent Memory layer stores agent-scoped context beside it: memories, embeddings, retrieval filters, token-budgeted context, exact prompt cache hits, semantic cache hits, and AgentOps telemetry.
272μs evidence recall
The time-series core retrieves recent facts and aligned events at microsecond latency before the agent acts.
1.23ms filtered memory search
Agent Memory searches 10K 128-dimensional records with tenant/session filters, ranking, and context assembly for prompt-time recall.
522ns to Python
Query results move into NumPy, Pandas, and PyTorch without serialization, keeping the model loop close to live data.
Benchmark claims are defined by hardware, build, data shape, scope, and measurement protocol. See the benchmark criteria and reproduction notes before comparing or republishing a single number.
Business case for production agents
Section titled “Business case for production agents”Ship agents on live data
Build maintenance, risk, robotics, observability, and grid agents that ask the database for current evidence and durable context in the same turn.
Reduce model spend
Put exact and semantic cache lookup before the provider call. Avoid repeated LLM work on recurring operational questions, alerts, and support workflows.
Shorten investigations
Reconstruct what the agent saw, which memories it retrieved, whether it reused a response, which tool it called, and what happened next.
Consolidate the stack
Replace a fragile chain of TSDB + vector database + cache + log store for operational agents with one timeline and standard SQL.
How live data and agent memory work together
Section titled “How live data and agent memory work together”Observe
Ingest real-time events from exchanges, robots, factories, fleets, grids, applications, or agent tools. The system keeps the ordered timeline intact.
Remember
Store agent memories with tenant, namespace, user, session, agent, type, metadata, importance, TTL, pinned status, and client-supplied embeddings.
Recall
Retrieve by time, scope, semantics, importance, recency, access count, and token budget. Assemble the context an agent needs without dumping the whole past into a prompt.
Act
Reuse exact or semantically similar prompt responses, call a provider on cache miss, write back new memory, and keep AgentOps events in ordinary time-series tables.
What agents can do with both layers
Section titled “What agents can do with both layers”Ask temporal questions
“What changed before the alert?”, “What did the agent do after this signal?”, “Which similar episodes ended badly?” Time-series gives the order; memory gives the learned context.
Ground decisions in evidence
Attach every recommendation to raw events, prior actions, retrieved memories, cache hits, tool calls, and model calls. Debug agent behavior as a replayable timeline.
Avoid repeated model calls
Exact and semantic prompt cache lookup runs before an external provider call. Reuse prior responses when your application policy allows it.
Build vertical agents
Industrial agents, trading agents, fleet agents, observability agents, robotics agents, and support agents can share one substrate for live facts and durable context.
Built for real-time agent workloads
Section titled “Built for real-time agent workloads”AI Agents & AgentOps
Agent-scoped working memory, context retrieval, exact/semantic cache, provider adapters, LangGraph-style examples, and telemetry tables for runs, retrievals, cache events, LLM calls, and tool calls.
Physical AI & Robotics
Sensor fusion and action history become replayable episodes. A robot agent can recall what it saw, what it tried, and which previous intervention worked.
Industrial IoT & Smart Factory
Factory telemetry becomes operational memory. Maintenance agents can combine vibration history, work orders, previous diagnoses, and live alarms.
Autonomous Systems
Fleet logs, scenario mining, and agent decisions stay on one timeline. Reproduce a decision from raw sensor data through retrieved context.
Energy & Utilities
Grid agents can reason over PMU streams, incident memory, operator actions, and historical patterns without losing the timing of the event.
Capital Markets
Trading agents can pair tick-by-tick market state with strategy memory, risk decisions, cache hits, and compliance-ready replay.
Why teams pick ZeptoDB
Section titled “Why teams pick ZeptoDB”- One timeline for facts and decisions. Store raw events in the time-series engine and agent memory records beside the workflows that consume them.
- Fast enough for the agent loop. Microsecond time-series recall, millisecond-scale memory search, exact/semantic prompt cache lookup, and zero-copy Python access.
- A clearer business case. Reduce duplicate provider calls, shorten incident investigations, and give compliance teams a replayable trail instead of a disconnected prompt log.
- Context with operational filters. Tenant, namespace, user, session, agent, type, TTL, importance, pinned status, recency, and access count are first-class retrieval signals.
- Not just a vector database. ZeptoDB does not replace the live operational database with a detached vector index. The memory layer sits beside the event stream that explains why the memory matters.
- Production-shaped surfaces. HTTP endpoints, Python helpers, Prometheus metrics, sidecar snapshots, and examples for provider cache and LangGraph-style flows.
How it compares
Section titled “How it compares”| kdb+ | ClickHouse | InfluxDB | TimescaleDB | ZeptoDB | |
|---|---|---|---|---|---|
| Time-series latency | μs | ~5ms | ~15ms | ~10ms | 272μs |
| Ingestion | ~5M/sec | 100K/sec | 50K/sec | 50K/sec | 5.52M/sec |
| Temporal joins | ASOF | limited | no | workaround | ASOF + Window JOIN |
| Python path | IPC | serialized | serialized | serialized | 522ns zero-copy |
| Agent memory | separate stack | separate stack | separate stack | separate stack | native memory + cache layer |
| Prompt cache | separate stack | separate stack | separate stack | separate stack | exact + semantic lookup |
| License | $100K+/yr | OSS | OSS / Cloud | OSS / Cloud | BUSL-1.1 + Free Community / Enterprise |
Detailed comparisons: Agent Memory vs Vector DBs · vs kdb+ · vs ClickHouse · vs InfluxDB · vs TimescaleDB
Start building
Section titled “Start building” Agent Memory How live time-series becomes context, cache, and replay for agents
Python Agent Memory Quickstart Copy-paste memory, context, cache, and write-back flow
Quick Start First query or agent memory loop in minutes
Features Time-series engine, memory layer, APIs, storage, and security
Benchmarks Criteria, reproduction notes, ingestion, query latency, Python zero-copy, and Agent Memory recall
Talk to Sales Discuss agent workflows, deployment shape, support, and Enterprise requirements