# UV Labs > UV Labs builds the missing data layer for financial AI: post-training decision sequences with human feedback. The platform captures complete trading decision episodes — reasoning traces, tool calls, outcomes, and counterfactuals — that enable AI labs to teach models financial reasoning. UV also provides agent infrastructure (UV Harness) for exchanges and brokerages to deploy autonomous trading agents at scale. Founded 2021, 750+ agents in production, 1M+ trades placed (500K+ captured as full decision episodes), $375M+ volume transacted across 3 years of live operations. Contact: bebis@uvlabs.ai | X: @uv | Telegram: @jbcrypto95 | https://calendly.com/bebis This file contains the complete text content of https://uvlabs.ai/, converted to Markdown for AI consumption. --- ## Homepage (https://uvlabs.ai/) ### Toward Autonomous Markets We run 750+ trading agents with real capital — and build the decision data and infrastructure that let AI models operate markets safely. Every year, thousands of extraordinary minds enter finance instead of curing disease, solving energy, or exploring space. We teach AI to run capital markets so humans don't have to. ### AI can talk about money. It can't safely use it. Frontier models can talk about finance but can't safely operate. We build the infrastructure that bridges that gap. **Decision Data** — AI labs have price data, news data, and market data. What they don't have is decision data. We generate RL trajectories with real traders in the loop and real capital on the line. Tool use, constraint navigation, decisions, and outcomes, all sourced from a production trading environment. **Agent Infrastructure** — Real trading infrastructure is tuned for years in live markets. LLMs don't change that. Financial agents need to process large, continuous, and diverse information streams. Our inference engine orchestrates dozens of models to reduce cost by 99% while preserving frontier performance. **Trust Layer** — The starting line for financial agents is perfect reliability. The rest is trust-building. Every product that touches money will eventually need embedded AI. We provide the policy engine, compliance tooling, and audit trails to accelerate toward this outcome. Stats: 750+ agents in production | $375M+ volume transacted | 3 years live operations ### What running 750+ agents taught us We started building agentic finance before the term existed. Three years of live operations, real capital, and multiple market regimes produced a set of convictions about what this technology actually requires. **01 Compounding — Every trade tunes the next one.** Over a million placed trades — 500K+ of them captured as full decision episodes — each one shaping how we tune the Harness and structure every trajectory. The agents running today are products of every decision that came before them. **02 Transparency — You can't accelerate time in production.** Reliability is a Lindy effect. So is the feedback loop between agents and the humans who deploy them. Our agents have won their trust across 3 years of live market operation and billions of tokens processed. **03 Signal over noise — Economics matter as much as intelligence.** Inference cost comes straight out of PnL. Our agents accomplish with $1 of compute what costs ~$100 with naive per-event frontier inference. At scale, that difference is the entire margin. **04 Conviction — Financial AI is inevitable.** Coding agents went from novelty to necessity overnight. Financial agents are next. Our mission is to accelerate toward a world where capital can allocate itself. > When machines took over farming, humanity built civilization. When machines learn to allocate capital, we build everything else. ### Build with us. Work with our team to deploy and train frontier financial agents. **For Financial Platforms** — Put policy-governed trading agents in front of your users. UV Harness — our hosted agent infrastructure — gives your users autonomous agents battle-tested across three years of live market operation. (https://uvlabs.ai/harness/) **For Research Labs** — Complete decision episodes for post-training. Access the decision data frontier models are missing. Complete trading episodes with reasoning traces, tool calls, and verified outcomes. (https://uvlabs.ai/research/) Schedule a conversation: https://calendly.com/bebis | bebis@uvlabs.ai --- ## Decision Data (https://uvlabs.ai/research/) Post-Training Data & Environments ### Decision data for financial AI. Every other financial dataset captures what happened. Ours captures the reasoning behind every decision, the outcome that followed, and what should have happened instead. Stats: 500K+ decision episodes — from 1M+ live trades | Full traces: reasoning, actions & outcomes, intent to outcome | 3 years live collection > Other datasets record what happened. Ours records why — and what should have happened instead. ### Example episode (illustrative schema — episodes span crypto and equities venues) ```json { "symbol": "NVDA", "direction": "long", "market_context": { "regime": "low_vol", "rsi_4h": 58.2, "atr_pct": 0.024, "spread_bps": 1.2, "imbalance_ratio": 0.63, "volatility_regime": "compressing" }, "social_sentiment": { "avg_score": 0.23, "distribution": { "bullish": 20, "bearish": 2, "neutral": 27 }, "top_signal": "Institutional accumulation flagged by 3 accounts" }, "agent_reasoning": { "explicit_reasoning": "NVDA consolidating above 200d MA post-earnings. Vol compressing, order book imbalance at 0.63, and 3 accounts flagging institutional accumulation. Entering long with stop below the consolidation range.", "decision_confidence": 0.84, "tool_calls": [{ "name": "fetch_technicals", "args": { "symbol": "NVDA", "tf": "4h" }, "result": "Above 200d MA. RSI 58, ATR contracting." }] }, "trade_execution": { "entry_price": 131.42, "position_size_usd": 24800, "stop_loss": 126.50, "take_profits": [138.00, 142.50] }, "position_journey": [ { "at": "1h", "pnl": 0.31, "mfe": 0.44, "mae": -0.12 }, { "at": "4h", "pnl": 1.12, "mfe": 1.38, "mae": -0.12 }, { "at": "24h", "pnl": 2.89, "mfe": 3.41, "mae": -0.54 }, { "at": "48h", "pnl": 4.72, "mfe": 6.31, "mae": -0.54 } ], "outcome": { "result": "win", "exit_price": 137.62, "realized_pnl_percent": 4.72, "hold_duration_minutes": 2847, "timing_score": 0.91, "sharpe_contribution": 0.34 }, "counterfactuals": [{ "mfe_pnl_percent": 6.31, "optimal_pnl_percent": 8.43, "trailing_stop_pnl": 5.88, "timing_score": 0.74, "held_too_long": false, "exited_too_early": true }] } ``` ### RL Environment: Three ways to train The Python SDK is in preview and Gym-compatible. - **uvlabs.download()** — Complete episodes as state-action-reward tuples for offline training. - **uvlabs.replay()** — Run your policy against historical decisions and measure counterfactual outcomes. - **uvlabs.connect()** — Generate on-policy trajectories in live or simulated markets. These episodes come out of the same production Harness platforms run in live markets — the flywheel that keeps the corpus growing. ### Custom Trajectories Specify the market, conditions, and strategy type. We deploy real traders to generate complete decision sequences with full reasoning traces, on demand. Any asset class. Custom schemas. On-demand generation. Full reasoning traces. ### FAQ **Can you customize the schema for our use case?** Yes. Schemas, observation spaces, reward functions, instrument coverage, all configurable. If you need fields that don't exist yet, we build them with you. **What format is the data in?** Structured JSON, delivered via streaming API or batch export. Each episode contains market state, reasoning trace, action, and outcome. Plugs into standard ML pipelines out of the box. **How do you handle lookahead bias?** Every state snapshot is strictly point-in-time: only information available at decision time. Outcomes and counterfactuals are computed after the fact and stored separately. **What's the reward signal?** Episodes include realized P&L, risk-adjusted metrics (Sharpe, Sortino, max drawdown), timing efficiency, and counterfactual comparisons. Most teams will want custom reward shaping on top of that (multi-objective, exposure-weighted, regime-conditional) and we support all of it. **Do you support online and on-policy RL?** Yes. Offline datasets, episode replay for counterfactual evaluation, and live environments for on-policy trajectory generation. The SDK is Gym-compatible with configurable observation and action spaces. **Can you scale to our data requirements?** 750+ agents generate episodes continuously across multiple market regimes. Generation scales to match your pipeline throughput, and you can prioritize specific asset classes or decision types. **How does a pilot work?** You tell us what you're training and we scope the engagement: asset classes, episode volume, schema, and delivery format. Most pilots are live within a few weeks. ### Run a pilot. Tell us what you're training and we'll scope the data, schema, and environment around your research. Pricing is scoped per engagement — you'll get a number on the first call. University and academic researchers — ask about discounted access. Schedule a call: https://calendly.com/bebis --- ## UV Harness (https://uvlabs.ai/harness/) For Exchanges, Brokerages & Wallets ### UV Harness. Agent infrastructure, ready to ship. Build frontier financial agents in days, not quarters. Battle-tested orchestration, execution, and policy enforcement. Stats: 99% compute reduction | 750+ agents in production | $375M+ volume transacted | 3 years live production > The Harness runs production trading for hundreds of live users today — five years of engineering, three of them in live markets. The same system, hosted for your platform. ### The Stack: What's inside the Harness. Four systems your agents run on. Each one is battle-tested independently. Together they're the full operating environment. **Agent Orchestration** — The right model for every task. Inference fires only when it matters. Routes each subtask to the right model: frontier for reasoning, fast and cheap for classification. Event-driven inference means agents only think when something meaningful happens. At 10K users, polling-based agents are economically impossible. Event-driven inference is what makes per-user agents viable. **Policy Engine** — Every decision hits your rules before anything executes. Position limits, drawdown controls, exposure caps, restricted assets — globally or per-user. Violations get blocked before execution, and the reasoning trace records what happened and why. **Execution Infrastructure** — Built-in execution across dozens of venues. Customize your environment in a single config. Agents optimize execution based on your team's configuration: smart order routing, cross-chain settlement, and slippage optimization come built in. Scope the environment to a single venue or open it up to everything. Agents handle the rest. **Market Intelligence** — Financial context out of the box. Custom integrations only if you want them. Price feeds, funding rates, and sentiment in one tool layer covering crypto, equities, and prediction markets. Agents can operate without any extra integrations, and custom data sources drop in through the plugin layer. ### Example (Python SDK) ```python import uv # Connect to your harness instance harness = uv.Harness(api_key="uv_sk_...") harness.add_plugin("sentiment_scanner", handler=my_scanner) # Global policy — enforced on every agent on your platform harness.add_policy("max_leverage", ratio=3.0) # Spin up an agent for a user account # Each subtask dispatched to the right model agent = harness.create_agent( account="user_abc123", models=["sonnet", "haiku", "frontier-mini"], signals=["imbalance_shift", "vol_regime_change"], tools=["place_order", "manage_position"], plugins=["sentiment_scanner"], ) # Account-level policies — scoped to this user only agent.add_policy("max_position", usd=25_000) agent.add_policy("drawdown_stop", pct=-0.05) agent.deploy() ``` ### Integration: Start in days. Configure your agent environment with plugins and policies, then integrate into your platform with a widget or API key. - **Widget** — Drop agent UI into your app. Your users interact with agents inside your platform, under your brand. - **API / SDK** — Create agents, push policies, manage user accounts programmatically. Build exactly the experience your platform needs. - **Co-Build** — Our engineering staff works closely alongside your team to design and ship a world-class agent experience: custom environments, bespoke policies, and full compliance sign-off before you go live. ### Build or buy? Ship agents next month, not next year. | | UV Harness | In-House | |---|---|---| | Time to Launch | Days – weeks | 6–12 months | | Engineering Cost | Included | $350K+ / year | | Inference Cost per 1K Signals | ~$0.12 | ~$24.00 | | Production Track Record | 3 yrs · 1M+ trades | Unproven | Engineering cost assumes a 2–3 person in-house agent team. Inference comparison assumes per-event frontier-model calls vs. event-driven routing; methodology on request. ### FAQ Every trade the Harness executes can become a decision episode — the data layer labs train on (https://uvlabs.ai/research/). **How does this get past our risk committee?** The policy engine enforces your risk framework on every decision before anything executes: position limits, exposure caps, restricted assets. The controller system provides full audit trails for every action, including the reasoning behind it. Built to support regulatory requirements out of the box with minimal changes to the core system. **What happens when a user's agent does something dumb?** It gets blocked before execution. The reasoning trace logs what happened and why it was stopped. The user gets a clear explanation. No action that violates your rules ever reaches an exchange. **How does this scale to thousands of retail users?** Our agents run on a proprietary trading engine designed for platform scale. We currently run 750+ agents concurrently; the architecture shards horizontally per account, so platform-scale deployments are a capacity-planning exercise, not a rewrite. Event-driven inference means agents only consume compute when something meaningful happens, not on a polling loop. **Can users chat with their agents?** Yes. They can ask why it made a decision, what it's watching, or tell it to adjust. The agent responds with its actual reasoning, not a canned answer. Users can understand what's happening and steer it. **What models does it support?** Any of them. OpenAI, Anthropic, Mistral, Llama, your own fine-tunes. We route tasks to models, not sell them. Swap providers anytime without changing your integration. **How fast can we go live?** Self-serve: agents in a staging environment the same day. Custom deployment: our team embeds with yours — working pilot on one user segment within the first month, full rollout within 90 days. Not a 6-month integration. ### Ship agents on your platform. 3 years production · 750+ agents · $375M+ volume. Tell us about your platform and we'll show you what the integration looks like. Engagements are scoped per platform — co-build engineering is included. 30-minute call. We'll tell you if the Harness is a fit. https://calendly.com/bebis --- ## Integration Guide / Docs (https://uvlabs.ai/docs/) UV Harness Integration Guide. Sections: The Stack, Case Study, Integration, API Reference, Pricing. ### 01 / The Stack — Why the Harness Exists Markets move at the same speed whether you're writing every line of code by hand or using AGI. Building production-grade agent infrastructure from scratch takes 6–12 months and $350K+ in annual engineering cost. That only gets you to day one. The real cost is what comes after. Years of live-market iteration that no amount of engineering talent fast-forwards. How does your agent behave during a liquidation cascade? What happens to your margin when inference costs spike? UV Harness encodes the answers we learned running 750+ agents through real markets. Stats: 750+ agents in production | $375M+ volume transacted | 99% compute reduction | 3 yrs live production **Four systems** — The Harness is four battle-tested systems that run together as a complete agent operating environment. Each one was built and refined independently in production over years. - **Agent Orchestration**: Routes subtasks to the right model (frontier for reasoning, cheap for classification). Event-driven: inference fires only when something meaningful happens. 99% compute reduction vs. polling-based agents. - **Policy Engine**: Position limits, drawdown controls, exposure caps, restricted assets. Enforced globally or per-user, before execution. Full reasoning traces for audit and regulatory review. - **Execution Infrastructure**: Smart order routing across dozens of venues. Real-time slippage optimization, cross-chain settlement. Scope to one exchange or open to everything. - **Market Intelligence**: Price feeds, funding rates, on-chain activity, sentiment. Covers crypto, equities, and prediction markets. No custom data integrations required. **Build vs. buy** | | UV Harness | In-House | |---|---|---| | Time to Launch | Days – weeks | 6–12 months | | Engineering Cost | Included | $350K+ / year | | Inference Waste | <1% | ~99% | | Production Track Record | 3 yrs · 1M+ trades | Unproven | ### 02 / Case Study — Cod3x: Proof at Scale Cod3x is our own production deployment, and the proof that this stack works with real users and real capital. We built the first version of this infrastructure in 2022, before "agents" were a product category. Over three years and multiple market regimes, our users deployed 750+ agents that have traded nearly $400M in volume. Every component of the Harness was battle-tested within Cod3x through years of rapid iteration. **Engagement proves the thesis.** The strongest signal from Cod3x is behavior. Users who try our agents become better customers: 84% engagement rate | 22 min avg session | 55%+ returning users | $900+ ARPU | ~$2,000 estimated LTV | 46% gross margin **What we learned from user behavior:** - Users stuck around. With no token incentives, and at roughly $100 per month in fees, we experienced lower churn rates than typical perps platforms. - Newer traders stayed in the game. They kept within their risk policies and kept trading: frictionless monitoring and risk management gave them time to improve their skills while their agents managed expectations. - People had fun. Users compared agent setups, talked about what their agent did overnight, and got excited about the process instead of the outcome. **Why this matters for your platform.** Every exchange, brokerage, and perps platform is competing for the same pool of active traders. The platforms that win are the ones where users can do more. The next wave is agents that watch markets, manage risk, and execute inside your product. In AI, you're either early or late. Coding agents went from novelty to necessity in under a year; financial agents will become a mission-critical feature faster than we think. The compounding advantage: 500K+ decision episodes, 9B+ tokens processed, over a million trades. Every one made the next agent better. That history can't be replicated, and can only be accessed through the Harness. ### 03 / Integration — Working Together Early Harness engagements are high-touch by design. Our engineers work alongside yours to build, test, and ship your agent integration. This is not a self-serve product yet. Every early engagement follows a co-build model: - **Phase 1 — Scope**: Map workflows, data sources, and venue coverage. Identify compliance constraints. Define where agents add the most value. - **Phase 2 — Build**: We work closely with your team throughout. Configure agents, risk policies, execution venues. Stand up monitoring and audit infrastructure. - **Phase 3 — Evolve**: Pilot with a focused user segment. Expand to new strategies, assets, or tiers. The Harness grows with you. **What we build for you:** - Agent environment: model selection, inference triggers, tool configuration, and execution routing scoped to your platform's specific needs - Policy framework: global and per-user risk rules, position limits, drawdown controls, exposure caps, and restricted asset lists mapped to your compliance requirements - Monitoring & audit: full reasoning traces for every agent action, real-time dashboards, and audit trails built for regulatory review - User-facing integration: agent UI as a widget in your app, or programmatic access via API/SDK. Your brand, your interface **Integration modes:** Co-Build (full partnership), API (programmatic control over agents, policies, accounts, and telemetry), Widget (drop-in agent UI — coming soon), SDK (native client libraries — coming soon). Model providers: all of them. OpenAI, Anthropic, Mistral, Llama, your own fine-tunes. We route tasks to models, not sell them. Swap providers anytime without changing your integration. ### 04 / API Reference The Harness API is a RESTful service with real-time streaming support. It covers the full agent lifecycle: provisioning, policies, execution, and telemetry. Base URL: https://api.uvlabs.ai/v1/ **Authentication** — All requests authenticate via a platform-scoped API key in the Authorization header (`Authorization: Bearer uv_sk_...`). Keys are issued during onboarding and support rotation, IP allowlisting, and permission scoping. All responses follow a standard envelope: `{ "success": true, "data": { ... }, "message": "optional context" }`. **Agents** — Create, configure, and manage agent instances scoped to user accounts on your platform. ``` POST /v1/agents # Create agent for a user account GET /v1/agents # List agents (filterable by account) GET /v1/agents/{id} # Get agent config + status PUT /v1/agents/{id} # Update models, signals, tools POST /v1/agents/{id}/deploy # Deploy to live POST /v1/agents/{id}/stop # Graceful stop DELETE /v1/agents/{id} # Teardown ``` Agents are event-driven. They consume compute only when a registered signal fires, not on a polling loop. Model routing is automatic: frontier models handle reasoning, smaller models handle classification and data extraction. (Python SDK — preview, in development.) **Policies** — Risk rules enforced before any action reaches an exchange. Policies can be scoped globally (all agents) or per-account. ``` POST /v1/policies # Create policy GET /v1/policies # List policies PUT /v1/policies/{id} # Update policy DELETE /v1/policies/{id} # Remove policy POST /v1/policies/{id}/rules # Add rule to policy POST /v1/policies/evaluate # Dry-run evaluation ``` Supported rule types: position limits (max size per asset, per account, or globally), drawdown controls (stop agents at a configured loss threshold), exposure caps (total notional exposure limits), restricted assets (whitelist or blacklist tradable instruments), approval flows (flag actions for human review before execution). Each rule returns one of four actions: Allow, Block, RequireApproval, or RequireMFA. Rules are evaluated in priority order; the first match wins. Every evaluation is logged to the audit trail. Policies are part of the environment: during the integration phase, we build custom rule types for your platform's specific compliance and risk requirements. If your framework needs something we don't support yet, we add it. **Execution** — Unified execution layer across CEX and DEX venues. The API abstracts venue-specific order formats, authentication, and settlement behind a single interface. ``` POST /v1/orders # Place order (market, limit, stop) DELETE /v1/orders/{id} # Cancel order GET /v1/orders # Open orders GET /v1/positions # Open positions POST /v1/positions/{id}/close # Close position GET /v1/venues # Configured venues + status GET /v1/market/ticker/{sym} # Ticker GET /v1/market/book/{sym} # Order book snapshot ``` Supported order types: market, limit, stop_loss, take_profit, trailing_stop, bracket (entry + stop + take-profit). Smart order routing splits across venues when configured. Slippage budgets are enforced per-venue in real time. The Harness supports a wide range of CEXs, DEXs, on-chain perp protocols, prediction markets, and traditional brokerages. Cross-chain operations are supported via bridge aggregation and Circle CCTP. Venues are part of the environment: during the integration phase, we configure the exact set of venues, asset classes, and routing rules your platform needs. If you trade on a venue we don't support yet, we add it. **Telemetry** — Every agent action produces a structured trace. Available via polling or real-time streaming. ``` GET /v1/agents/{id}/traces # Reasoning traces GET /v1/agents/{id}/audit # Audit log GET /v1/agents/{id}/metrics # Performance metrics GET /v1/portfolio # Aggregate portfolio GET /v1/portfolio/pnl # P&L breakdown WSS /v1/stream # Subscribe to events (WebSocket) ``` Streaming event types: agent.inference (reasoning step completed), order.created / order.filled / order.cancelled, policy.triggered (rule blocked or flagged an action), position.updated (P&L, size, or margin change). **Custody & Key Management** — The Harness is custody-agnostic. Teams bring their own key management, or we provide wallet infrastructure. The architecture adapts to your trust model. - **Exchange Sub-Accounts (CEX)**: Broker master creates scoped sub-accounts per user. API keys control trade, transfer, read independently. Harness manages key lifecycle and execution. - **Linked Signers (DEX)**: User's master wallet authorizes agent keypair (EIP-712). Agent can trade but not withdraw. Standard for on-chain perp DEXs. - **MPC Wallets (Institutional)**: Threshold signing across distributed key shares. Policy engine enforces quorums and spending limits. Transaction initiation via provider API. - **Qualified Custodians (Regulated)**: HSM key storage, multi-factor approval flows. Structured audit trails for regulatory review. For fiduciary and compliance requirements. - **Smart Accounts (On-Chain)**: ERC-4337 / EIP-7702 session key delegation. Protocol-level constraints: contracts, sizes, tokens. Instant revocation, gas sponsorship via Paymasters. - **Moon Vault (Provided)**: Server-side key gen, encrypted at rest. Multi-chain: EVM, Solana, Bitcoin, Cosmos. Private keys never exposed to application code. User flows are flexible. Some teams want smart accounts with session keys. Others use delegated API access through exchange sub-accounts. Exchanges have their own sub-account systems. The custody layer is engineered around your platform's needs during the integration phase. ### 05 / Pricing Model Structured to align our incentives with yours: we succeed when your agents are active and performing. We are currently only taking co-build clients. Every engagement starts with a direct relationship between our teams. Self-serve access is on the roadmap. **Integration** — Every engagement begins with a 4–8 week build and testing period. Our engineering team works directly with yours to configure the environment, implement policies, wire venues, and run a controlled pilot. A one-time integration fee covers scoping, environment build, policy implementation, venue configuration, and pilot support. Pricing is scoped per engagement based on complexity. **Ongoing** — Once live, you pay a monthly infrastructure license that covers the full stack: orchestration, policy enforcement, execution, monitoring, and support. Pricing scales with your deployment scope (number of agents, assets monitored, venues connected) and is scoped during the integration phase. Our event-driven architecture keeps per-agent economics low at any scale. Agents consume compute only when meaningful signals fire, not on polling loops, so your costs grow with actual activity rather than idle infrastructure. Ready to build? 30-minute call: https://calendly.com/bebis | bebis@uvlabs.ai --- ## Agentic Trading (https://uvlabs.ai/agentic-trading/) Field Guide ### Agentic trading. When the intelligence in a trading system moves from the human who wrote the rules into the machine that makes the call. **Definition:** Agentic trading is autonomous AI agents that reason about markets, make the call, and execute it end to end — not signals for a human to trade, but the whole decision, made by the machine. ### What makes trading agentic. For decades, market software did what it was told: a rule fired, an order went out. The intelligence lived in the human who wrote the rule. Agentic trading moves it into the system — an agent that reads the market, reasons through the situation, and acts, with no answer specified in advance. Four properties separate an agent from the software that came before it: 1. **It reasons, it doesn't just predict.** A quant model outputs a number — a probability, a signal. An agent works the whole situation: what's happening, why, the options, the risks, the plan. 2. **It decides under open-endedness.** Rules only cover what their author foresaw. An agent has to act when the situation is novel or contradictory — which, in live markets, is most of the time. 3. **It executes end to end.** No recommendation handed to a human. The agent sizes the position, sets risk, times the entry, manages the trade, and exits — decision and action in one loop. 4. **It adapts.** Edges decay the moment they're found. An agent shifts with the market instead of running a fixed strategy until it breaks. **The core distinction:** Algorithmic and quant systems run logic a human authored in advance. Agentic trading systems generate the decision themselves, at runtime, in situations no one scripted. That shift, from executing rules to making judgments, is what "agentic" means. ### Agentic vs. algorithmic vs. quant. Not competitors, but layers, each adding autonomy on top of the last. | Dimension | Algorithmic | Quantitative | Agentic | |---|---|---|---| | Core engine | Pre-programmed rules | Statistical / ML models | Reasoning AI agents | | Output | Order execution | Predictions and signals | End-to-end decisions and actions | | Handles novelty | No, only scripted cases | Within the model's distribution | Yes, reasons about new situations | | Who makes the call | The human who wrote the rule | The model, then often a human | The agent itself | | Adapts at runtime | No | Retrained periodically | Yes, adjusts as conditions change | A useful way to hold it: algorithmic trading automates execution, quantitative trading automates prediction, and agentic trading automates judgment. Each is harder than the last, and judgment is the one frontier models have not yet been taught to do safely with money. ### Why it's hard for today's models. Frontier large language models can talk about finance fluently. Ask one to explain a basis trade or critique a portfolio and it will perform well. But talking about markets and operating in them are different skills, and models are trained for the first, not the second. The gap is data. Models learn finance from text: filings, news, textbooks, transcripts. None of that captures how a real decision is actually made: the live reasoning, the alternatives weighed and rejected, the sizing logic, the exit plan, and how it all turned out. That record, the decision episode, is exactly what is missing from the public internet, and exactly what agentic trading requires. Finance also breaks the standard training playbook in ways chatbots do not. Rewards are delayed: a trade may not resolve for weeks. Good decisions lose money to variance and bad ones profit from luck, so outcomes alone are a noisy teacher. The environment is adversarial. And expert feedback is scarce and expensive. These are not reasons agentic trading is impossible; they are the reasons it needs purpose-built training data rather than more scraped text. ### What an agentic trader has to learn. Building a reliable agentic trader is a post-training problem. The model has the language and world knowledge; what it lacks is decision-making competence in markets. Teaching that requires a specific kind of data: - **Complete decision episodes.** Not "bought, then sold, made 4%," but the full context, reasoning, action, and outcome of each decision, captured from a live trading environment. - **Reasoning traces.** The step-by-step analysis behind a decision, so the model learns sound process, not just lucky results. Process supervision rewards each correct step, which separates skill from variance better than judging the final P&L. - **Counterfactuals.** What would have happened with different sizing, timing, or stops. Replaying each decision point under alternatives turns one trade into many training examples. - **Human feedback from experts.** Evaluations of whether each step of the reasoning was sound, from people who can actually judge a trading decision, not generalist labelers. **Where UV Labs fits:** UV Labs generates this data as a byproduct of running real agents: reinforcement-learning trajectories from live traders operating real capital, captured as complete decision episodes. It is the post-training data that teaches a model to act in markets, not just describe them. Stats: 3 years live production | $375M+ volume transacted | 750+ agents in production | 9B+ tokens of financial context ### FAQ **What is agentic trading?** Agentic trading is the use of autonomous AI agents that reason about markets, make decisions, and execute trades end to end, rather than producing signals for a human to act on. The system perceives market state, forms a thesis, sizes and times positions, manages risk, and adapts as conditions change. **How is agentic trading different from algorithmic trading?** Algorithmic trading executes fixed, pre-programmed rules. Agentic trading uses AI agents that reason about open-ended situations and decide what to do when no rule applies. Algorithmic systems follow logic a human wrote in advance; agentic systems generate the decision themselves at runtime. **How is agentic trading different from quantitative trading?** Quantitative trading uses statistical and machine-learning models to predict prices or generate signals. Agentic trading goes further: the agent reasons through the full decision, including thesis, sizing, timing, risk, and adaptation, and carries it out, rather than just predicting. **Can large language models do agentic trading?** Frontier LLMs are trained on text about markets, not on records of decisions made in them — so they describe strategy well but have no training signal for operating capital. They lack the post-training data that captures how real trading decisions are made and how they turn out. Reliable agentic trading requires teaching models on complete decision episodes, with reasoning traces, tool calls, outcomes, and counterfactuals from live markets. **What data does an agentic trading system need to be trained?** Price, news, and market data are not enough. Agentic trading models need decision data: complete episodes that capture market context, the agent's reasoning, the action taken, the outcome, and what would have happened under different choices, paired with human feedback. --- ## HyperLLM (https://uvlabs.ai/hyperliquid/) In Development ### Built for Hyperliquid. HyperLLM is trained on what generic models ignore: funding rates, liquidation math, fee tiers, and the execution mechanics that determine what a trade actually costs. HyperLLM is built by UV Labs. It is an independent product and is not affiliated with or endorsed by Hyperliquid. ### What it knows. 1. **Funding Rates** — Funding can exceed 200% APR on crowded trades. The model tracks real-time rates, flags expensive holds, and factors funding into entry/exit timing. 2. **Liquidation Math** — Computes exact liquidation prices for cross and isolated margin. Accounts for unrealized PnL, open orders, and position adjustments, and models ADL exposure so the risk is visible in every decision. 3. **Fee Optimization** — Taker fees are 3x maker fees (0.045% vs 0.015%, as of mid-2026). The model picks order types to minimize costs: when ALO makes sense for rebates, when paying taker is worth it. 4. **Queue Priority** — Cancels process before fills. Liquidity disappears when you need it most. The model understands FIFO queue dynamics and when cancel/replace costs you your spot. 5. **Exit Execution** — Stop-market orders slip badly in thin books. The model structures TP/SL correctly: trigger distances, limit vs market, partial exits to avoid walking the book. 6. **API Integration** — Correct endpoint selection, proper rate limiting, WebSocket subscriptions. Handles the nuances of HL's API that trip up most trading bots. 7. **HLP Vault Dynamics** — HLP takes the other side when the book is thin. The model understands when the vault is your counterparty, how liquidations flow into HLP, and what that means for fills. 8. **Cross-Margin Portfolio** — Unrealized PnL on one position affects margin for others. The model tracks portfolio-level risk: how a winner funds a loser, when correlation kills you, total liquidation price. 9. **HIP-3 Markets** — Works on any perps built on Hyperliquid. Native markets, Trade.xyz, and future HIP-3 deployments all share the same mechanics. One model, every venue. ### Mechanics are the silent tax. Funding, fees, fills, and liquidations are deterministic. HyperLLM models them so your agent's decisions account for them. It is trained on UV's decision-episode corpus — three years of live trading data on perp-DEX mechanics. HyperLLM is in active development. Reach out for early access, or to feed real trading decisions into its training: bebis@uvlabs.ai. Start trading: https://cod3x.org --- ## About (https://uvlabs.ai/about/) ### We teach AI to run capital markets. We build what financial AI is missing: decision data that teaches models to act in markets, not just talk about them. ### The mission. Every year, thousands of extraordinary minds enter finance instead of curing disease, solving energy, or exploring space. That's a civilizational misallocation of talent. We're building AI that can operate in markets safely and at scale — so running capital becomes the machine's job, and that talent goes to harder problems. > We teach AI to run capital markets so humans don't have to. ### The data frontier models are missing. Price data + news data + market data → decision data. AI labs have no shortage of market data. What they don't have is decision data: the complete record of how a financial decision is made and how it turns out. We generate it from a live trading environment — real traders, real capital — as complete decision episodes: reasoning traces, tool calls, outcomes, counterfactuals. The data that teaches a model to operate, not just describe. Stats: 3 years live production | $375M+ volume transacted | 750+ agents in production | 9B+ tokens of financial context ### Built in live markets. We were building agentic finance before the term existed — three years of live operations across market regimes, real capital and real constraints. It taught us what this actually takes. UV Labs is a US company. We own the platform end to end — the trading engine, the Harness, and the data pipeline. Everything we ship follows one rule: it has to survive contact with a real market. ### The team: traders, researchers, engineers. Senior operators across trading, ML research, and infrastructure — betting that financial AI is a data problem before it's a model problem. - **Justin Bebis — CEO.** 5 years managing billions in AUM. One exit. Operations, risk, and research. X: https://x.com/0xbebis_ - **Sean Kramer — COO.** Former #1-ranked pro gamer. 4 years overseeing $25M in sales. Product, revenue, and growth. - **Camrin Peacock — CTO.** 10+ years in AI and mechatronics. Former CSIRO research engineer. Leads R&D and platform. - **Elliot Whalan — Principal Engineer.** Generative-audio pioneer. Staff engineer at Replica and Splash. Full-stack infrastructure. - **Brandon Swords — CFO.** 5 years in fintech and crypto compliance. Legal, finance, and people. - **Steven — Customer Success.** Musician turned founder turned trader. Social, product, and customer success. AI lab, institution, or partner — if you're working on financial AI, let's talk: https://calendly.com/bebis --- ## Glossary (https://uvlabs.ai/glossary/) Financial AI Glossary: Key Terms Explained. Essential definitions for researchers, engineers, and traders working at the intersection of artificial intelligence and financial markets. 47 terms across three categories. ### AI Training Methods (16 terms) - **RLHF (Reinforcement Learning from Human Feedback)** — Teaching AI to behave as humans prefer by learning from human ratings. - **DPO (Direct Preference Optimization)** — A simpler alternative to RLHF that skips the reward model. - **Process Supervision** — Judging each step of AI reasoning, not just the final answer. - **Outcome Supervision** — Judging AI only by the final result, ignoring how it got there. - **Fine-Tuning** — Adapting a pre-trained AI model for a specific task or domain. - **Imitation Learning** — Training AI by watching expert demonstrations instead of trial-and-error. - **Offline vs Online RL** — Learning from recorded data vs learning by interacting with the environment. - **Overfitting** — When a model memorizes training data instead of learning generalizable patterns. - **Reward Hacking** — When AI finds unintended shortcuts to maximize rewards. - **Transformer** — The architecture behind ChatGPT, Claude, and every modern LLM. - **Hallucination** — When AI confidently makes things up that aren't true. - **Temperature** — A knob that controls how creative vs predictable AI responses are. - **Inference** — When a trained AI actually generates predictions or outputs. - **RL Environment** — A simulation where AI agents learn by taking actions and observing rewards. - **Eval Suite** — A standardized set of tests to measure an AI model's performance. - **Model Hosting** — Infrastructure that runs AI models and serves predictions at scale. ### Data Concepts (14 terms) - **Agentic Trading** — AI agents that reason, decide, and execute trades end to end, not just generate signals. - **Decision Episode** — A complete record of a trading decision: context, reasoning, action, and outcome. (A UV Labs decision episode contains 62 fields across 6 categories: Market Context, Agent Reasoning, Trade Execution, Position Journey, Outcomes, and Counterfactuals.) - **Reasoning Trace** — A step-by-step record of how a decision was made. - **Post-Training Data** — Specialized data used to teach pre-trained models specific skills. - **Counterfactual Learning** — Learning from "what would have happened if..." scenarios. - **Replayable Environment** — A market simulation that can reset to any historical point. - **Chain of Thought (CoT)** — Getting AI to show its reasoning step-by-step. - **Distributional Shift** — When real-world data differs from what the model was trained on. - **Backtesting** — Testing a strategy on historical data to see how it would have performed. - **Embedding (Vector)** — Converting words, images, or data into numbers that capture meaning. - **Context Window** — The AI's "working memory" — how much text it can see at once. - **Tokenization** — Chopping text into bite-sized pieces that AI can digest. - **RAG (Retrieval-Augmented Generation)** — Teaching AI to look things up instead of making things up. - **Synthetic Data** — Artificially generated data that mimics real data for training. ### Trading Metrics (17 terms) - **Alpha** — Excess return above what the market provides; the value added by skill. - **Sharpe Ratio** — Risk-adjusted return: how much return you get per unit of risk. - **Maximum Drawdown (MDD)** — The largest peak-to-trough decline before recovery. - **MFE & MAE (Maximum Favorable/Adverse Excursion)** — The best and worst unrealized profit/loss during a trade. - **Position Sizing** — How much capital to allocate to each trade. - **Risk-Reward Ratio** — How much you could lose vs how much you could gain on a trade. - **Expected Value (EV)** — The average outcome of a trade if repeated many times. - **Win Rate** — The percentage of trades that are profitable. - **Slippage** — The difference between expected price and actual execution price. - **Liquidity** — How easily you can buy or sell without moving the price. - **Volatility** — How wildly prices swing — both opportunity and danger. - **Leverage** — Borrowing money to amplify both gains AND losses. - **Arbitrage** — Risk-free profit from price differences between markets. - **Mean Reversion** — The idea that extreme prices tend to snap back to normal. - **Beta** — How much an asset moves relative to the overall market. - **Long & Short Positions** — Betting on prices going up (long) or down (short). - **Stop Loss & Take Profit** — Automatic exits that limit losses or lock in gains. --- ## Blog (https://uvlabs.ai/blog/) Insights on Financial AI: technical deep-dives on training data, RL environments, model training, and building AI systems that can operate in financial markets. 13 posts. ### UV Labs vs BloombergGPT vs FinGPT vs Scale AI March 2026 — https://uvlabs.ai/blog/uv-labs-vs-alternatives.html A comparison of financial AI training data sources for researchers and practitioners. Different financial AI training approaches solve different problems, and they aren't interchangeable — each enables different capabilities. The post compares approaches across data type, cost, and what each can actually train. TL;DR: - BloombergGPT: Great for NLP tasks, but proprietary and expensive to replicate ($3M+) - FinGPT: Open source and accessible, but limited to text data without decision context - Scale AI: Excellent for labeling, but not specialized for financial decision data - UV Labs: Purpose-built decision episodes with reasoning traces for training AI that transacts ### The Continuous Data Problem: Why Financial AI Needs Fresh Training March 2026 — https://uvlabs.ai/blog/continuous-data-problem.html Financial AI requires continuous fresh data because markets are non-stationary and adversarial; static datasets create brittle models that degrade over time. Markets evolve, shift regimes, and change their fundamental structure — a static dataset produces a model that's already out of date by the time training finishes. TL;DR: - A model trained on 2021 bull market data knows nothing about 2022 Fed hiking; COVID crash models assumed V-shaped recoveries are inevitable - Model decay compounds: concept drift, distribution shift, crowding, and feedback loops against other AI systems all erode performance - Fresh data enables regime adaptation, new instrument coverage, infrastructure tracking, and continuous improvement rather than degradation ### Social Sentiment for Trading AI: Moving Beyond Headlines March 2026 — https://uvlabs.ai/blog/social-sentiment.html Raw sentiment scores fail because they treat all voices equally and often lag price; effective social data requires engagement weighting, noise filtering, and precise temporal alignment. By the time naive sentiment is measurable, the information is usually priced in — yet social data clearly influences markets, so the question is how to extract signal from noise. TL;DR: - GameStop's 134% move was driven by social media, but naive sentiment analysis (count bullish/bearish posts) doesn't capture the signal - Engagement metrics (likes, retweets, velocity) weight importance; source classification separates analysts, traders, influencers, and bots - Training requires sentiment snapshots at the exact moment of decision with proper attribution to subsequent outcomes, not post-hoc analysis ### Building AI That Can Transact: The Infrastructure Challenge March 2026 — https://uvlabs.ai/blog/ai-transaction-infrastructure.html The gap between "AI that can discuss markets" and "AI that can reliably execute orders" is enormous; the model is the smaller challenge, execution infrastructure is where systems succeed or fail. The path from intention to completed transaction involves many steps — specification, tool selection, parameter formation, execution, confirmation, state update — each with potential failure modes. TL;DR: - Knight Capital lost $440M in 45 minutes from infrastructure failure, not bad strategy; execution has 7+ failure points from intention to state update - Training on idealized execution fails in production; data must capture real slippage, partial fills, latency, and API errors - Every execution teaches something: slippage patterns, fill probabilities, timing effects, and error frequencies that can't be described, only learned from data ### Why Traditional Quant ML Isn't the Same as LLM Training March 2026 — https://uvlabs.ai/blog/quant-ml-vs-llm.html Traditional quant ML and LLM training are complementary but fundamentally different; a quant fund with decades of price data has almost nothing usable for LLM training. The models Renaissance-style funds use are fundamentally different from LLMs in ways that matter for training, deployment, and capability. TL;DR: - Quant ML does narrow tasks (signal prediction, pattern recognition) with numerical features; LLMs need reasoning traces, language context, and complete decision episodes - LLMs enable integration, explanation, and strategy generation that pure quant can't, but require entirely different training infrastructure - Your data advantage may not be what you think: price data doesn't help LLM training, decision data does ### From Tool Use to Alpha: The Four Stages of Financial AI February 2026 — https://uvlabs.ai/blog/four-stages-financial-ai.html Financial AI capabilities emerge in discrete stages (tool use, analysis, alpha, emergence), each gated by qualitatively different training data at 10-100x increasing scale. Like LLM capabilities generally, progress comes in jumps — and understanding the stages tells you what's actually possible today versus hype, and what training data unlocks the next stage. TL;DR: - Stage 1 (tool use) needs thousands of examples; Stage 3 (alpha generation) needs millions with long-horizon outcomes and counterfactuals - Most deployed financial AI is stuck at Stage 1 with hints of Stage 2; claims of Stage 3+ performance are almost certainly overstated - The bottleneck isn't compute or algorithms, it's data; teams solving the data problem are building the foundation for everything that follows ### Human Feedback in Financial AI: Beyond Standard RLHF February 2026 — https://uvlabs.ai/blog/human-feedback-beyond-rlhf.html Standard RLHF breaks down for finance because expertise is rare, feedback is complex, and outcomes unfold over weeks; the solution is capturing human judgment naturally through trading activity. The pool of people who can evaluate complex trading decisions is small, and the best ones have better things to do than rate model outputs. TL;DR: - Frontier labs reportedly pay expert traders well over $100/hour for feedback and still struggle to find qualified contributors; this doesn't scale - Implicit feedback (strategy modifications, manual interventions, capital allocation) scales infinitely without requiring separate labeling - Quality control through track record weighting, consistency checking, and expertise classification filters noise from signal ### The Case for Replayable Financial Environments February 2026 — https://uvlabs.ai/blog/replayable-environments.html Reinforcement learning needs exploration, but financial markets charge for every "try"; replayable environments enable risk-free exploration of alternatives while staying grounded in real market dynamics. Each market moment happens exactly once — you can't rewind the market and try a different trade — so replayability is the only way to get AlphaZero-style exploration in finance. TL;DR: - Simulation suffers from distribution shift, missing market impact, and idealized execution; replayable real data avoids these gaps - Replayability enables curriculum learning: difficulty progression, regime sequencing, and concentrated training on systematic errors - The feedback loop compounds: live trading generates grounded data, replay enables exploration, better models improve outcomes, attracting more users and data ### Counterfactual Learning: Teaching AI What Could Have Been February 2026 — https://uvlabs.ai/blog/counterfactual-learning.html Every trade contains information about many alternative outcomes; counterfactual analysis extracts this hidden value to multiply limited decision data into abundant training signal. Financial AI can't self-play like AlphaGo — each real decision happens once and costs real money — but counterfactuals turn one trade into many training examples. TL;DR: - A single trade with counterfactual analysis yields 9+ training signals: actual outcome, MFE/MAE comparisons, trailing stop simulations, timing scores, and error flags - MFE (Maximum Favorable Excursion) reveals how much profit was left on the table; MAE shows the true risk that was taken - Luck vs. skill decomposition uses counterfactuals to estimate what portion of results came from decision quality versus variance ### Why Financial AI Needs Reasoning Traces, Not Just Outcomes February 2026 — https://uvlabs.ai/blog/reasoning-traces.html Outcome-only training conflates luck with skill; reasoning traces are the only way to separate them and teach models how to think about financial decisions. The same outcome can come from a textbook breakout trade or from aping in on a tweet — and a model trained on outcomes alone has no idea which behavior to replicate. TL;DR: - OpenAI's research shows process supervision "significantly outperforms outcome supervision" for reasoning tasks - FOMO entries show meaningfully lower win rates than planned entries, but this only shows up in reasoning data, not outcomes - ReAct (Reasoning and Acting) traces capture the adaptive information-gathering process that mirrors how human traders actually work ### Anatomy of a Financial Decision Episode January 2026 — https://uvlabs.ai/blog/anatomy-of-decision-episode.html A complete financial AI training episode requires six components: agent reasoning, market context, trade execution, position journey, outcomes, and counterfactuals. This is the difference between knowing what a trading system does and understanding how it thinks — the first is useless for debugging, the second is trainable. TL;DR: - Reasoning traces with explicit phases (analysis, decision, execution) enable process supervision, not just outcome-based training - MFE/MAE (Maximum Favorable/Adverse Excursion) metrics are critical for exit optimization but often missing from datasets - Counterfactuals multiply training signal by extracting "what could have been" from each decision point ### What is Post-Training for LLMs? A Practical Guide January 2026 — https://uvlabs.ai/blog/what-is-post-training.html Post-training (RLHF, process supervision) transforms raw LLMs into useful assistants, but standard approaches break down for financial applications. What transformed GPT-3 into ChatGPT wasn't more pre-training data — it was a fundamentally different kind of training, and finance needs its own domain-specific version of it. TL;DR: - 40 contractors providing preference feedback transformed GPT-3 into ChatGPT; Scale AI and Surge AI built billion-dollar businesses on this insight - Financial RLHF is harder: rewards are delayed, good decisions can lose money from variance, and expert feedback costs well over $100/hour - Financial post-training requires complete decision episodes, counterfactual environments, and process feedback from domain experts ### The Financial AI Data Problem: Why Market Data Isn't Enough January 2026 — https://uvlabs.ai/blog/financial-ai-data-problem.html Financial AI is bottlenecked by data, but not the kind you think: market data shows what happened, while decision data shows what to do about it. Petabytes of price history, order flow, and execution records don't teach a system how to make decisions about trading, as opposed to what trading looked like. TL;DR: - BloombergGPT cost $3M to train on 363B tokens of market data, yet still cannot make trading decisions - Renaissance's edge came from capturing decision data (reasoning, signals, outcomes), not just price history - Financial AI needs complete decision episodes with reasoning traces, counterfactuals, and process feedback --- ## Essays on X (https://uvlabs.ai/articles/) Long-form essays the UV Labs team publishes on X — on financial AI, agent infrastructure, and the path to autonomous markets. 10 essays by @0xBebis_ (https://x.com/0xBebis_) and @Cod3xOrg (https://x.com/Cod3xOrg). 1. **Hand-Written Software is Becoming Infrastructure** (Apr 22, 2026) — Why the role of human-written code is shifting from product logic to infrastructure layer as AI agents take over application development. https://x.com/0xBebis_/status/2046994476741341618 2. **How to Predict The Future of AI** (Apr 8, 2026) — A framework for thinking about where AI is headed based on what the infrastructure constraints actually tell us. https://x.com/uv/status/2041984366939926726 3. **HyperLLM: What We Learned Training a Small Model for Quantitative Finance** (Mar 25, 2026) — Lessons from training a purpose-built language model for quantitative finance on real trading data. https://x.com/uv/status/2036862367531950474 4. **You're Not a Quant. Stop Trying to Act Like One.** (Mar 18, 2026) — Most traders lose money imitating institutional strategies. A different approach to using AI for trading decisions. https://x.com/0xBebis_/status/2034306798174568495 5. **Chasing Dragons** (Mar 2, 2026) — On the pursuit of building something that matters in crypto and why the hardest problems are worth solving. https://x.com/0xBebis_/status/2028529532643524823 6. **Unpacking Moltbook: How Clawd Bootstrapped Millions in Compute** (Feb 2, 2026) — A deep dive into how the Clawd project bootstrapped large-scale compute infrastructure from scratch. https://x.com/0xBebis_/status/2018413737213149650 7. **Financial Super Intelligence (DevCon Talk)** (DevCon 2025) — Steven's DevCon talk on Cod3x's vision: a world where alpha becomes a commodity and outperformance becomes a function of compute. https://x.com/Cod3xOrg/status/1993043262605869067 8. **Financial AI is Inevitable** (Aug 12, 2025) — The case for why autonomous financial agents aren't speculative but an inevitable consequence of AI progress. https://x.com/0xBebis_/status/1955282951169888477 9. **Where is Crypto x AI Going Exactly?** (Jun 25, 2025) — Mapping the intersection of crypto and AI infrastructure, and where the real value accrues. https://x.com/0xBebis_/status/1937890059241525346 10. **Going Vertical: The True Cost of AI** (Jan 2025) — Why vertical integration is the only way to make AI economics work in financial markets. https://x.com/0xBebis_/status/1877409761768993232 Follow @0xBebis_ on X for the latest: https://x.com/0xBebis_