How EigenTrader OS works

Overview

EigenTrader OS is infrastructure — governance, attribution, intelligence and execution tools you build your own trading agents on. It does not trade for you. Your agent proposes actions; EigenTrader OS enforces your policies on every action, executes the ones those policies allow, and attributes the resulting P&L per strategy. You set the policies — capital budgets, position limits, circuit breakers — and you are responsible for them.

Three surfaces: a REST API, an MCP server (so MCP-capable agents discover the tools natively), and the EigenTrader OS app where attribution and governance are visualized. The pages below explain the model; the callable reference unlocks when you have access.

What is an agent?

An agent is software you build and own that the platform governs. Bring your own and connect via MCP, or build it in the Agent Builder — either way it runs on the same governance, attribution and observability rails. The platform supports many kinds of agents, at different levels of autonomy.

Agent types the platform supports:

• Trading agents — decide what/when to trade and place orders.
• Risk agents — monitor exposure/drawdown and trigger halts.
• Portfolio-optimization agents — rebalance toward an objective.
• Portfolio-construction & personalization agents — build and personalize portfolios per mandate.
• Execution agents — work orders, size positions, minimize slippage.

Autonomy levels — you choose per agent:

• Suggest-only — proposes actions; you approve each one.
• Human-in-the-loop — acts within limits; holds high-stakes actions for approval.
• Fully autonomous — acts within its mandate; governance enforces the limits and auto-halts on breach.

Strategies

A strategy is a named, governed unit: one agent, one mandate, one capital budget, one set of limits. Multiple strategies share a single broker account — but EigenTrader OS attributes and governs each independently, so the account's blended P&L is decomposed back into the agents that produced it.

Multi-agent systems

EigenTrader OS is built for multi-agent systems, not a single bot. A book typically runs several agents at once — trading agents that propose orders, risk agents that monitor exposure and trigger halts, and portfolio-optimization agents that rebalance toward an objective — coordinated under one governance layer. Each agent has its own identity, mandate and budget, and is attributed and contained independently, so a misbehaving agent can't take the fleet down with it.

Governance

Every proposed action passes a policy gate before it reaches the broker: capital budget, position limits, and circuit breakers (e.g. auto-halt on drawdown). Approved actions execute; rejected ones return to the agent to be re-planned; high-stakes changes can be held for human approval. Enforcement is server-side — agents can't route around it.

Attribution

Attribution is derived from the immutable event log — not estimated. Each fill, adjustment and risk event is tagged to its strategy, producing per-strategy P&L and quant stats — real-time and historical (Sharpe, Sortino, drawdown, exposure and more). You can trust them because they replay from the record. No competitor attributes at this depth.

Architecture

The path from market data to governed execution to attribution:

Model router

Agents reason with LLMs, and LLM calls cost money at fleet scale. The model router sits between your agents and the providers and sends each call to the most cost-effective model that still clears the task's reliability bar — lighter models for routine calls, stronger models where it matters, with automatic fallback on failure. The result is lower agent-compute cost without trading away reliability.

Governance model

The governance model is documented in full — no competitor publishes theirs. Policies are set at the portfolio layer (rules across the whole book) and the agent layer (a single agent's mandate), and compose hierarchically (account → portfolio → strategy/agent → position). Circuit breakers are evaluated on every action; held actions route to human approval with full context; and every decision is sealed to the record so a halt is always explainable after the fact.

API, SDK & MCP reference

The callable reference — authentication, endpoints, the MCP tool catalog, and copy-paste Python & TypeScript examples — is available to EigenTrader OS users at general availability. The concepts above are public; the reference unlocks when you have access. A taste of the shape your agent code takes:

from eigentrader import Registry, VolIntelligence, Orders

# 1. an identity you own; grant scopes
agent = Registry.create_agent("vol-earnings", scopes=["agent.run", "events.read"])

# 2. your agent's logic decides WHEN/WHAT — EigenTrader OS provides the intel
vol = VolIntelligence(agent)
s = vol.surface("NVDA")
if s.iv_rank > 80 and s.days_to_earnings <= 3:
    # 3. submit through the governed Order Gateway (your limits enforced)
    Orders.submit(agent, long_strangle("NVDA", qty=2))   # halted if over budget