EigenTrader OS
Sign inRequest access
Agentic · the platform beneath your agents

Build agents. Deploy   safely.

Build autonomous trading agents in the Agent Builder — identity, harness, governance, observability and memory included — or bring your own and connect via MCP. Use the REST API directly, or let your agents consume platform tools over MCP. Same governance either way.

Agent Builder or BYOA via MCPMulti-agent fleetsGoverned by default
What this is

Not a connector. The platform your agents run on.

MCP is the agent-facing integration surface — but agentic is the platform underneath it: the primitives, runtime and safety rails agents consume. Volatility Intelligence, execution and strategy tools are all built on the same primitives.

Core primitives

The building blocks under every agent

Identity & Registry

Per-agent identities, API keys and ownership metadata. Every action is audit-ready and attributed to the agent that took it.

Harness & Runtime

Agent lifecycle management, sandboxed execution and resource quotas — with non-bypassable policy enforcement at the boundary.

Governance & Order Gateway

Per-strategy limits, capital budgets and circuit breakers. Pre-trade enforcement and compliance hooks, server-side — agents can't route around them.

Observability & Event Bus

Real-time agent event streams — signals, fills, risk events, audit logs. Stream to the console or to your own downstream consumers.

Agent Memory & Vector DB

Persistent state and embeddings for recall and context, with fine-grained permissions on memory access.

Tooling & Intelligence

Packaged products your agent calls — Volatility Intelligence, options execution, strategy selection — importable as tools or via REST.

Multi-agent orchestration

Run a fleet, not a bot — trading, risk and portfolio-optimization agents coordinated under one governance layer, each attributed and contained on its own mandate.

Model router

Every LLM call is routed to the right model — the cheapest that clears the reliability bar — so agent compute stays cheap without giving up quality.

How agents connect

Connect over MCP. Govern with policy.

Connect any agent over MCP

Register and connect your agent over MCP — it authenticates, calls platform tools and streams telemetry. Build it in EigenTrader OS, or bring your own runtime; REST + SDKs cover service-oriented use too.

Govern it with policy-as-code

Declare policy in YAML, a Markdown agent file, or natural language — at the agent layer (one agent's mandate) or the portfolio layer (rules across the whole book). Budgets, limits and circuit breakers are enforced server-side on every order; you set the policy, and agents can't route around it.

Same governance, attribution and observability whether the agent is built here or brought via MCP — and the policies are always yours to set.

EigenTrader OSAgent policyrisk-agent · CONNECTED OVER MCP
ScopeAgent layerPortfolio layer
Define policy as
# policy · risk-agent
agent: risk-agent
when:                            # model-evaluated, not a static stop
  regime_model: risk_off
  rotation: out_of(book.top_sector)
  vol_term_structure: inverted   # front month > back
then:
  scale_gross: 0.5x
  widen_stops: 1.5x
  block_entries_if: earnings_gap_risk > 0.7
on_breach: halt + alert
applies to every order the agent proposes
You set the policy · we enforce it

Illustrative. The full policy schema, SDK & MCP reference lives in the docs.

You build, own and operate your agents.

Bring your own via MCP, or build them in EigenTrader OS. Either way, the agent is yours.

EigenTrader OS provides the infrastructure, tools and governance rails. It does not make trading decisions for you, trade on your behalf, or manage your account. Your agent runs on your connected brokerage account (e.g. Alpaca); you are responsible for the agents you deploy and the trades they place. We add governance, attribution and observability on top of your broker — we don't replace your judgment. Same model as your broker's API.

The governance dashboard

Where you govern and monitor your fleet

Your agents run against the backend and report into it — they never need this screen. The dashboard is for you: supervise every strategy, see per-strategy performance, watch a live personalized feed, and ask a trader assistant about your book. EigenTrader OS is the platform underneath; this is the cockpit on top.

Performance

Per-strategy returns, not a blended number

Watch the portfolio equity curve, then pick any strategy from the dropdown — the chart drills into its Strategy Returns, real-time and historical.

PORTFOLIO EQUITY · LIVE
$110,903.26▲ $103.26 0.09%
$110.9K$110.9K$110.8K
Personalized live feed

A feed personalized to your portfolio and market

Alerts, fills, risk and analysis — streamed in real time and tuned to your positions, your strategies and the events you actually trade.

PERSONALIZED LIVE FEED
09:31:02 ASSISTANT[info]
Good morning. Fleet online — 7 strategies governed, 0 breaches overnight.
09:31:05 ASSISTANT[alert]
⚠ NVDA IV spiked to 72.4% — vol-earnings rolling Jan-17 $140C → Feb.
09:31:09 ASSISTANT[analysis]
Personalization: today's vol surface tuned to your options-heavy book.
09:31:21 ASSISTANT[trade]
Filled: BUY 100 AAPL @ 225.16 · slippage 0.4bps · attributed to mean-rev.
Personalized trader assistant

Ask it about your book or the market

A question — a strategy, a risk, how the day is shaping up — answered from your positions and live market data. Just the question and the answer.

PERSONALIZED TRADER ASSISTANT
09:31:00 ASSISTANT
I watch your book and live market data. Ask me anything — a strategy, a risk, the market today.
>
Product spotlight

Agentic Options — production options infrastructure, as tools

Production Volatility Intelligence (IV rank, expected moves, regime detection across the U.S. options universe, 5-min refresh), an options execution engine and strategy selection — packaged as tools your agent calls.

TradingViewCharting. You still execute manually.
thinkorswimA platform. You still click the buttons.
Options AlphaEducation. You still decide everything.
EigenTrader OSProduction infrastructure your agent calls — watch the U.S. options universe, detect vol events, size and execute, governed 24/7. You built the agent; the rails are ours.