Inalpha — Quant agents that evolve under audit.

01 / 01 / Problem

You're not doing quant.
You're trusting a black box.

Most LLM trading stacks return a single score and a paragraph. You can't replay it, you can't audit it, and you can't disagree with it. Inalpha treats every factor, plan, and order as a versioned record — not a vibe.

What you want

Black-box LLM

Inalpha

Signal

One score

Plan with rationale + opposing analysts

Reasoning

"trust me"

Hooks-enforced decision record

Replay

Not reproducible

JSONL on disk + token-signed audit trail

02 / 02 / Why Inalpha

Two non-negotiables.
Both must hold.

A. Agents are first-class

Factor / risk / evolution agents, each with its own toolset
Opposing stances in research debate by design
Traceable decisions, not vibes
Replay-able from any timestamp

B. Engineering discipline is the floor

Hooks on every tool call
Permissions scoped per role
Plan → approve → execute with one-shot token
Decision records on disk, declarative configs in repo

─── A alone is just a chat wrapper. B alone is just another backtest framework. Both — that's Inalpha.

03 / Architecture · system schematic

Hub → spokes → convergence.

Strategy code is written once. Swap the Clock for backtest vs live; swap the Gateway for paper vs broker. Business logic stays put — divergence can only come from physical reality (slippage, latency, data precision).

04 / Unified kernel · same code, three modes

One codebase.
Three modes.

-backtest

from inalpha_paper import BacktestEngine
engine = BacktestEngine(bars=bars_2024)
strategy.run(engine)

+live

from inalpha_paper import LiveEngine
engine = LiveEngine(broker=ibkr)
strategy.run(engine)

01 / kernelv0.x

data

Multi-venue feeds. Freshness-anchored. Same client across markets.

from inalpha_data import get_bars

02 / kernelv0.x

paper

In-memory matching, backtest engine, persistent paper trading. State is replay-able.

from inalpha_paper import run_backtest

03 / kernelv0.x

research

Multi-analyst LLM debate. Opposing stances. No stale numbers passed as insight.

from inalpha_research import debate

05 / Engineering harness · claude code, adapted

Inspired by Claude Code.
Adapted for trading.

Declarative configs decide what each agent can call. Plan → approve → execute is enforced by a one-shot, TTL-bound token — the LLM never reaches the order path unsupervised. Subagents isolate risk. MCP plugs in tools without hand-rolled glue.

permissions.yaml

$ research:
  allow:
    - data.get_bars
    - data.get_news
  deny:
    - paper.place_order

risk:
  allow: ["*"]
  require_human: ["place_order > 0.5"]

01
hooks
Middleware runs on every tool call.
02
permissions
Tool access scoped per agent role.
03
plan-exec
Plan first, execute once, no runaway loops.
04
subagent
Risk and review live in isolated subagents.
05
MCP
Model Context Protocol native, no glue code.
06
Swarm
Parallel workers run grid backtests.

06 / Coverage · twelve markets, one kernel

Same kernel. Same prompts. Same agents.

All markets route through one orchestrator. Add a venue, every agent gets it for free.

── Crypto / 1

Crypto

── Equities / 9

US
A-share
Hong Kong
Japan
Korea
Australia
India
UK
Germany

── Macro / 2

Global Indices
FRED Macro

0── stars

0── contributors

0── commits

0── markets

alpha quality

── Where we are honest with you

01D-9 in flight: LLM-authored strategies (E1 MVP) with sandbox gates + multi-objective fitness
02RiskEngine rules enforced at the paper HTTP boundary (notional cap / price deviation / drawdown veto)
03No real-money deployment yet — every change passes plan/exec approval and lands on disk

You're not doing quant.You're trusting a black box.

Two non-negotiables.Both must hold.