Jev 101 logo
Jev 101

Guides / illustrated walkthrough

Jev Trader Tutorial: Build a Subsecond AI Trading Bot on Monad

Alex Hitt builds and deploys a fully autonomous AI market maker on the Monad testnet in about six minutes: the Jev Trader, a bot powered by the TypeSafe Jev model that fires subsecond deterministic trades on the Kuru DEX — clone, bun install, split-RPC config, benchmarks, dry run, and go-live.

Quick takeaway

Jev Trader is an open-source autonomous market maker that executes deterministic subsecond trades on the Kuru DEX (Monad testnet). The Jev model scores the order book in 70-500ms via a parallel sampling architecture — frontier LLMs need 3+ seconds of token-by-token decoding and cost about 240x more ($0.042 vs $10 per 1M input tokens). Setup: git clone, copy .env.example to .env, bun install (npm install fails immediately), leave PRIVATE_KEY blank for dry-run mode, split reads and writes across two premium RPC endpoints, set MODEL=jev with your TypeSafe AI API key. Validate with bun run scripts/bench-read.ts (target ~18-20ms) plus the offline calldata dry-run, then bun run start and read the SSE telemetry: simulated: true, upIn10 0.85, confidence HIGH. Tune quote_inside_ticks, then paste your funded wallet key to go live on Monad.

Video source

Alex Hitt

6:32YIEHGt-9cS4
Visit channelWatch original

Step-by-step walkthrough

  1. 1

    Clone the Jev Trader repo and install with bun — never npm

    Grab the codebase with git clone, navigate into the new project folder, and copy .env.example to .env to create your active configuration. Install dependencies with exactly bun install: the repo is heavily optimized for the bun runtime, and the video shows npm install failing outright with an incompatible-runtime error. That one terminal sequence locks in the high-performance foundation the bot needs for its microsecond-scale operations.

    Hand-drawn terminal window running the bun install command with a magenta cursor block, the only supported installer for the Jev Trader repository cloned from GitHub.
    bun install only — the repo ships optimized for the bun runtime, and npm install fails immediately.Watch at 1:34
  2. 2

    Parameterize .env: blank private key, split RPC paths, MODEL=jev

    Open .env and leave PRIVATE_KEY completely blank for now — omitting it forces a protective dry-run mode that secures your capital while you test the network. Paste a premium low-latency node URL into the read RPC variable, which exclusively queries limit-order-book depth at the start of every block, and a secondary provider into the write RPC variable, used strictly as a fire-and-forget channel for broadcasting signed transactions. Set MODEL to jev and paste your TypeSafe token into the TYPESAFE_AI_API_KEY field. This bifurcation is what spares you the socket contention that makes a single-RPC setup lose Monad’s 300ms race.

    Code editor card listing MODEL = jev and TYPESAFE_AI_API_KEY = "sk-abc123...xyz987" as the two decisive lines of the Jev Trader .env configuration.
    Two lines wire up the decision engine: MODEL = jev plus your TypeSafe AI API key.Watch at 3:12
  3. 3

    Beat the 300ms block window: benchmark reads, dry-run the calldata

    Every cycle the bot must pull market state, ask the Jev model for a decision, and broadcast a transaction before Monad’s block closes — the diagram budgets ~18ms for the eth_call read plus 70-80ms of Jev inference inside one 300ms window. Type bun run scripts/bench-read.ts to test your premium node: the terminal needs to report roughly 18-20ms, or the AI won’t have time left to compute its decision. Then run the offline calldata utility (scripts/dry-run-trade.ts), which signs a hypothetical buy and sell to verify your transaction structures match the Kuru SDK before you ever trade live.

    Jev-Trader 300ms Hot Loop architecture diagram flowing from Monad Blockchain Kuru LOB through an ~18ms eth_call, 70-80ms Jev inference in the Node.js Bun runtime, and a fire-and-forget Broadcast Tx to a Dedicated Write RPC with an SSE Dashboard for telemetry.
    The bifurcated hot loop: read path, Jev inference, fire-and-forget write — inside one 300ms block.Watch at 2:34
  4. 4

    Run the hot loop, read the SSE telemetry, then go live

    Start the bot with bun run start: it pulls the localized order-book state and routes it to the Jev model through the Vercel AI SDK. Open the local server port in your browser to watch the server-sent-events telemetry stream — the demo block shows simulated: true (hypothetical outcomes, no real capital at risk) plus AI_Inference_Metrics with model jev-1, upIn10 0.85, and confidence HIGH. Leave it running to observe the hypothetical PnL trajectory and tune the quote_inside_ticks parameter, which sets how aggressively orders sit relative to the bid-ask spread. When you are satisfied, stop the process, paste your funded wallet’s private key into .env, and start again — the bot verifies margin balances and deploys active AI-guided liquidity on Monad.

    SSE telemetry JSON from the Jev Trader bot highlighting "simulated": true with a shield badge next to AI_Inference_Metrics showing model jev-1, upIn10 0.85, downIn10 0.12, and confidence HIGH for block 1234567.
    simulated: true plus a shield icon — the dry run tracks hypothetical PnL while your capital stays untouched.Watch at 5:06

Frequently asked questions

What is Jev Trader?

An open-source trading bot you clone from GitHub that runs a fully autonomous AI market maker on the Monad testnet. It uses the TypeSafe Jev model as its decision engine to execute subsecond deterministic trades on the Kuru decentralized exchange, and the whole build — clone, configure, benchmark, dry run — fits in a six-minute video.

How fast is the Jev trading loop?

The Jev model evaluates limit-order-book data with a parallel sampling architecture and returns deterministic probability scores in 70-500ms, versus 3+ seconds of token-by-token decoding from frontier LLMs. The full cycle — market state read (~18-20ms), Jev inference (70-80ms), and transaction broadcast — has to fit inside Monad’s 300ms block window.

Do I need a TypeSafe AI API key to run Jev Trader?

Yes. The video lists four prerequisites for your host machine: the bun JavaScript runtime, testnet Monad tokens for gas, an active TypeSafe AI API key (pasted into TYPESAFE_AI_API_KEY with MODEL=jev), and access to premium low-latency RPC endpoints for the read and write paths.

Can I test Jev Trader without risking real funds?

Yes — that is the default. Leave the PRIVATE_KEY field blank and the bot runs in a protective dry-run mode: the SSE telemetry shows simulated: true while it tracks hypothetical PnL. Watch the upIn10 scores, tune quote_inside_ticks, and only paste your funded wallet’s private key when you are ready to deploy real liquidity.

Related guides

Jev Browser Agent Guide

The same creator’s other hands-on: Jev’s browser agent, its dual-model execution loop, and DOM snapshot filtering.

Read

Jev Pricing

What hosted Jev inference costs per decision — compare it with the $10-per-million frontier baseline from the video’s chart.

Read

Get a TypeSafe AI API Key

The TYPESAFE_AI_API_KEY the bot’s decision engine needs — plans, endpoints, and a quickstart.

Read

More video walkthroughs