Skip to main content

A language for continuous decisions

Turn raw signals into decisions you can defend.

Write the computation in SQL, Python, or JavaScript. Replay it on history, inspect every decision, then keep the same stateful program running as new data arrives.

Incremental by defaultSQL · Python · JavaScriptHistory to liveDeterministic event time
BTC / ETH CORRELATION WATCH CONNECTING
RtBot computes live correlation between BTC and ETH pricesLive one-second BTC and ETH market prices are paired by event time. RtBot computes their rolling return correlation and emits an event when the configured threshold is crossed.
ρ

Loading synchronized BTC and ETH market history…

01 / STREAMING BY CONSTRUCTION

Write the computation. It is already streaming.

RtBot SQL compiles into a stateful operator graph. Each (time, value) tuple advances that graph incrementally, and an output appears only when the program has something to say.

ONE SQL PROGRAMREPLAYING HISTORYSAME GRAPH · NO RESET
RtBot SQL compiles into a stateful graph that processes event-time tuplesHistorical and live event-time tuples enter the same compiled operator graph. The graph maintains a moving average, compares the current value with its threshold, and adds a row to the output stream only when the SQL predicate is true.
01 ONE (TIME, VALUE) ENTERS02 STATE MOVES FORWARD03 AN OUTPUT MAY COME OUT

02 / EVENT TIME, NOT ARRIVAL TIME

Compose streams by when they happened.

Every value carries its own timestamp. RtBot queues streams independently and evaluates a multi-stream expression only when event times match. One stream may lead, lag, or arrive in bursts; as long as each stream stays ordered, arrival timing does not change the causal result.

MULTI-STREAM EVENT-TIME JOINARRIVAL PATTERN · A LEADS DETERMINISTIC
RtBot aligns independently arriving streams by event timeStream A and stream B arrive at different moments. RtBot queues their values and emits A plus B only when both values carry the same event timestamp.
EVENT-TIME TABLERECONSTRUCTED
00 / 08 VALID
Reconstructed event-time history. Results appear only after both stream values have arrived for a timestamp.
TIMEABA + B

Result appears only when A(t) and B(t) both exist.

03 / REPRODUCIBLE BY CONTRACT

Change the arrival. Keep the answer.

Run the same timestamped inputs through the same program and initial state. Packets may pause, burst, or interleave differently in physical time; the event-time output trace remains identical.

REPRODUCIBILITY LABSAME LOGICAL INPUT · DIFFERENT WALL CLOCKS
READY
Two RtBot executions produce identical results from different arrival schedulesRun one and run two receive the same timestamped values on streams A and B, but the values arrive in different physical-time patterns. Both executions produce the same five event-time output rows.

CONTRACT Each input preserves event-time order. Only the cross-stream wall-clock schedule changes.

04 / THE COMPUTATIONAL CORE

Built for numerical programs that remember.

RtBot combines signal processing, keyed state, temporal composition, and decision logic in one small deterministic runtime.

01

Numerical by design

Moving statistics maintain rolling state. Filters, resampling, arithmetic, peak detection, and composed feature pipelines advance incrementally with each event.

DSP · TIME SERIES · INCREMENTAL
02

State is part of the program

Each entity can carry its own computation forward. Chained operators turn measurements into indicators, conditions, and decision outputs.

KEYED · STATEFUL · COMPOSABLE
03

Deterministic by contract

Event time lives in the data. Given the same ordered input, graph, and floating-point platform, RtBot produces the same result without depending on wall-clock timing.

CAUSAL · REPLAYABLE · AUDITABLE
04

One graph, many runtimes

The native C++ core runs through Python, JavaScript/WASM, and Java—from a notebook or browser to a service embedded beside the data.

NATIVE · EMBEDDED · PORTABLE

05 / WHERE IT FITS

For answers that depend on what happened before.

RtBot earns its place when a decision depends on history, context, several signals, and exact timing—not merely the latest row.

01

CONDITION

Know when equipment, infrastructure, or a process begins to degrade—not merely when one reading crosses a line.

TYPICAL OUTPUT · DEGRADATION STATE
02

RISK & SURVEILLANCE

Turn fast-moving activity into explainable exceptions, flags, and escalations while preserving the evidence behind them.

TYPICAL OUTPUT · FLAG · ESCALATION
03

QUALITY & SAFETY

Combine several signals, persistence rules, and operating context before interrupting a line or involving an operator.

TYPICAL OUTPUT · HOLD · INTERVENTION
04

OPERATIONS

Continuously evaluate service, business, and control signals and emit the small number of changes downstream systems need.

TYPICAL OUTPUT · STATE CHANGE · OPPORTUNITY

06 / CONCRETE PROOF

A real signal problem, open for inspection.

The rotating-machinery preset library maps published methods for the NASA IMS rolling-bearing run-to-failure dataset into executable SQL. The accompanying notebook replays the data, validates the suite, and documents every parameter choice.

Inspect the bearing presets
20,480Hz source signal
11executable presets
TIER 1Fault detectionRMS · kurtosis · detectivity
TIER 2Fault diagnosisIIR bands · envelope · cepstrum
TIER 3Fault prognosishealth index · degradation rate
NASA IMS DATASET · PAPER-BACKED METHODS · REPRODUCIBLE NOTEBOOK

07 / START FREE, STAY PORTABLE

Begin where the algorithm is easiest to understand.

Use RtBot directly inside applications you own. Explore and backtest in Python, make the computation tangible in JavaScript, then embed the same deterministic graph in a service.

EXPLORE

Python

Replay data frames, tune parameters, inspect intermediate outputs, and embed the native runtime in numerical workflows.

Open the Python guide →
MAKE IT VISIBLE

JavaScript + WASM

Run the same engine in browsers, workers, and JavaScript applications—like the live computation at the top of this page.

Open the JavaScript guide →
EMBED

C++ + Java

Run the same graph inside native or JVM services and keep execution close to the systems that already own the data.

Inspect the runtime source ↗

08 / FROM PROGRAM TO OPERATIONS

Keep the engine. Add the production envelope.

Katenaria packages a validated RtBot program for continuous operation inside your infrastructure: high-rate ingress, durable stateful execution, and reliable delivery of sparse decisions.

01INGRESS

Inbound

Accept and normalize high-volume observations from the systems already in place.

02STATEFUL RUNTIME

rtbot-Redis

Execute stateful decision programs close to the stream and the data they depend on.

03EGRESS

Outbound

Deliver sparse decisions to applications, event buses, workflows, and user interfaces.

SELF-HOSTEDPRODUCTION SUPPORTCOMMERCIAL SOURCE ACCESSPlan an architecture review →

BEGIN WITH ONE DECISION

What should your system know before the next event arrives?

Bring one historical dataset and one decision worth making sooner. Build it with the free runtimes; when it is valuable enough to run continuously, we can help operate it in your infrastructure.