Ithaca

Ithaca is the operating system for AI hedge-fund research that turns market questions into constrained strategies, benchmarked backtests, risk traces, and runs paper trades.

Comment

Ithaca: infrastructure for agent-driven market research

Ithaca is an MCP-native platform that lets external AI agents research markets, propose constrained strategies, request trusted backtests, and request paper deployments. It turns a market thesis into a reproducible workflow instead of an unverified chat response.

It is not investment advice, does not promise returns, and does not let agents execute arbitrary code or autonomously trade live capital.

The workflow

+-------------------+     +----------------------+     +--------------------+
| BYO AI agent      | --> | Ithaca MCP gateway   | --> | Vetted market data |
| Codex / Claude /  |     | OAuth, scopes, trace |     | news, OHLCV, risk  |
| Cursor / custom   |     +----------+-----------+     +--------------------+
+-------------------+                |
                                     v
                         +--------------------------+
                         | Declarative StrategySpec |
                         | JSON Schema, not code    |
                         +------------+-------------+
                                      |
                                      v
                         +--------------------------+
                         | Trusted backtest worker  |
                         | metrics, artifacts, hash |
                         +------------+-------------+
                                      |
                           human review required
                                      |
                                      v
                         +--------------------------+
                         | Paper deployment         |
                         | control-plane gated      |
                         +--------------------------+

Why it exists

Finance tooling is fragmented. Agents can find data and make persuasive claims, but the path from research to backtest to deployment is usually disconnected and hard to audit. Ithaca keeps the context, inputs, permissions, results, and decisions in one system of record.

The result is a workflow a user can inspect: what data the agent used, which tools it called, what strategy it proposed, how the backtest ran, what artifacts were produced, and which human approved the next step.

Technical design

Ithaca is a Python platform with a React/Vite observability UI:

  • MCP gateway: OAuth-authenticated tools for market research, strategy authoring, runs, and resources. Every call is tenant-scoped and traced.
  • Contracts: JSON Schema generates Pydantic models for Python and Zod models for TypeScript, preventing API, worker, and UI contract drift.
  • Control plane: FastAPI services own immutable strategy versions, run transitions, compliance checks, approvals, and the money path.
  • Runtime workers: stateless processes claim durable jobs, run backtests under aggregate deadlines, emit progress, and create artifacts.
  • System of record: PostgreSQL stores tenants, strategies, runs, jobs, traces, artifacts, paper books, controls, and approvals. SQLite supports deterministic local development.
  • Web UI: reads the same run and trace state through REST and Server-Sent Events. SSE can replay after a sequence cursor, then follow the live tail.
  • Deployment: Docker, Kubernetes, Terraform, DigitalOcean managed PostgreSQL/object storage, Clerk OAuth, and an Interactive Brokers integration seam for connected-account data.

Reproducibility and observability

Each run has an append-only, gap-free event stream keyed by (run_id, seq). The trace captures tool calls, tool results, strategy proposals, state transitions, checkpoints, denials, errors, and artifact creation.

Completed backtests persist metrics, equity curve, positions, provenance, warnings, a canonical SHA-256 result hash, and a versioned artifact bundle. Matching strategy inputs, seed, and window can be checked against the same deterministic result hash.

Safety boundary

Risk Ithaca boundary
Agent-authored code Never executes. Agents submit closed declarative specs only.
Cross-account access Every read and write is scoped by tenant.
Over-broad permissions Effective permission is role ∩ scopes ∩ tenant.
Agent self-promotion Agents can request a paper deployment, never promote or activate one.
Worker bypass Workers propose paper-book deltas; the control plane re-gates and applies them.
Silent failure Errors, denials, timeouts, and cancellations are durable trace events.
Race conditions Run transitions use optimistic versioning; money-path writes are serialized.

The launch product is paper-only by design. A human reviews, promotes, activates, pauses, and retires deployments.

What makes it useful

Ithaca gives an agent enough capability to do real research while keeping the financial workflow reviewable. Instead of copying an AI answer between a data terminal, a backtester, and a spreadsheet, users get one connected trail from prompt to evidence to paper outcome.

I built it with Codex and GPT-5.6 as development partners for MCP/OAuth tracing, contract and scope hardening, deterministic end-to-end demos, integration debugging, and verification. The standard was the real path: authenticate, initialize MCP, call the tool, run the durable backtest, inspect the trace and artifacts, and confirm the same state in the UI.

Early traction

Ithaca reached roughly $1,000 MRR through friends, family, and cold outreach to potential customers. The strongest signal was not demand for another market chatbot. People wanted an agent workflow they could inspect, replay, and control.

I am exploring an accelerator as the next step: continue customer discovery, harden the product, and make Ithaca the control layer for finance-capable agents.

Built With

Share this project:

Updates