Unified Agentic Quant intelligence across Crypto, Liquidity Pools, & Tokenized assets
Arivion is an AI trading operations cockpit for active digital asset investors, quant builders, and laid back investors.
Demo video uploaded on Canva due to YouTube Errors: https://canva.link/5frep71kinkib0r
AI trading tools often stop at surface level recommendations. They can summarize markets, but they rarely connect that reasoning to live data nor test strategy logic, risk constraints, and verifiable execution assumptions.
Arivion helps users move from market research to tested strategy in one workflow. Discover opportunities, analyze live market conditions, build trading logic, run backtests, simulate portfolios, monitor positions, and prepare execution with clear evidence behind every decision.
When Arivion commits to an on chain action, it routes execution through the 1Shot permissionless relayer using EIP-7710 delegated execution on Arbitrum One and Base Mainnet.
This allows the user to execute real transactions without needing ETH for gas. The relayer fee is paid in USDC and included directly in the execution bundle and the outer transaction gas is handled by 1Shot and paid through stablecoin settlement.
Where needed, Arivion also includes an EIP-7702 authorization in the same bundle. This means a fresh EOA can be upgraded into a smart account and execute its first action in a single relayed transaction.
For task tracking, Arivion uses 1Shot webhooks as the primary status channel. A destinationUrl webhook posts updates to /webhooks/1shot, where Arivion maintains a relay-task ledger. During testing, we found and documented a server-side crash in relayer_getStatus for value-carrying 7710 tasks. Because of this, Arivion does not treat a task ID alone as proof of confirmation. Final status is based on webhook updates plus on-chain reconciliation.
Arivion successfully relayed three different execution paths through 1Shot:
Uniswap v3 LP actions
Circle CCTP cross-chain USDC flows
GMX v2 perpetual execution
The most difficult case was a GMX v2 perpetual trade using a value-carrying ExchangeRouter.multicall. It landed live on Arbitrum One.
Arivion also built its own GMX v2/1Shot adapter, turning what was previously a native relay only perp flow into a 1Shot-relayed EIP-7710 execution path.
This matters because GMX is not a simple token transfer or swap. A real GMX v2 perp order requires exact SDK-generated calldata, collateral movement, keeper execution fees, and a value-carrying ExchangeRouter.multicall. Arivion reverse engineered this flow, captured the exact GMX calldata from the SDK, wrapped it inside a scoped delegation, and successfully landed it through 1Shot on Arbitrum One.
That unlocks a much stronger class of trading agents. Instead of only recommending trades or routing basic swaps, Arivion agents can now reason about market setups, open real GMX perpetual positions, manage collateral, and execute through a permissioned relayer flow where gas is paid in USDC. For agentic trading, this is the difference between a chatbot with signals and an agent that can actually trade
Mainnet transaction: https://arbiscan.io/tx/0x772bcc83552cf3c9524fa0b2c276d27d5c7db3985e831eca5cd9c4fff54736c8
Execution result:
USDC delta: 2.0556 USDC
2.00 USDC collateral
0.0565 USDC relayer fee
ETH delta: 0.00012 ETH, This was only GMX’s intrinsic keeper fee
ETH spent on transaction gas: 0
The GMX keeper later filled the order into a real ETH/USD long position of roughly $4 size. The position was later closed successfully, with collateral returned.
Arivion uses MetaMask Smart Accounts as the core trust layer for agent execution. It's entire on-chain execution path is built on @metamask/smart-accounts-kit, end to end.
Arivion upgrades the user’s existing EOA into a Stateless7702 MetaMask smart account using EIP-7702. The account stays at the same address, so the user keeps their USDC, wallet identity, transaction history, and on-chain state. There is no wallet migration, no new account to fund, and no separate smart-wallet address to explain.
The user grants authority via ERC-7715 Advanced Permissions. Once upgraded, the user authorizes the agent through MetaMask’s native Advanced Permissions flow (wallet_grantPermissions). Arivion requests a scoped erc20-token-periodic allowance, for example, up to 5 USDC per day, with an expiry and adjustable limits and the user sees exactly what the agent may do before approving. No private key is ever shared; the user signs one scoped permission, and no USDC moves at approval time.
The agent enforces fine grained limits via EIP-7710 when it executes. Arivion never holds the user’s private key. The agent operates from its own MetaMask smart account and holds the user’s granted authority. At execution time it redelegates a narrower version of that authority to the 1Shot relayer as an EIP-7710 delegation, scoped with FunctionCall caveats, restricting execution by target contract, function selector, native-value limit, and time window.
In our flow that authority is pinned to exactly the contracts the approved action needs: USDC, Uniswap v3, GMX’s ExchangeRouter, and Circle’s CCTP TokenMessenger. The relayer can redeem only those calls, within those bounds gas paid in USDC, nothing else permitted.
Permissioned, traceable, and reversible by design. Every delegation is stored, auditable, expiring, and revocable. The user can remove the permission in MetaMask at any time, once revoked, the agent can no longer act, and Arivion’s executor refuses to run without an active grant.
This is why MetaMask Smart Accounts are not just a login layer in Arivion. They define the entire authority model of the agent, who approved the action, what the agent may do, how much it can spend, where it can execute, and when that permission expires.
Venice AI is the default reasoning engine inside Arivion’s LLM gateway. It is the model responsible for reading market briefings, screening opportunities, building strategy logic, interpreting backtests, reviewing verification results, and deciding which scoped on-chain action should be proposed to the user. When a user asks Arivion to find and act on a trading setup, Venice drives the agent loop. It emits structured tool calls that connect to Arivion’s full tool surface, including market data, strategy building, verification, DEX actions, portfolio analysis, and execution planning.
Venice fits Arivion because trading agents need a reasoning layer that can discuss markets, leverage, risk, and execution without unnecessary friction. It gives Arivion a permissionless AI brain while still working behind an OpenAI-compatible gateway, making it easy to switch on as the default provider.
Most Agents can summarize headlines, explain indicators, or suggest a trade idea, but they do not carry that idea through the full professional workflow. Arivion Copilot is different because it connects market context, opportunity discovery, strategy construction, backtesting, risk review, portfolio planning, and execution preparation inside one governed system.
Every recommendation from Arivion is designed to be backed by measurable outputs. Backtest results, paper trading performance, drawdown, risk exposure, fill assumptions, data coverage, and verification status. This makes Arivion more useful for serious traders because it does not just answer “what looks good?” It helps answer “why should I trust this setup?” Here's a multi stage flow of Arivion.
Stage 1: Real-World Market Context
Before making a recommendation, Arivion builds a live market briefing. It reads on-chain data for price movement, volume, funding, open interest, and volatility, and layers in Fear & Greed data, trusted RSS/Atom news feeds, Google News, and sentiment signals. For on-chain context it queries LP pools through The Graph (GraphQL), GMX v2 market data through public APIs, and Dune Analytics through curated query executions. This gives the agent a market-aware view before it begins screening or strategy design.
Stage 2: Discovery and Screening
The agent then screens assets across crypto, tokenized stocks, liquidity pools, and GMX markets. The screening engine evaluates momentum, trend, RSI, MACD, liquidity, realized volatility, funding, open interest, risk-adjusted return, and news sentiment. Instead of just listing “top movers,” Arivion ranks opportunities across multiple factors and explains why each asset qualifies, turning broad market noise into a structured shortlist the user can actually evaluate.
Stage 3: Backtesting and Validation
Once a setup is selected, Arivion checks data coverage through the Lab API and stores series in TimescaleDB. The Quant Worker runs validation, backtests, paper-runtime simulations, portfolio tests, LP and GMX simulations, risk checks, slippage assumptions, and fill-model analysis. If the result is meaningful, the Verifier service performs deterministic replay, compares canonical event digests, checks snapshot consistency, and produces a verification scorecard so a strategy is only promoted to execution if it survives independent re validation.
Stage 4: Execution: MetaMask Smart Accounts + 1Shot, Cross-Chain, Gas in USDC
After validation, Arivion builds a practical execution plan, allocation, venue route, entry and exit rules, stop-loss, risk caps, and the required approvals and then executes it on mainnet through the trust layer.
Authority comes from the user’s MetaMask Smart Account (the ERC-7715 Advanced-Permissions grant / EIP-7710 delegation). Execution itself rides the 1Shot Permissionless Relayer, so every transaction is an EIP-7710 redeemDelegations call with gas paid in USDC, the user never needs ETH, and never signs again after the initial grant.
A single approved plan runs as a real cross-chain sequence across Arbitrum One and Base. A real flow in the demo video:
The agent pulls the granted budget into its own smart account (redeeming the user’s permission, bounded by the period cap),
Provides single sided USDC liquidity on Uniswap v3 (Arbitrum),
Opens a small GMX v2 perp, self-funding its native keeper fee by swapping a sliver of USDC → ETH on Uniswap, so no ETH seeding is needed,
Bridges USDC to Base via Circle CCTP where the mint is self-funding (the freshly minted USDC pays its own 1Shot fee), and
Provides Uniswap v3 liquidity on Base.
Arivion's quant engine is a Python Quant Worker that handles all the heavy computation behind a strategy. It runs semantic strategy validation, vectorized backtests, parameter optimizer sweeps, paper-runtime and bot simulations, full portfolio runs, LP valuation and simulation, GMX and multiasset planning, and risk evaluation with slippage and fill-model assumptions, all backed by candle, funding, open-interest, and L2 data stored in TimescaleDB. It keeps two always-on managers, one for live paper sessions and one for multiasset paper portfolios, so positions stay marked in real time. Untrusted user strategy code is statically scanned and then executed in an isolated, resource-limited sandbox with no network or filesystem access, and meaningful results are replayed by a separate Verifier that compares canonical event digests and issues a signed verification scorecard. The outcome is that every number Arivion reports, from drawdown to fill fidelity, is measured and reproducible rather than asserted.
Core Backend Services
apps/api is the Lab API. It is an Express service on port 4000, with auth, owner scoping, strategy CRUD, paper sessions, backtests, backfill queue control, data coverage, chain/wallet/DEX routes, testnet intents, GMX guarded live routes, and stock-order routes. It also boots the BullMQ backfill worker and the tokenized-stock order engine.
apps/agent is the Copilot service on port 4500. It owns threads, messages, runs, SSE streaming, credits, LLM gateway/metering, memory, knowledge retrieval, triggers, managed paper positions, market analysis, and multiasset setup flows. It connects to MCP using the user’s owner token.
apps/mcp is the tool facade. It exposes MCP tools grouped as data, build, live, DEX, portfolio, wallets, testnet, verifier, ingestor, and sandbox tools. In Compose it runs in passthrough auth mode, meaning calls use the caller’s owner JWT rather than a shared service identity.
Workers
apps/worker is the Quant Worker. It is a FastAPI service for heavy quant computation: semantic strategy validation, backtests, optimizer runs, paper runtime, bot runs, portfolio runs, LP valuation/simulation, multiasset planning, Stocks catalog/session logic, and risk evaluation. It also runs two always-on managers: LivePaperManager for live paper sessions and LivePortfolioManager for multiasset paper sessions.
apps/data-ingestor is the market-data worker. It backfills and streams market candles, mark/index candles, funding, open interest, long/short ratios, instruments, L2 snapshots, trades, DEX pools/swaps/candles, LP positions, and live prices. On startup it launches a REST live poller, a GMX realtime WebSocket collector, optional raw WS collector, and DEX live poller.
apps/verifier is the trust/replay worker. It verifies “passports” by replaying canonical runs, comparing event digests and metrics, rejecting mismatches, and returning signed verification metadata for trusted tiers like backtest verified or live-paper verified.
apps/sandbox-runner is the untrusted-code worker. It statically scans user strategy code, blocks dangerous imports/names, then executes in an isolated subprocess with resource limits, cleared environment, blocked filesystem/network/process access, and a read-only container in Compose
There are also “workers” inside Node services: the API boots a BullMQ backfill worker in and a stock order engine for testnet tokenized- tock orders. The Agent boots a Redis trigger subscriber, position monitor, and scheduled reflection loop.
Data Architecture
Postgres/TimescaleDB is the source of data storage. It stores users, strategies, candles, funding, L2/trades, backtests, paper sessions/events/fills, optimizer runs, bots, DEX pools/swaps/candles, wallet links, testnet intents, agent threads/runs/messages, memory, knowledge vectors, credits, approvals, positions, GMX orders, and stock orders. Redis is used for BullMQ queues, token/session revocation checks, realtime pub/sub and live session updates.