INALPHAOPEN-SOURCE QUANT AGENT FRAMEWORKD-12REV 0.122026.06.17AN ORACLE THAT KEEPS A LEDGERFACTOR TIMING Β· RANK ICINVESTING LEGENDS PANELSTRATEGY EVOLUTION70-FACTOR LIBRARY Β· DECAY WATCHPLAN Β· APPROVE Β· EXECUTEPOSITION GUARD Β· βˆ’20% HARD STOPAUTONOMOUS PAPER RUNNERAGENTS Β· FIRST-CLASSAGPL-3.012 MARKETSINARI OMIKUJI
InalphaInari Γ— alpha

AnΒ oracleΒ thatΒ keepsΒ aΒ ledger.

Quant agents that evolve under audit.

Agents pick the factors that work now, convene a panel of investing legends, write and evolve the strategies β€” and route every order through machine approval. The LLM writes the code; the engineering harness signs every decision.

$git clone https://github.com/mirror29/inalpha
View on GitHub
Why Inalpha Β· the black box vs the ledger

Most AI trading is a black box.Inalpha writes everything down.

the black box
When it loses

"Buy BTC, 0.62 confidence" β€” and no way to tell which data or which step went wrong.

When it wins

Was that skill, or luck? If you can't reproduce it, you can't trust it.

Who can place a trade

The model holds the keys to your account. One bad prompt becomes a real order.

Inalpha Β· ledger
01
When it loses

Replay the exact decision: the data it saw, the logic it ran, the reason it gave.

02
When it wins

Every idea and test is on record, so real edge is something you can prove β€” not a lucky streak.

03
Who can place a trade

The AI only proposes. A rule you set places the order β€” it can't pull the trigger itself.

Every step explained. Every trade, your call.

Intelligence Β· factors that work now

Agents that pick the factors that work now.

factor.timing ranks a 70-factor zoo β€” price, volume, fundamental, and FRED macro families β€” by rolling Rank IC, and surfaces the signals working right now. Every factor is formalized, IC-tested, multiple-testing-checked, de-correlated, and logged with author, timestamp, and the economic-story gate decision.

factor.timing Β· rolling Rank IC
── A governed factor library
  • 70 factors Β· 7 families Β· incl. FRED macro (yields Β· DXY Β· VIX Β· CPI)
  • decay watch Β· rank_ic_recent vs rank_ic, surfaced per factor
  • top-N de-correlated at ρ < 0.85 β€” never ten copies of one signal
  • discovery L1 Β· whitelisted DSL (no eval/exec) β†’ auto-eval + dup-check + register
factor.timing β€” ranked by 60d rolling Rank IClive Β· illustrative
momentum_60deffective
+0.082β†˜ +0.071
residual_reversaleffective
+0.061β†— +0.066
vol_carryeffective
+0.047β†˜ +0.039
amihud_illiq
+0.024β†˜ +0.021
pead_drift
+0.012β†— +0.018
value_bm
-0.007β†˜ -0.012
70 factors · de-correlated ρ<0.85 · decay-watched · recent IC vs base
Research Β· opposing minds, one synthesis
deep_dive ~ NVDA Β· live debateillustrative
β–² bulls 00 bears β–Ό

Research is a debate, not a single voice.

A deep dive convenes technical, fundamental, sentiment, and valuation analysts β€” and, when you ask, a panel of investing legends. They argue opposing cases, then Inalpha synthesizes the disagreement into one decision on record.

Optional Β· a panel of investing legends
BuffettLynchWoodBurryDruckenmillerMarks
Pluggable methods Β· agent skills

Beyond the panel, agents load research playbooks as skills β€” a supply-chain lens, a methodology you bring in β€” read only when a case calls for it. Knowledge plugs in; tokens aren't spent on what isn't in play.

Evolution Β· written, sandboxed, mutated

Agents write the strategy β€” then rewrite it to beat itself.

An agent writes a full strategy in Python. Three sandbox gates clear it before a single backtest runs. Then it mutates under a multi-objective fitness, so no one metric can be gamed β€” only strategies that beat the baseline survive.

Seeded from proven archetypestrendmean-reversionvolatilitymulti-factor
Agent writes
class Strategy(Bar): ...
Three sandbox gates
1AST audit

no os / eval / jailbreak imports

2Isolated subprocess

runs walled off from the kernel

3Strategy contract

must subclass + implement on_bar

Multi-objective fitness
sharpe + 0.3Β·calmar βˆ’ 0.1Β·turnover βˆ’ 1.0Β·(maxDD > 30%)
mutate Β· evaluate Β· keep what beats the baseline
Quality gate

Before promotion a gate scores the candidate against the baseline; below bar, the agent auto-pivots and rewrites once β€” only what clears ships.

Unified kernel Β· same code, three modes

One codebase.
Three modes.

Strategy code is written once. Backtest, paper, and the live runner all share it β€” swap only the Clock and the Gateway. Business logic never changes; divergence can only come from physical reality β€” slippage, latency, data precision.

strategy = MomentumStrategy(params)
clock =SimClock(bars_2024)
gateway =SimGateway()
engine.run(strategy, clock, gateway)
only clock + gateway change Β· your strategy never does
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
Trust boundary Β· the moat

The AI proposes.
It never places the order.

Every order intent walks a one-way path: the agent drafts a plan, a rule you set (or you) approves it, and only then does a single-use, expiring token unlock execution. The model has no tool that reaches the order book directly β€” not after a jailbreak, not after a hallucination.

LLM agent
trade.create_planAgent drafts a plan
trade.approve_planA rule, or you, approves
trade.execute_planOne-shot token executes
Order book
guard-stop Β· Framework backstop

Independent of strategy logic, the framework caps every position at a βˆ’20% hard stop β€” applied in backtest too, so the drawdown you see is the drawdown you'd live. Its liquidations clear the risk gate only when triple-signed (SELL Β· guard tag Β· guard- order prefix), so nothing can spoof its way past the boundary.

LLM agentOrder book
denied β€” no direct path for the LLM
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.

orchestrator
research
factor
risk
execution

add a venue β€” every agent gets it for free

── Where we are honest with you

  • 01Autonomous paper runner + cross-currency cash: promoted strategies trade a simulated multi-currency account on live bars, machine-approved through plan/exec, with full decision replay
  • 02A 70-factor library with lineage tracking and decay alerts β€” factors are IC-monitored and de-correlated; alerts only warn, they never move your book
  • 03Framework position guard: a βˆ’20% hard stop applied in backtest and paper alike, independent of strategy logic
  • 04RiskEngine enforced at the paper HTTP boundary: notional cap / price deviation / drawdown veto / real exchange calendars across every market
  • 05No real-capital deployment β€” the runner trades a paper account, orders matched locally; every step passes plan/exec approval and lands on disk
FAQSEO.md Β§FAQ

What you're probably wondering.

Honest answers to the questions we get asked most.

Get startedagpl-3.0 Β· audited Β· open

Star it. Read it. Tear it apart.

Inalpha is alpha-stage and AGPL-3.0. No real money yet β€” every line is on GitHub.

$git clone https://github.com/mirror29/inalpha
0── stars
0── contributors
0── commits
0── markets
not for live capital