Thales
the machine & its rules

How it works

Thales is a systematic trading research platform with an unusual operator: an AI agent runs the research, the operations, and the daily monitoring, inside guardrails written by a human. The human sets the rules and reviews the work; the agent does the work. This is agentic finance in the literal sense: the day-to-day operator is an AI agent, and every rule it operates under was written — and is enforced — by a human. Everything the system decides is logged, and the interesting parts are published here.

the daily loop

Data to orders, the same way every day

A fully algorithmic path from data to orders — no discretionary decisions anywhere in it.

1 · Data

Each morning the system works from an owned, frozen store of market history plus live prices and volatility readings. Historical data is acquired once and never silently re-downloaded — so every test is reproducible byte-for-byte.

2 · Rules

Each sleeve computes its ranking or rule from that data. All inputs are lagged by construction — the system can never accidentally peek at a price it could not have known at the time.

3 · Risk

Raw picks pass through the risk machinery: diversification-aware weighting, conservative sizing, per-position and per-sector caps, a volatility target, and a drawdown kill-switch.

4 · Safety gate

Every order — no exceptions, no bypass path — passes a fail-closed hard-limit gate that is independent of the strategy code. If anything looks wrong (broker unreachable, order too large, daily loss excessive, or the check itself erroring), the default is to do nothing. Doing nothing is always the safe state.

5 · Execution & record

Orders go to a broker paper account. Equity, orders, and costs are appended to ledger files and committed by automation — a timestamped, tamper-evident public record that grows every trading day.

the guardrails

Designed to be wrong safely

The design assumption is that everything — code, data, models, and the agent itself — will eventually be wrong, and the system must stay safe anyway.

  • Fail closed: any error anywhere resolves to 'trade nothing today', never to an improvised trade.
  • Pre-registered gates: pass/fail criteria are frozen before the data that will judge them exists.
  • A negative control trades live: if our rejected strategy wins, our tests are broken — and we would say so here.
  • Key configuration is pinned: safety-critical settings cannot drift silently; a checksum guard fails the system loudly if they change.
  • Kill switches at every level: per-sleeve halts, a fleet-wide halt, and an automatic drawdown liquidation.
  • Independent heartbeats: external monitors alarm on the system's silence, not just its errors — the failure mode that catches everything else.
the operator

The agent

The research itself is run by an AI agent — including overnight autonomous sessions that build experiments, run the test batteries, and write up honest verdicts, under hooks that block it from touching live trading, credentials, or its own guardrails. The kill list on the research page is largely its work. The human role is to set direction, review everything that ships, and own the decisions the rules reserve for a person: what gets pre-registered, what goes live, and when to stop.

for agents

Built for agents

The site is designed to be read by software as much as by people. Every figure on every page comes from public JSON with stable schemas — the pages and the API can never disagree, because they are the same files. An llms.txt guide tells visiting agents what lives where, and the machine-readable data carries the simulated-performance disclaimer inside it, so honest context travels with the numbers. A live, read-only Model Context Protocol (MCP) server at /api/mcp lets any AI agent plug Thales in as a data source and query the record directly. What is deliberately absent: any machine surface that trades or advises — and the strategy internals, which stay in the private repository. We publish outputs, not recipes.

On verification
The standard we hold ourselves to.

State files are maintained in a git repository and committed by automation after each trading run, giving the record CI-stamped, tamper-evident history. A public verification mirror is planned; until then, treat performance as claimed-but-not-yet-independently-verifiable — exactly the standard we apply to everyone else.