Why the Harness Exists

Overview

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.

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.

Build vs. buy

Engineering cost assumes a 2–3 person in-house agent team. Inference comparison assumes per-event frontier-model calls vs. the Harness's event-driven routing; methodology on request.

Working Together

Early Harness engagements are high-touch by design. Our engineers work alongside yours to build, test, and ship your agent integration.

Co-build model

This is not a self-serve product yet. The implementation decisions we make together will shape how financial agents operate for years. We take that seriously.

Every early engagement follows a co-build model:

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. Our team works alongside yours to design and ship a custom agent experience: bespoke environments, custom policies, and compliance sign-off before you go live.
• API: Programmatic control over agents, policies, accounts, and telemetry. Build exactly the experience your platform needs.
• Soon Widget: Drop-in agent UI for your application. Your brand, your interface.
• Soon SDK: Native client libraries for faster integration.

API Overview

The Harness API is a RESTful service with real-time streaming support. It covers the full agent lifecycle: provisioning, policies, execution, and telemetry.

Authentication

All requests authenticate via a platform-scoped API key in the Authorization header. Keys are issued during onboarding and support rotation, IP allowlisting, and permission scoping.

# Platform API key
curl https://api.uvlabs.ai/v1/agents \
  -H "Authorization: Bearer uv_sk_..." \
  -H "Content-Type: application/json"

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

import uvlabs

harness = uvlabs.Harness(api_key="uv_sk_...")

agent = harness.create_agent(
    account="user_abc123",
    models=["sonnet", "haiku"],
    signals=["imbalance", "vol_shift"],
    tools=["order", "position"],
)

agent.deploy()

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.

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.

# Global: every agent on your platform
policy = harness.create_policy(name="platform-risk", scope="global")
policy.add_rule(
    type="position_limit",
    params={"max_leverage": 3.0},
    effect="Block",
)

# Per-account: flag large drawdowns for human review
account_policy = harness.create_policy(name="user-risk", scope="user_abc123")
account_policy.add_rule(
    type="drawdown_control",
    params={"max_drawdown": 0.05},
    effect="RequireApproval",
)

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.

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

# Real-time
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.

Pricing Model

Structured to align our incentives with yours: we succeed when your agents are active and performing.

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.