CLI flag reference

docker run --rm registry.rystic.ai/kalshi-twin:<version> rystic help run

usage: rystic pull [flags] [product]

download and install a twin release

Installs into $RYSTIC_HOME/twins/<product>/<version> and marks it current,
verifying the download against the release checksum before unpacking.

usage: rystic update [flags] [product]

install a newer twin release, or just ask whether one exists

With -check, prints what is available and exits 10 when a newer
version exists — nothing is downloaded.

usage: rystic run [flags] [product] [-- args...]

run a twin (pulls it if missing); -d detaches, args after -- go to the twin

Prints one identity line — product, version, model, licensee, URL — once
the twin serves. --scenario/--seed/--tapes/--tape choose the starting state.
Default port 8080; a busy port is a conflict (exit 9); --port 0 picks a free one.

usage: rystic ps [flags]

list running twins — status from a live probe, not the record

usage: rystic stop [flags] <name>… | --all

stop instances (SIGTERM, then SIGKILL after -timeout)

usage: rystic restart [flags] <name>… | --all

stop and start again from the recorded spec

usage: rystic rm <name>…

remove a stopped instance's record and log (refuses a live one)

usage: rystic logs [flags] [-f] <name>

print a detached twin's log; -f follows

usage: rystic report [flags] <batch-out-dir> [-sort col] [-csv]

the batch P&L table — per-world declared columns, exact totals, settled vs left open

usage: rystic up [flags] [-d] [-f rystic.yaml] [service…]

start every service of a stack file — each exactly one `run -d`

A stack file is a hand-picked set of twins: version: 1, project, and
services: {name: {product, version, runner, port, scenario, seed, tapes,
tape, speed, env, args, seed_rng, egress_retain, network, live}} — the same
keys as run's flags; the service name is the instance name; the project
labels every twin for `ps --project` and `down`. Already-running services
are said, not restarted. Without -d, up holds the terminal and Ctrl-C is
`down`.

usage: rystic down [flags] [-f rystic.yaml | --project p]

stop every instance of a stack file's project

usage: rystic export [flags] compose|antithesis [-f rystic.yaml] [-o dir]

write a docker-compose.yaml (digest-pinned, license from .env) or the Antithesis scaffold from a stack file

compose: each service becomes a compose service on registry.rystic.ai/<product>@<digest>
(resolved through the front door with your license — the run is reproducible),
RYSTIC_LICENSE from .env (.env.example is written beside it, never a value),
init: true, the image's HEALTHCHECK for depends_on. antithesis: the same plus
platform linux/amd64, Dockerfile.config (FROM scratch, the compose file + .env)
and a README with the tenant push commands (--tenant, --gcp-project). A tape:
key cannot be expressed in compose and is reported.

usage: rystic status [flags]

license, runtime, registry, installed, running, updates — one screen

usage: rystic batch [flags] [product] [flags] -- <bot command>

run a bot against every tape in your library — natively, or one container per world with --runner docker

One twin+bot pair per tape, -j at a time, longest tape first, at speed 1 —
real time, so the code under test keeps a coherent clock. One JSONL ledger
row per tape in -out. -dry-run prints the plan without running anything.
The bot contract is four environment variables — RYSTIC_ADDR, RYSTIC_WORLD,
RYSTIC_WORLD_KIND, RYSTIC_RESULT, plus RYSTIC_MARKET on a tape cell — and
the same values are substituted into the bot's own argv as {{addr}}
{{world}} {{world_kind}} {{result}} {{market}}, for a bot that takes them as
flags rather than from the environment: `-- python3 bot.py --event
{{market}}` gives each cell its own market instead of one market N times.
{{market}} is the MARKET ticker the tape directory is named for; a bot
wanting a coarser id derives it itself, and on -scenarios it is refused
rather than substituted empty. With --runner docker the substitution happens
inside your image, and an image whose rystic predates placeholders is
refused before it runs rather than passing the braces through verbatim.
--runner docker --image <ref> runs each world in its own container from YOUR
image (FROM registry.rystic.ai/<product>:<version> + your bot's runtime): the
same ledger, state and logs, kernel-isolated, no shared ports; the license
reaches each container only through its environment.

usage: rystic grid [flags] [product] [flags] [-- <bot command>]

run the bot × world matrix: bundled example bots (plus yours) against the twin's scenario worlds

One twin per cell. Rows are the archive's declared grid bots, plus your own
command after `--` (same contract as batch: read RYSTIC_ADDR, exit 0 for
pass, and the same argv placeholders — except {{market}}, which a scenario
world has not got and which grid therefore refuses). Columns default to the
archive's declared worlds; -worlds overrides
('all' runs the twin's whole catalog). Prints the grid and exits non-zero
if any cell failed.

usage: rystic check [flags] [product]

boot an installed twin and confirm it serves and resets

usage: rystic tail [flags]

stream a running twin's state events to this terminal

Connects to the twin's /_rystic/events stream and prints one line per
event. -events scopes the feed (private, public, writes, reads, control;
or all) — the default shows fills, order updates and other state changes
and skips public market-data floods.

usage: rystic feed [flags] [product] --instance <name> | --url <base>

feed a running twin live exchange frames (the twin's manifest declares the source; a release build carries the key it needs)

Runs in the foreground until Ctrl-C. `rystic run --live` starts a twin and
this feeder together (either runner: the feeder is a host process posting
to the twin's URL); use `feed` alone for a twin already running — any
runner, any machine. --live-series * carries whatever the twin's Markets
card picks from the exchange's busiest open markets; nothing is carried
until something is picked (--live-carry N pre-carries the busiest N,
--live-markets A,B carries exactly those). Every --live-x-y flag defaults
from RYSTIC_LIVE_X_Y. The twin's manifest names its exchange key vars: an
id, then either <X>_PRIVATE_KEY_FILE (a path) or <X>_PRIVATE_KEY_B64 (the PEM).

usage: rystic doctor [flags] [product]

check this machine end to end without running anything

Verifies the license, the install, that the twin and your license agree on a
signing key, and that the data the twin needs is where it expects it. Exits 0
when everything passes; warnings (!) are features you do not have yet, not
failures. Run it before a demo, not during one.

usage: rystic features [flags] [product]

list what the installed twin can do

Read from the twin's own manifest, so it describes the build you have rather
than what this CLI was written against. -v adds detail and control-plane URLs.

usage: rystic list [flags]

released sims your license covers — latest, installed, running (--installed: the old per-version lines)

usage: rystic login [flags] <file>

install a license file, and log docker in to the registry with it

Verifies the license and parks it in $RYSTIC_HOME, where every later
command finds it without a flag (`rystic license` shows it afterwards).
The same file is the password for the Rystic image registry, so when a
container runtime answers this also runs `docker login <registry> -u
license --password-stdin` — `docker pull <registry>/<product>:<version>`
and `rystic run --runner docker` then work with nothing else. --no-docker
skips that half.

usage: rystic license [flags] [activate <file>]

show the active license, or install one

`rystic license activate <file>` verifies a license and parks it in
$RYSTIC_HOME, where every later command finds it without a flag.

usage: rystic config [flags] [set <key> <value>]

show every setting with its source, or set one

Settings resolve flag > environment > $RYSTIC_HOME/config.json > built-in,
and this prints which. Keys: runner, port, tapes, release_endpoint,
catalog_endpoint, image_source (registry|archive), registry, docker.binary,
docker.host.

usage: rystic self-update [flags]

replace this CLI with the latest release

The CLI itself is not license-gated: it downloads from the public release
endpoint. With -check, reports and exits 10 without replacing anything.

usage: rystic version [flags]

print this CLI's version, then every running twin's

Prints this CLI's version, commit, build date and platform, then every
running twin's product, version and model, and warns when a running twin
is behind the installed one.