Bring your own models
Plug in your API keys: OpenAI, Anthropic, or a local model, whatever you trust. XVN is model-agnostic; the brain is yours.
Open source·Built on Mantle·Trades on Orderly + Byreal
Build an AI trading agent you'd actually fund.
Most AI trading agents are just prompts and optimism. XVN is where market knowledge meets AI: turn your idea into a trading agent, test it against honest baselines, and only let the ones that actually work go live. Bring your own models and keys. Your machine, your edge.
Apache-2.0 · runs on your machine · bring your own models · trade on the exchange you want · you keep your keys · every live trade attested on Mantle
why xvn
Most AI trading bots can't prove they work.
If the strategy is weak, the agent is weak. Everyone's wiring up an AI trading bot right now, but almost none can show their edge is real. XVN does the unglamorous part for you: testing your idea against honest baselines, throwing out the flukes, and only running live what actually survived.
A clever prompt with no testing is just gambling with extra steps.
how it works
From trade idea to live agent.
One loop, end to end. Your keys, your models, your machine. Nothing handed to a platform.
01
/ 05
Build the agent
Turn your idea into a trading agent. Set how it thinks, its risk limits, and the conditions it's allowed to act on. Wire up a single agent or a multi-stage pipeline, from the dashboard or the CLI.
Prove it on paper
Run it against cached history and a paper account, scored on honest baselines. No real money until it's earned its place.
Sharpen it overnight
XVN tries hundreds of variations of your agent while you sleep, keeping only the ones that beat your original on data they've never seen.
Deploy it live
Push the winner live — on Orderly, on Byreal, wherever you trade. Want it to earn while you sleep? List it and let others run it. Every trade attested on-chain.
Test on paper. Sharpen while you sleep. Go live with what survives. Let it earn, if you want.
features
Seven moving parts.
One platform.
01
CLI-first, agent-controllable
XVN is the API. The dashboard is just a window.
Everything XVN does is scriptable. Every surface is a CLI verb (strategies, evals, deploys, the optimizer), and the whole platform is exposed over a built-in MCP server, so your own agents can drive it end to end. Click through the dashboard, automate with the CLI, or hand the keys to an agent and let it run the loop for you.
- single xvn binary
- every action a CLI verb
- MCP server built-in
- automate the automation
02
Strategy & agent evaluation
Prove the edge before you risk a cent.
Every strategy, LLM-driven or pure mechanical, runs through the same backtest and gets scored on a pre-committed metric. The anti-overfitting gate is the part that matters: nothing graduates to live unless it beats baseline across multiple market scenarios, not just the one it was tuned on.
- Δ-Sharpe
- paired A/B compare
- bootstrap CIs
- multi-scenario gate
- buy-and-hold → XGBoost baselines
03
Strategy filters
Stop paying the agent to trade noise.
Inline, deterministic filters decide whether the agent even runs on a given bar: RSI, moving averages, Bollinger, ATR, funding rates, exchange flows, portfolio state, authored from the CLI or the dashboard. Deterministic where it should be; AI only where AI earns its keep.
- filter-gated execution
- indicator + on-chain DSL
- CLI or UI authoring
- less churn, cleaner signal
04
Agent infrastructure
Your models, your agents, composed your way.
Agents are reusable templates (a prompt, a model, skills, memory) that you create, fork, and wire into multi-stage pipelines. Stage roles are free text, so a strategy can be one agent or a whole relay. Optional per-agent memory is temporally safe, so backtests never peek at future-dated observations.
- bring-your-own model
- reusable agent library
- composable pipelines
- no-lookahead memory
05
Live trading
Trade where you want, with guardrails that don't flinch.
Push it live for perps — on Orderly (Mantle) or Byreal (Solana), with more exchanges coming. You fund your own account; XVN trades it with a scoped key. A deterministic risk layer wraps every entry: size caps, exposure limits, a daily-loss circuit breaker, correlation caps, a mandatory stop, with race-free per-strategy budgets. Same risk engine, whichever exchange.
- trade on Orderly or Byreal
- your account, your keys
- scoped trading key
- deterministic risk caps
- per-strategy budgets
- full audit log
06
Built-in optimizer
Your strategies get sharper while you sleep.
Overnight, XVN tries hundreds of variations of your agent: different prompts, models, risk settings, parameters, filters, even how the agents are wired together. Each one is backtested on data it has never seen, and only the variations that beat your original are kept.
- runs while you sleep
- tested on unseen data
- keeps only what beats your original
- full history kept
07
Strategy marketplace
Optional: let a proven agent earn for you.
A strategy that survives the testing is worth something to people who don't want to build their own. If you want, list it and let others run it for a fee. Strategies are attested as ERC-8004 records on Mantle and every trade is tracked on-chain.
- earn from a proven agent
- ERC-8004 on Mantle
- every trade on-chain
- portable track record
open source
Runs on your machine.
XVN is Apache-2.0 and built to be run by you, not rented from us. A single
xvn binary with the dashboard baked in. No SaaS, no account,
no middleman holding your keys or your models. The risk engine is
deterministic Rust you can read; the eval metrics are pre-committed and
inspectable; the audit log is append-only and yours.
- Apache-2.0
- Rust workspace + React dashboard
- single-file SQLite state
- MCP server for external agents
# 1 · install — prebuilt binary, dashboard baked in
$ curl -fsSL https://xvnapp.com/install.sh | sh
# 2 · set up the local database (one time)
$ xvn init
# 3 · boot the dashboard
$ xvn dashboard serve --bind 127.0.0.1:8788
# prefer to build it yourself?
$ git clone https://github.com/latentwill/xvision
$ cd xvision && cargo build --release
→ dashboard ready at http://localhost:8788see it run
The whole loop, on screen,
against live infrastructure on Mantle.
An optimizer iteration, live
A variant goes in, gets evaluated, and a better-than-parent survivor is sealed into the lineage.
Audit-log replay
Reconstruct full position state from the append-only log alone. Nothing hidden, nothing inferred.
On-chain attestation
A sealed strategy's record and its trades, written to Mantle and readable by anyone.
Marketplace browse
Discover a proven agent, and delegate to it.
The honest footnote. XVN is early software that places real orders. Non-custodial means your funds live in your own Orderly account, not ours, but a buggy strategy or a loose risk config can absolutely lose money, and a deployed agent trades on its own. Start with small caps, keep an eye on it, and read the safety docs before you size up.
Build it. Prove it. Run it live.
XVN is open source and runs on your machine. Bring your models, point it at a paper account, and let it do the rest.