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 / SIGNALS, NOT ROWS

Stop translating equations into joins.

When the problem is one causal equation over several ordered signals, RtBot keeps the domain model intact. Time is not another field to reconcile. It is the coordinate system on which the program runs.

THE INTENTactive_power(t) = voltage(t) × current(t) × power_factor(t)ONE EQUATION · THREE LIVE SIGNALS
RELATIONAL STREAMING SQL2 EXPLICIT TIME JOINS
SELECT
  v.event_time,
  v.value * i.value * pf.value AS active_power
FROM voltage AS v
JOIN current AS i
  ON i.event_time = v.event_time
JOIN power_factor AS pf
  ON pf.event_time = v.event_time;
01

Join voltage to currentState that their event-time columns must match.

02

Join the power factorRepeat the temporal relationship for the third signal.

03

Then evaluate the equationThe physical calculation comes after row matching.

RTBOT SQL1 SIGNAL EXPRESSION
SELECT
  v.value * i.value * pf.value AS active_power
FROM voltage AS v,
     current AS i,
     power_factor AS pf;
01

List the three signalsEach input is already an ordered signal x(t).

02

Time alignment is automaticThe three signal fronts meet at event time t.

03

Emit active_power(t)The result appears when the equation is evaluable.

BEFORETranslate one equation into a chain of temporal joins.

WITH RTBOTKeep the equation as the executable program.

05 / ONE PROGRAM, TWO MODES

What you validate is what you deploy.

RtBot removes the production rewrite from the development cycle. Historical and live events advance the same compiled graph, with the same state transitions and output semantics.

WITHOUT A SHARED EXECUTION MODELTRANSLATE, THEN VALIDATE AGAIN
  1. Explore in a notebookMerge frames, calculate features, tune parameters.
  2. Rewrite for streamingRecreate joins, windows, state, and emission behavior.
  3. Choose production policiesResolve time, ordering, lateness, and replay decisions.
  4. Validate the rewriteProve that the production system still means the same thing.

Every translation is another place for the algorithm and the production system to disagree.

WITH RTBOTNO PRODUCTION REWRITE
MODE 01HISTORICAL REPLAYbacktest · tune · inspect
MODE 02LIVE STREAMcontinue · evaluate · emit
ONE EXECUTABLE DEFINITIONRtBot SQL programSAME COMPILED GRAPH
DECISION TRACESAME OUTPUT SEMANTICS

Replay stops. Live input starts. The program does not change.

06 / CONCRETE PROOF

From published method to live stream—with no rewrite.

NASA IMS Dataset 1 provides a public 34-day failure history and published signatures against which every step can be inspected.

DOI01 / SOURCEPUBLISHED METHODRMS fault signature
SQL02 / PROGRAMEXECUTABLE SQLrms_alert
34D03 / VALIDATEHISTORICAL REPLAY4 bearings · 2 faults
LIVE04 / OPERATELIVE STREAMsame C++ graph
PRESET 01 · FAULT DETECTIONRMS trend + rolling baseline
PUBLIC CASE
CREATE MATERIALIZED VIEW rms_alert AS
SELECT device_id, channel_id, rms_value,
       MOVING_AVERAGE(rms_value, 48) AS baseline_rms
FROM rms_trend
WHERE rms_value > MOVING_AVERAGE(rms_value, 48) * 2.5;
RAW VIBRATION20,480 Hz
ROLLING BASELINE48 bursts · ≈8 h
ALERTRMS > 2.5×
34 daysrun-to-failure history
4 bearingstwo observed faults
4 of 11presets reproduced in the public notebook

07 / 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

08 / 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 ↗

09 / FROM PROGRAM TO OPERATIONS

Deploy the program as a production kernel.

A Helm chart installs the data plane in your Kubernetes cluster. The Kernel Controller manages the complete lifecycle of the self-hosted deployment.

K8SYOUR KUBERNETES CLUSTERHELM RELEASE
CONTROL PLANEKERNEL CONTROLLER

Manages the kernel lifecycle

INGESTINBOUNDMQTT · WEBSOCKET · HTTP
COMPUTERTBOT-REDIS
DELIVEROUTBOUNDMQTT · WEBSOCKET · HTTP
SELF-HOSTED DATA PLANEINBOUND → RTBOT-REDIS → OUTBOUND
FREE TO DEPLOYCOMMERCIAL SUPPORT AVAILABLETalk to us about production →

WHEN TO CALL US

When the next batch is already too late, talk to us.

We help technical teams move validated algorithms from batch or micro-batch pipelines into continuous, self-hosted production systems. Bring one existing computation and the constraints around it.

Discuss your streaming migration FREE TO START · COMMERCIAL IMPLEMENTATION AND SUPPORT

TALK TO US IF YOU NEED TO:

  • 01

    Convert batch or micro-batch computations into continuous streaming programs.

  • 02

    Rewrite full-window jobs as incremental, rolling state updates.

  • 03

    Validate and tune against historical data, then run the same program live.

  • 04

    Process high-frequency, time-stamped data at sustained throughput.

  • 05

    Combine asynchronous streams by event time without custom synchronization.

  • 06

    Deploy and operate the complete data plane inside your own infrastructure.