On October 1, Jev bought WLD at market with 99% confidence.
Its own inputs had already labelled the move “extended”. The LLM agent trading next to it had refused that exact chase all day. Jev didn’t hesitate. Then it sat in the losing trade for 23 hours, answering “hold” every time it was asked (55 times in a row), until the stop closed it at −1R.
That was the first real trade of a new kind of AI model in my trading bot. Jev isn’t a chatbot and it isn’t an agent. It’s what its maker, TypeSafe, calls a System One model: it reads a structured state, answers narrow typed questions and returns probabilities, in a few hundred milliseconds, for a fraction of a cent.
I spent 17 days running it side by side with a reasoning LLM on the same market data, the same safety rules and the same small real account. This post is about Jev: what it is, what a call looks like, how to ask it well, what it did with real money, and where I think it belongs.
TL;DR
Most of us now think of “AI” as a model that writes: you send a prompt and get text back, maybe a tool call. Jev is different by design. TypeSafe’s docs describe System One models as built for “fast, structured decisions that software can use directly”, and Jev is the first one.
The name is a nod to Daniel Kahneman’s two systems of thinking: System 1 is the fast, automatic judgement, System 2 the slow, deliberate reasoning. An LLM agent that reads news, calls tools and writes a plan is System 2. Jev is meant to be the five-second expert glance.
In practice:
The design philosophy in TypeSafe’s build guide will feel familiar to anyone who has fought an agent: build a normal software workflow, keep control flow and side effects in code, and insert System One only where you need a judgement, as narrow typed questions.
That happens to be exactly the rule my trading bot was built on.
trAIde is an autonomous crypto trading bot I build in public: KuCoin perpetual futures, a deliberately tiny real account, a live public dashboard and open-source code (the backstory is in my previous post, I Gave My AI Agent $70 and My Exchange Keys). Its main trader is an LLM agent running gpt-6-luna, so on the dashboard it’s simply Luna. Everything hangs on one rule:
Code enforces SURVIVAL. The model owns OPPORTUNITY.
The model picks the coin, the direction and the timing. Code decides how much can be lost: a risk cap per trade, a stop and target attached at entry, circuit breakers, trailing stops, and a “stand-aside” that gives any playbook without a measured edge a stake of exactly zero.
A trading decision looks like a perfect System One question: a state (the market), a fixed set of options (long, short, stand aside) and a probability you could act on. So the experiment asked:
Can a sub-second classifier call direction as well as a reasoning LLM on the same data, at a fraction of the cost? And when the two disagree, who is right?
The rules, set before Jev placed a single order:
Jev never sees the balance, the gates or its own scoreboard. A model that can see its scoreboard can learn to game it.
This is the real shape of a call in the bot (wording trimmed), using TypeSafe’s Python SDK (typesafe-sdk):
from typesafe_sdk import AsyncTypeSafeClient, RetryPolicyclient = AsyncTypeSafeClient(model="jev-1.13.0", timeout=5.0, retry=RetryPolicy(max_retries=1))questions = { "direction_0": { "type": "choice", "instructions": "You trade the USDT perpetual future in `symbol`. From `timeframes`, " "` summary`, `price` and `futures`, which position has the better expected " "result over the next 1 to 8 hours, after about 0.14% round-trip cost?", "criteria": { "long": "Open a LONG now: price is more likely to rise far enough to pay the costs " "than to fall to the stop.", "short": "Open a SHORT now: price is more likely to fall far enough to pay the costs " "than to rise to the stop.", "stand_aside": "No position: the expected move is too small or too uncertain.", }, }, # direction_1 and direction_2: the same question with the options rotated (see below)}resp = await client.system_one(state=state, questions=questions)# each answer: the chosen option, a probability for every option, and a confidence
And this is one line from the bot’s log on October 17, a single Jev decision end to end:
JEV ETH-USDT: SHORT 0.96 (L 0.01 / S 0.96 / stand 0.03) continuation · pullback · near 1.65R → refused (Stand aside: 'continuation:short' playbook measures NO EDGE over 54 signals)
Jev was 96% sure. The bot refused anyway, because Jev’s own record on that playbook said it had no edge. Hold on to that; it comes back.
Before asking Jev anything with money attached, I read TypeSafe’s docs and their official agent skill, plus the independent studies collected in awesome-jev-robustness. Six practices came out of it. They apply to any Jev project, trading or not.
1. Give it words, not numbers. Numbers are one of Jev’s documented weak spots, and TypeSafe recommends named categories instead (“RSI: overbought”, not “RSI: 78.3”). In the bot, code turns every indicator into a label, and a test walks the whole state to make sure not one raw number reaches Jev. An illustrative, trimmed example of what Jev reads:
{ "symbol": "SOL-USDT", "instrument": "USDT-margined perpetual future", "timeframes": { "1hour": { "trend": "bullish", "trendStrength": "trending", "rsi": "strong", "macd": "momentum positive", "bollinger": "near the upper band" } }, "price": { "vsValue15m": "far above value (stretched)", "rsi15m": "overbought" }, "futures": { "funding": "longs pay shorts, normal rate", "move24h": "strongly up" }}
2. Ask in every option order and average. One independent study measured 88% accuracy when the right option was listed first and 57% when it was listed last (jev-behavior-study, 11,621 requests). So every money question goes out in every cyclic order at once, and code averages the answers. Questions in one call run in parallel, so this costs a few more input tokens and no extra time:
def _rotations(labels): labels = list(labels) return [labels[i:] + labels[:i] for i in range(len(labels))]# direction_0: long, short, stand_aside# direction_1: short, stand_aside, long# direction_2: stand_aside, long, short → averaged in code, spread recorded
The spread between orderings is recorded on every call, and it isn’t small:
3. State the premise; questions can’t see each other. Each question in a call is answered independently, so “which playbook?” asked next to “long or short?” is answered without knowing the direction. Every follow-up now carries its premise (“if this trade is a LONG, which playbook?”, and the same for a SHORT), and code keeps the answer for the side the direction question chose.
4. Always offer a way out. Without a “none of these” option, a classifier answers anyway; one calibration audit shows what happens when the abstain option is removed. Every question in the bot has one: stand_aside, none_fits, hold.
5. Fence off untrusted text. Fluent text in the state can steer the verdict: one benchmark found that a single appended, unverified opinion flipped 12% of Jev’s decisions (JevAdvBench). Research notes written by other programs go into one fenced field, untrustedContext, labelled as information and not instructions.
6. Pin the version, hash the wording. Every call records the model version and a hash of the code that writes the state and the questions. Wording is the biggest lever you have, so any change to it becomes a separate, measurable record, and so will the switch to Jev 1.14.
Jev also manages its own positions. Each pass, it gets a separate call about every position it holds: a Choice between hold, protect (tighten the stop), extend (move the target) and close, again asked in every order, plus a Noul: "does the market still support the reason this trade was opened?" Code executes the answer through the same tool bodies the LLM uses, and only when it clears the same confidence bar an entry needs.
All numbers below cover Sep 30 15:38 to Oct 17 14:12 UTC, both traders over the same window. Every call is scored against the futures mark price 15 minutes, 1 hour and 4 hours later, after about 0.14% of round-trip costs, and overlapping calls on the same coin count once.
Jev did everything it promised here. The median answer took 0.33 seconds (one in ten took 4 seconds or more, network included). A question set for one coin read about 4,700 input tokens, roughly $0.0002, so a full pass over 8 coins costs about a sixth of a cent. One run of the LLM agent, by comparison, reads about 325,000 tokens, close to 9 times a whole Jev pass.
The catch is the market, not the model. Where this bot has any edge, it lives at 1 to 8 hour horizons, so shaving seconds buys nothing, and a wrong call costs the same in fees whether it took 0.3 seconds or 30.
At 15 minutes and 1 hour, both traders were slightly negative after costs. At 4 hours, Luna was flat (+0.01%, t ≈ 0) and Jev lost 0.44% per call (t = −1.7), right 44% of the time. Jev made 507 scored calls, Luna 443.
Split by playbook, both traders tell the same story. Trend calls lost in a choppy market (Jev −0.76% and −0.75% per call, Luna −0.36% and −0.41%), and fading stretched moves won (Jev +0.78%, Luna +1.22%). Which kind of trade it was mattered more than which model took it. Jev also preferred trends: 63% of its calls were trend continuation.
This is the finding I didn’t expect, and the one that matters most if you plan to build on Jev’s probabilities.
On market direction, the more confident Jev was, the more often it was wrong. Calls at 0.95 or higher went the right way 32% of the time 4 hours later (−1.23% on average, before fees). Calls under 0.70 went the right way 57% of the time (+1.18%). The rank correlation between stated confidence and outcome was −0.17 (t = −2.2) over 176 independent calls. And Jev said “0.95 or more” a lot: 27% of all its calls, and 6.5% of its recent directional answers were a flat 1.00.
Luna’s confidence didn’t sort its calls either (it drifted the same way, t = −1.8), but Luna never claimed more than 0.9.
This is not a verdict on Jev’s probabilities in general. On 8,801 labelled examples, an independent test found Jev’s confidence points the right way, just overconfident, and that calibrating it on your own data fixes most of the gap (Anthus: Can You Trust Jev’s Confidence?). TypeSafe’s own guidance says the same: validate thresholds on your own data. Markets are the nasty case. There’s no label at decision time, and my best guess is that the setups that look most certain (every timeframe aligned, a strong trend, “far above value”) are the crowded ones that have already moved. WLD at 0.99 was exactly that.
What saved the money: in this bot, confidence never buys size. Size comes from the stop distance and the playbook’s measured record. On October 1 Jev said “LONG AAVE” at 0.98; its trend-long record was negative (t = −2.4 over 20 independent calls), so the stake was zero and the order was refused. AAVE was down 1.5% an hour later.
I hoped Jev would be a second opinion. When both traders called the same coin within 30 minutes, Jev picked the same side 112 times out of 117, and those shared calls went the right way 44% of the time over the next 4 hours. Two models agreeing added no confidence at all.
That matches a recent paper comparing Jev with LLM judges, which found them cheaper, faster, and wrong in the same places. Mine is the trading version: both models read the same analysis, so they made the same mistakes. A different model reading the same state isn’t diversity. Diversity has to come from different inputs or different questions.
(The 5 disagreements were all Jev long, Luna short, and Jev was right in 3. Far too few to mean anything.)
All 15 of Jev’s trades closed on an exchange stop, and none ever reached its target. The small wins are stops that code had already moved into profit; nearly every loser ran all the way to its original stop. Jev’s position check answered “hold” every time I looked (55 of 55 on its first trade, 43 of 43 in the latest log), and its record holds no early close.
A management question whose safest answer is “do nothing” isn’t management. If I ask Jev again, hold will need criteria as concrete as the others, not just "keep it as it is".
Neither number is a verdict: it was a choppy, drifting market, and 15 trades is a tiny sample.
On the morning of October 17, Jev gave 357 entry answers in 7 hours. It said “stand aside” 49 times. The shared gates refused the other 308: timeframes in conflict (124), a playbook with no measured edge (115), against the daily trend (47), below the confidence floor (15) and a few more. Zero orders.
That’s the quiet hero of the experiment, and it’s exactly what TypeSafe’s build guide recommends: Jev judged, code decided. A new model with backwards confidence and a taste for chasing traded real money for 17 days and cost the account 1.78%.
The hardest bugs had nothing to do with the model. They came from two traders sharing one notebook:
None of these crashed anything. All of them quietly turned one trader’s record into the other’s. If you add a second model to any system, every shared cap, ring buffer or derived number is a channel between two records. Decide each one per model or system-wide on purpose.
After 17 days, here’s my honest map.
Where I’d reach for Jev:
Where I’d be careful:
Jev keeps running as a small, cheap experiment. Its stake stays at zero wherever its own record shows no edge, so mostly it just records, and that record decides everything: if a Jev playbook earns t ≥ 1 over at least 20 independent calls, holds up across two different kinds of market and beats Luna over the same window, its stake grows by itself.
Three things I want to try:
The scoreboard is public, and the race is still on:
This is an experiment, not financial advice. The bot trades a deliberately tiny account, it has lost money overall, and nothing here is a recommendation to trade anything. The cover image is AI-generated; every chart comes from the bot’s own trading record.
17 Days with Jev: I Put a Sub-Second “System One” AI on a Real Trading Account was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.