Deploy and Host

Jev Trader CPU — an AI market-making bot for the Kuru MON-USDC book on Monad, making one buy-or-sell decision per ~300 ms block with a local JevOS model on CPU ($0 inference, no API key). Every block it reads the live order book, asks the model, and posts one post-only limit order just inside the touch, so fills earn the spread instead of paying it. A live dashboard streams each block, decision, quote, fill and paper P&L.

Deploys in dry-run (paper trading): real book, real local AI decisions, simulated fills. No private keys, no API keys, zero form fields.

About Hosting

Two services, deployed together with one click:

trader — the Bun bot plus a self-contained live dashboard (SSE, no build step, no external assets) on /
jevos — the local CPU decision model (mc9max/jevos), reachable only over Railway's private network; no public domain, no key required

The trader discovers the model at http://${{jevos.RAILWAY_PRIVATE_DOMAIN}}:${{jevos.PORT}} automatically. Stateless: block history is in-memory (last 1000 events), nothing is written to disk, no volume is mounted. The dashboard doubles as the healthcheck (GET /, 200, unauthenticated).

Why Deploy

Hosted decision APIs charge per token and add network latency to a 300 ms block budget. Jev Trader CPU keeps the whole loop on your own hardware: the book read is a single eth_call, and the decision never leaves your Railway private network. You get the real upstream market-making strategy — post-only quotes one tick inside the touch, position caps, adverse-selection-aware quoting — with a $0/month inference bill and nothing to sign up for.

Latency note (measured 2026-10-15): on Railway's shared Hobby CPU the local JevOS model answers in ~0.5–1.9 s, not inside the ~300 ms block window — roughly 1 block in 4 gets a fresh decision and the rest safely hold (the dashboard shows late holds and per-decision latency honestly). The dry-run loop still paper-trades correctly: every decision posts a real sim quote and fills trigger on real taker prints.

Common Use Cases

Paper-trade a market-making strategy on live Monad book data with a real local model in the loop
Run a latency lab: per-block read/decide/loop timings and late holds are visible on the dashboard
Fork it into your own JevOS-powered trading logic — src/model.ts (LocalJevModel) is the seam
Demo CPU-only AI decisions: the whole "brain" is a 630 MB INT8 model running on shared vCPU

Configuration

Zero form fields on deploy — the template wires the model URL itself. After deploy, these are the knobs in the trader service's Variables panel (all optional):

Model: MODEL (jev-local default = free local JevOS sidecar; jev = hosted TypeSafe API via TYPESAFE_AI_API_KEY; mock = random decisions). JEV_BASE_URL is auto-wired to the sidecar over the private network.
Trading: DRY_RUN (true = paper trading; set false + PRIVATE_KEY for live orders), TRADE_SIZE_MON (200), MAX_POSITION_MON (1000), QUOTE_INSIDE_TICKS (1), HORIZON_BLOCKS (100), BANKROLL_USD (100, for P&L %), MARGIN_MON/MARGIN_USDC (600/20), GAS_LIMIT, MAX_FEE_GWEI/PRIORITY_FEE_GWEI (400/2).
Chain: RPC_URL / READ_RPC_URL (default https://rpc.monad.xyz), optional WS_URL, MARKET + MARGIN_ACCOUNT (Kuru MON-USDC; change together or not at all).

To go live, add PRIVATE_KEY with DRY_RUN=false — in Variables, never in a template form.

Dependencies for

This template requires a production Railway project with internal networking and persistent volumes for Jev Trader CPU data.

Deployment Dependencies

Two services, no database, no volume, no form fields. The trader needs outbound HTTPS to the Monad public RPC (https://rpc.monad.xyz) for book reads, block polling and trade logs. The jevos sidecar needs nothing at runtime — the model is baked into its image. To place real orders (off by default), add PRIVATE_KEY with DRY_RUN=false in the trader's Variables panel; live quotes draw from the Kuru margin account, which the bot funds at startup.