An AI that runs a hedge fund, end to end, and on the record.
A working multi-agent prototype today. Watch it deliberate, backtest, and audit a position, one ticker, on paper. The plan: coordinated swarms that run the whole fund, end to end.
One continuous loop, from market feed to managed capital.
The target design: every stage running as coordinated agents under a central orchestrator, outputs flowing forward through deterministic gates, and positions feeding back into research. Today the research & selection stage, the Boardroom, is live; the rest is the roadmap.
Seven coordinated swarms, one meta layer.
The target architecture: specialized agent groups, each owning a stage of the fund's operation. Today one of them runs: the research Boardroom. The rest are the roadmap. Every swarm is a framework of typed capability slots, so governance stays permanent and the agents inside are swappable.
Ingestion
Agent-supervised data pipelines that file incidents instead of failing silently, feeding search-interest, options-chain and futures-basis data for behavioral and timing signals.
Prediction
A probability-weighted market model plus a time-series foundation-model ensemble, and a Behavioral Desk scoring attention, prospect-theory and extrapolation signals on the same reality-checked discipline.
Research
Desks debate into an adjudicated house view, grounded in a shared knowledge graph and policed by deterministic bias gates that catch herding and overconfidence in our own agents.
Execution
Deliberately not an LLM: a deterministic engine with a timing overlay covering trading windows, calendar-risk days, participation caps and order-to-trade hygiene enforced as policy.
Stewardship
The post-purchase layer: living theses re-underwritten on cadence, deterministic exit discipline through the same gates as entries, a hedging module and a drawdown governor.
Compliance
OPA rules plus LLM auditors running manipulation-pattern detectors on our own order flow as examiner-ready proof of what we don't do.
Neural Engine, Foundry & Bursar
Meta-research and analytics agents, plus The Foundry (governed self-improvement) and the Bursar, which meters every dollar into net-of-cost P&L under hard budget envelopes, so autonomy always runs net-of-cost and inside a budget.
Full autonomy, inside an envelope the OS makes impossible to leave.
The governance model we're building (ships v0.8 to v0.9): humans approve a Mandate once, covering its objective, the exact files an agent may touch, its budget, its legal scope. Inside that envelope the agent is fully autonomous; outside it, actions aren't just forbidden, they're impossible, because the mandate compiles to policy in LoQOS.
The Foundry
Governed self-improvement: ratchet loops run experiments on allowlisted surfaces only, each a commit in a per-swarm lineage graph. Everything is reversible; a deterministic scorer, independent of the proposer, decides what's kept.
Shared knowledge graph
One memory across every swarm: entities, claims, forecasts, theses and their provenance. Agents get bounded subgraphs with citations instead of replaying transcripts.
The Bursar
Every token and compute dollar is metered and attributed to an agent, swarm and decision, then reported as net-of-cost P&L, with budget envelopes enforced and safety spend always exempt.
Not AI bolted onto a hedge fund. The fund itself, rebuilt as an operating system.
The model proposes. Deterministic code disposes.
What makes LocusQuant different from a chatbot pointed at a brokerage: the guardrails are code, not prompts, and every decision is on the record.
Deterministic code gates
Risk boundaries and house-view consistency are enforced by plain Python gates, not prompt guidance a model can talk around. A non-compliant proposal is rejected before it can execute.
Append-only audit trail
Every agent output and gate decision streams to an append-only store, so each decision is traceable back to the inputs that produced it, with no silent overrides.
Honest-by-default UI
Degraded desks, missing data, and gate interventions are surfaced, not hidden. The interface shows what actually happened, including when the system overrode the model.
A working prototype, today.
Not a mockup. A running multi-agent system you can watch deliberate, backtest, and audit. Today it runs a single ticker on paper capital, no live money, with every decision recorded.
Orchestrated multi-agent graphs over Groq-served Llama models, with FinBERT sentiment and grounded market & macro data from SEC EDGAR and FRED.
The system is designed to automate research → prediction → deliberation → execution → stewardship, while humans keep four irreducible seats: exception resolution, compliance judgment, capital allocation, and legal sign-off.
From prototype to fund-in-a-box.
The near-term releases from the pipeline, each still paper-traded and routed through the same deterministic gates.
View the full pipeline → What's Next
Who's building it.
Data science background across credit-bureau and fintech systems, forming the quantitative and modeling core of LocusQuant.
Enterprise integration background, wiring the operating system into robust, production-grade infrastructure.
Reach a founder directly through the .
See the fund run, on the record.
Request access to the live prototype and watch the agents research, deliberate, backtest, and audit a position, one ticker, on paper, every decision recorded.
Investors & partners welcome · no live capital at risk today