GroveStreams is a temporal intelligence platform with built-in analytics, forecasting, and an AI query layer. It reduces the entire temporal data management surface to a single primitive — the stream. Every property on every entity and every relationship between entities is a stream with its own independent time axis, queryable through a single language (GS SQL), with built-in AI forecasting and correlation detection. No history tables. No materialized views. No batch roll-up jobs. One primitive replaces them all.
The entire database is a living memory of everything that ever happened and how things were connected at any point in time. Every data point knows when it happened. Every relationship knows when it changed. Every query can travel through time.
The Deep Cell Model
Visualize GroveStreams as a relational table where each component (entity) is a row and each stream is a column — but every cell holds up to 100 million timestamped values, not just one. The current value sits on top. The complete history lives underneath. A temperature reading every second? Stream. A rate schedule that changes once a year? Stream. A pump-to-tank relationship that changes twice a year? Also a stream. All use identical query semantics.
This is what makes temporal intelligence possible: any query can reach any point in time. You don't pre-aggregate. You don't choose in advance which time ranges to keep. Every value, every relationship, every change — queryable with standard SQL, from one second to one decade.
Time-series databases store deep history but have no relational model — no JOINs across entities. Traditional databases have relational structure but each cell holds one value — temporal history requires separate history tables, triggers, and batch jobs. TimescaleDB and similar extensions add deep time-series storage to a relational model, but at the row level — rows are time-stamped, not cells. Historians store millions of points per tag but have no entity model at all. GroveStreams is the only platform we know of where every cell in a relational table is itself a complete time-series, and where relationships between entities are themselves time-series.
This is schema-per-instance rather than schema-per-table. Each entity carries its own temporal structure. No rigid table schemas forcing every row into the same shape. No NULL-filled columns for data that simply doesn't apply.
One Primitive Replaces Five Infrastructure Concerns
A skilled DBA can build temporal history tracking, relationship history, roll-up aggregations, and cross-entity correlation in PostgreSQL or any traditional database. But they must design the history tables, write the triggers, build the materialized views, maintain the batch jobs, and do it all from scratch — for every project, every time. GroveStreams makes all of that automatic and native.
Streams subsume what traditionally requires:
- Data tables
- History tables with triggers
- Materialized views for roll-ups
- Batch aggregation jobs
- Junction tables for relationships
Temporal Relationships
Relationships between entities are streams. When Pump-A is reconnected from Tank-7 to Tank-12, a new data point is appended to the stream. The old connection stays in the history. Any stream can store a UID pointing to another component or stream, enabling temporal relationship tracking today. This is the key architectural differentiator vs. most platforms — relationships have full temporal history, not just a current-state pointer.
Same Dashboard. Different Data. Per User.
Role-based access control in GroveStreams is enforced inside the query engine — not at an API gateway, not in application code, not as an afterthought. When users interact through the UI, GS SQL, the AI assistant, ODBC/JDBC connections, or OAuth-authenticated OData connections, the query engine filters results by their individual permissions. If a user doesn't have read access to a component, that component's data is absent from query results entirely — not just hidden in the UI.
User A sees their 50 assets. User B sees their 200. Same dashboard, same URL, same layout — different data. The AI assistant respects it. The ODBC/JDBC connection from Tableau respects it — including saved-query VIEWs that expose full temporal history. The OData feed to Power BI respects it. Every GS SQL query respects it. Automatically.
Most platforms either don't have query-layer security at all, or require vendor engineers to configure it. Time-series databases like InfluxDB and QuestDB offer tenant-level isolation but no per-user, per-component filtering. TimescaleDB inherits PostgreSQL's row-level security, but it breaks with continuous aggregates — the exact scenario where rollups and per-user filtering need to work together. Platforms that do offer comparable security require expert configuration and aren't consistent across every access path. GroveStreams enforces it uniformly across every query path, and your team manages access policies directly — no vendor dependency for ongoing security configuration.
API keys provide a separate security model for system-to-system integration — scoped by endpoint, resource type, IP address, and domain whitelist.
Independent Time Axes
Each stream has its own time axis. No shared clock forcing NULL-filling or interpolation. An energy meter reading every fifteen minutes and a contract status that changes quarterly coexist naturally. Sparse data is native — not a special case. When correlating streams with different time axes, roll-ups project both onto a common temporal grid — the same roll-up infrastructure that powers analytics also solves cross-stream temporal correlation.
The Core AI Data Foundation
Standard SQL is hard for LLMs to get right with time-series. Handling time zones, gaps, interpolation, and temporal joins leads to hallucinated syntax and broken queries. GroveStreams solves this at the platform level. GS SQL provides time-series extensions — rollups, time filters, gap filling — sitting on top of a massive-scale store. AI agents get complete temporal context natively, not through fragile prompt engineering.
Ask your data anything. Get answers in seconds, not sprints. An AI agent using GS SQL can answer questions like:
- "What was the average energy cost per meter during peak hours last quarter, and how does it compare to the same period last year?"
- "Which pumps were connected to Tank-12 when the pressure anomaly occurred on March 15th?"
- "Show me every equipment relationship change that happened within 24 hours of a maintenance event across all facilities."
- "What is the predicted demand for the next 72 hours based on the last 90 days of consumption data?"
- "Which streams are most correlated with the temperature anomalies we saw last week?"
Streaming Intelligence Engine
Static reports tell you what happened. GroveStreams tells you what's happening — and what's about to happen. Every capability in the platform maps directly to the needs of intelligent agents:
| Platform Capability | For AI Agents | What It Means |
|---|---|---|
| Ingestion (100M+ pts/stream) | Infinite Context Window | Agents can reason over years of history, not just the last few hours |
| Rollups & Aggregation | Agent Memory | Raw noise summarized into meaningful trends automatically |
| Derived Streams & Formulas | Reasoning Logic | Pre-processed data so the AI doesn't have to compute it on every query |
| HTTP/MQTT Actions | Agent Tools | AI can act on conclusions — reboot a server, adjust a setpoint, trigger a workflow |
| Forecasting (TFT, Prophet, N-BEATS...) | Predictive Planning | Agents get foresight, not just hindsight |
| GS SQL | Native Query Language | Purpose-built for temporal queries — no hallucinated SQL syntax |
Your Analysts Can Query It on Day One
Most enterprise data platforms require specialized consultants, onsite engagements, and six-figure implementation projects before your team can ask their first question. GroveStreams is designed so your analysts own it from day one. The AI assistant generates GS SQL from plain English. Dashboards are drag-and-drop. Template design is point-and-click. Your team doesn't need SQL experience to get started — and we're never on your critical path.
One of our largest customers, a Fortune 100 energy storage company, runs their entire analytics operation on GroveStreams with no prior SQL experience. Their team started with the platform's visual tools, and now leverages the AI assistant to generate complex temporal queries across thousands of battery systems. We helped them get started — but we don't have to live there.
How GroveStreams Compares
| Capability | Multi-System Alternative | GroveStreams |
|---|---|---|
| Properties | Static values or separate TS sync | Every property is a temporal stream |
| Relationships | Static pointers (no history) | Streams with full temporal history |
| Time-Series Storage | External system (separate DB) | Core architecture (100M+ pts/stream) |
| Relational + Temporal Depth | TSDBs have depth but no relational model. RDBMS have relations but one value per cell. Historians have depth but no entity model. No platform combines all three. | Every cell in a relational table is a complete time-series. JOINs, WHERE, GROUP BY across entities — at any point in time. |
| Cross-Stream Correlation | History tables, triggers, batch jobs | Roll-ups align time axes; equi-join on entity ID |
| Query Language | Multiple (SQL + Graph + TS API) | Unified GS SQL |
| AI Forecasting | External ML services | Built-in (8 model types per stream) |
| Real-Time Roll-ups | Manual (Spark/Flink jobs) | Automatic, configurable hierarchies |
| Derived Streams | Custom pipeline code | Excel-style formulas, real-time |
| Schema Evolution | Table locks / pipeline rebuilds | Live reconciliation, zero downtime |
| Query-Layer Security | Tenant isolation (InfluxDB, QuestDB), broken with rollups (TimescaleDB RLS), or requires vendor engineers (Palantir) | Per-user RBAC inside the query engine — same dashboard, different data, self-configured |
| Time to First Query | Weeks to months (implementation, training, vendor dependency) | Days — visual tools for analysts, full API for engineers, AI assistant for both |
| Third-Party Ecosystem | Hundreds of connectors (Kafka, Spark, dbt, etc.) | Focused set (MQTT, HTTP, ODBC/JDBC with saved-query VIEWs, OData, RSS) |
