Real-time Greeks,
volatility, and flow
for every options desk.

Production. A wire-attached options feed; analytic ticks exit on the same contract as their historical and replay counterparts.

// Live: subscribe to streaming Greeks
// Cargo.toml: kairos = "0.1"
use kairos::Client;
use kairos::stream::Update;

let client = Client::connect(creds)?;
let mut stream = client
    .live()
    .greeks()
    .for_securities(["QQQ"])
    .subscribe()?;
loop {
    match stream.next_update()? {
        Update::Ready(batches) => handle(batches),
        Update::Pending => continue,
        Update::Done => break,
        Update::Dropped(e)
        | Update::Error(e) => recover(e),
    }
}

Research. A bounded interval streamed through the same engine; outputs are bit-for-bit identical to live emission for that window.

// Historical: bounded YYYYMMDD window
// Cargo.toml: kairos = "0.1"
use kairos::Client;

let client = Client::connect(creds)?;
let batches = client
    .historical(20_260_415, 20_260_419)
    .greeks()
    .for_securities(["QQQ"])
    .run()?
    .collect()?;

// batches: Vec of Arrow RecordBatch over the
// analytic's published schema.

Audit. A captured tick log fed back in original order; output ticks reproduce the original session exactly.

// Replay: re-run against a captured parquet
// Cargo.toml: kairos = "0.1"
use kairos::Client;

let client = Client::connect(creds)?;
let batches = client
    .replay()
    .greeks()
    .for_securities(["QQQ"])
    .from_parquet("capture-2026-04-15.parquet")
    .run()?
    .collect()?;

// Same builder, same tick contract — bounded
// against the captured dataset.