Real-time AI and ML systems operate as continuous loops. Events arrive, application state changes, a model makes a decision, and the result becomes another event.
AlgoX2 keeps the data path for every one of those decisions on one real-time plane: rules engines, scorecards, gradient-boosted trees, sequence models, recommenders and agents. Producers write each fact once. Applications continuously turn those facts into the state models need. Each consumer reads the same ordered history at its own pace.
Build real-time AI on one data plane
Stateful stream processing applies application code to new events and materializes current-state projections, entity profiles, sequence features, or decision messages. Online models read the current materialization, while training jobs replay retained history at recorded cuts.
Streams, state, and computation
| Primitive | Role |
|---|---|
| Ordered event history | Captures fresh events once and retains their permanent stream positions for replay. |
| Stateful stream processing | Runs application transforms continuously and writes their results back as new streams. |
| Materialized current-state views | Resolve an entity key directly to current features, profiles, or the latest N events. Ordered streams retain the complete event history behind each view. |
| Index by entity | Reads the latest events of one customer, card, device, or agent session without scanning the events of others. |
| Cuts and checkpoints | Save application state with the exclusive next-read position in each input stream, so a restart resumes with the following messages. |
Messages keep the same stream positions across memory, local storage, and object storage. X2 serves cache hits from memory and refills an uncached range from a storage tier that retains it. Live arrivals and historical refills use separate cache shares, so a deep replay does not evict the live working set.
What teams build on AlgoX2
Fraud and Credit Decisioning Velocity rules, application and behavioral scorecards, gradient-boosted trees, and sequence models score the same event from the same history. Their features update as each event arrives, not in an overnight batch. A challenger model runs beside the champion on identical inputs, and each decision records its input cut, model version, and output on a stream.
Real-Time Feature Store A stream application maintains counters, scores, profiles, and latest values as events arrive. The online path reads current values by entity key without waiting for a batch refresh.
Sequence Features Applications derive ordered sequence features from per-entity event history. Online models read the latest N events, while training reconstructs the same features at earlier inference times.
Personalization and Recommendations Applications fold interactions into continuously changing customer, account, device, or product state. Recommendation and ranking systems combine that state with the entity’s latest N events, including the event that happened a moment ago.
Agent Journals Bank-side and customer-facing agents record every read, model call, tool call, and approval in a session journal. After a crash, a replacement resumes from the journal without repeating recorded steps: X2 fences out the old writer, and writes by position land exactly once. The journal is live for observability and replayable for audit and evaluation.
One source for serving and training
Serving and training need different physical access paths. Serving reads one current entity under a latency budget, while training reconstructs billions of earlier contexts at high throughput.
They do not need separate definitions of the data. A versioned input definition specifies membership, ordering, corrections, and cutoff eligibility once. Online serving and historical training both derive their inputs from that definition and the same retained source.
This structure removes an entire class of training-serving skew. A recorded cut identifies the facts that were available, while the transformation and model versions identify how those facts became an input and a decision.
Built for the request path
AlgoX2 is streaming-first. It acknowledges a publish in under 10 µs and carries up to 5M messages a second per node, so a model reads the event it is scoring. It is designed for fresh events, high ingestion throughput, independent consumers, and application code running close to the stream.
Model development and execution remain outside the data plane. Training and serving systems manage model code, weights, runtimes, accelerators, and scaling. AlgoX2 stores and delivers the continuously changing events, state, and history that those systems depend on.