We Fed Our Trading Signals to Jev

Deploy Finance runs a live dashboard that does something simple: every time our own signal engine flags a strong trade on BTCUSDT, it also asks TypeSafe AI's new Jev model the same question: take it, or skip it? We pulled a live sample of 1,000 of those decisions this week. Jev skipped 46% of them, and on the entries we inspected, it rated quality well below the signal's starting strength.

Jev was built to make narrow calls like that one, and it made them in about a quarter of a second. The result says more about the wave of "Jev trading bot" projects that have shipped since TypeSafe launched the model on September 15, and about what has to exist around a fast AI judgment before you'd trust it with capital.

What Jev is

Jev is TypeSafe AI's first "System One model," built by former OpenAI engineer Diogo Almeida. It isn't a chatbot or a reasoning model. You send it a state (market data, text, whatever you're deciding on) plus a set of typed questions, and it returns probabilities over a fixed set of answers: a choice, a score, or a yes/no. It never generates free text, and by construction it can't return an answer outside the set you gave it.

TypeSafe's own numbers: 70–500ms latency, $0.042 per million input tokens, output free, trained with a method they call Reinforcement Learning for Calibrated Decisions. The company's framing is narrower than the hype around it: "find an expensive queue and put Jev at the front of it." It's pitched at routing, triage, classification, and scoring, where you already know the possible answers and make the same call repeatedly. TypeSafe recommends keeping frontier LLMs for reasoning and multi-step generation.

In trading terms, Jev can make one call quickly and cheaply. Deciding which calls to make, when, and with how much capital is left to whoever builds around it.

What people are building with it

Within a week of launch, madewithjev.com listed 11 builds in its trading-and-markets category, with more on GitHub outside the catalog. We looked at the ones getting attention:

Most follow one pattern: one question in, one answer out, wired straight into an order or a score. The ones that trade mostly run in dry-run or paper mode, and none of the builds we reviewed publishes a verified live track record. Jev makes the inference step fast and nearly free. Execution, position sizing, hedging, custody, and the response to a confidently wrong answer stay with the builder.

What our own dashboard showed

To measure that gap, we built jevdesk.deploy.finance. It points Jev at the same market data our own signal engine watches (BTCUSDT on Bybit perp) and logs both answers side by side, live.

The setup: our engine scores order flow with a CVD-based consensus model and fires a signal when it's confident, for example STRONG_SELL_CONFIRMATION at a consensus of -1.61. For every signal it fires, the dashboard asks Jev the same question our engine just answered: take this entry, or skip it?

In the live sample of 1,000 decisions we captured this week, Jev said skip 46% of the time, at around 270ms per call. On the skipped entries we inspected, its take-probability sat between 32% and 50%, and its "entry quality" score came in 60–96% below the signal's initial strength. In one case we looked at closely, Jev's independent 15-minute directional view agreed with our engine's call (76% probability down, matching the engine's short), and it still scored that specific entry as weak.

So in that case, direction was settled and the disagreement was about the entry. The dashboard could ask that question only because our engine had already found and timed the setup; Jev graded something it was handed. Most of the builds above ask Jev "buy or sell" with no setup attached, which leaves nothing in the loop checking whether the signal is still fresh when the order goes out.

A trading call needs a system around it

This is the gap every "Jev trading bot" build has to fill on its own, and most leave it open. A typed decision (buy, sell, hold, or a probability) is one component of a trading system. Around it you still need:

• Signal generation that recognizes a setup forming from order flow and price history.
• Entry and exit timing, because a correct direction call on a stale signal still loses money.
• Risk management: position sizing, stop placement, and a response for when the model's confidence is low or the market gaps.
• Execution that survives latency, partial fills, and a model call that doesn't come back in time.
• Custody: where the capital sits and who can move it while the strategy runs.

Jev handles one piece of that list: the call itself. The community builds we looked at either defer the rest with paper trading and small bankrolls, or write it from scratch. That second path is the slow, hard part of the problem, and the "300ms decision" headlines leave it out.

What Deploy Finance's agents run

Deploy Finance's agents are built around the rest of that list. The two live agents, Income: Funding Rates and Superstar, run on Hyperliquid from a wallet the user controls. You fund the wallet in USDC, choose an agent and allocation, and approve a scoped, revocable trading permission. The agent can open, close, and manage positions, but it cannot transfer or withdraw funds, and you can revoke its access at any time.

Income: Funding Rates is market-neutral: it holds a delta-neutral position (long the asset, short the perpetual) and collects the funding spread, with entry, hedge management, and exit handled by the agent. It has a $100 USDC minimum. Superstar is a directional agent, taking long or short positions on large-cap perpetuals under a defined strategy; it carries a $10,000 USDC minimum, and its published performance comes from a simulated backtest, not live trading history.

Both agents handle entries, exits, risk controls, and position management continuously against a defined mandate, which is the part most Jev builds leave as a to-do.

Where a model like Jev fits

TypeSafe's own positioning (routing, scoring, triage, "put it at the front of an expensive queue") describes a useful component inside a larger system. A model that returns a probability TypeSafe says is calibrated, in 270ms, for a fraction of a cent, can pre-filter signals, score qualitative inputs, or gate entries. Our dashboard uses it in that last role: as a second opinion on a signal our engine already generated and timed.

Most community builds give Jev a bigger job. "Ask Jev buy or sell, place the order" makes one judgment the whole strategy. TypeSafe's launch material pitches Jev for routing and scoring; the demos are the ones asking it to run a strategy.

Who holds the keys while the bot runs

Speed and cost comparisons skip a second question: where the money sits while the bot runs. Self-hosted bots typically sign orders with a private key or exchange API key that the bot process holds; jev-trader, for example, needs a private key to leave dry-run mode. A raw private key carries full authority over the wallet, including withdrawals. That's an acceptable setup for a paper account or a small test balance. With a $10,000 live bankroll, a bug or a leaked server credential can reach the whole wallet.

Deploy Finance's agents don't get that authority. The agent wallet belongs to the user, and the agent operates through a scoped session key that can trade on whitelisted venues but cannot transfer assets to another address or withdraw funds. Once the user revokes the key, the agent can't act at all. Self-custody doesn't remove strategy risk, funding reversal, liquidation risk, or venue risk; Hyperliquid remains the execution venue and carries its own risk regardless of who holds the keys. What the permission boundary limits is what an agent can do with the wallet: trade on approved venues, and nothing that moves funds out.

When a Jev bot is fine, and when it isn't

For testing an idea, running paper trades, or building a weekend project like most of madewithjev.com's trading category, Jev fits well: it's cheap, fast, typed, and TypeSafe is upfront about its narrow scope. The most promising builds above use it to score qualitative inputs such as sentiment, news, and Fed language, and leave the trade call to other logic.

With real capital, the question changes from "how fast can a model answer buy or sell" to "what checks whether the signal is still fresh, who manages risk when the call is wrong, and who can touch the funds while it runs." Deploy Finance's agents are built to answer those three. Income: Funding Rates and Superstar are both live on app.deploy.finance; review each agent's strategy, minimum, and risks before you allocate.