Crew Fund

Inspiration

We wanted to make professional-grade investing accessible to anyone who can describe an idea in plain English, not just people who can code a quant model. Every "AI trader" demo we had seen was a chatbot picking stocks, with no way to tell skill from luck or from accidental lookahead. So we built the opposite: a fund where any idea, typed in plain words, faces the same honest tests a professional quant would use, where an agent has to show its receipts when you question it, and where a human stays in charge of the money.

What it does

THE CREW is an AI hedge fund you run like a heist crew. You are the Mastermind; AI agents are your crew.

Recruit an agent by talking to it. The recruiter researches with you first: ask what a signal means or which ones fit your idea, and nothing changes until you ask for it. When the strategy is ready it asks before compiling it into a recipe: a weighted blend of market signals, how many stocks to hold, a lookback, and a rule for sitting in cash.
Every agent is backtested honestly: month by month from January 2017 to the holdout cutoff (116 monthly decisions over 1,257 stocks), net of trading costs, never using future data.
A Red Team attacks it with four tests: lookahead (does the signal survive a one-month delay?), shuffle (does it beat 100 random portfolios from the same stocks?), and replays of the 2020 crash and 2022 bear market against random portfolios of the same size. The verdict (PASSED, CAUTION or FAILED) is advice, never a block.
Talk to your agents. Each answers from its own stored record (recipe, performance, Red Team tests, holdings, trade log, and how it did against the S&P 500 in any month you ask about), lists the facts it cited, and remembers the conversation. Answers can be read aloud, and questions dictated.
Change and recompile in plain English. "Make it less risky" or "raise this signal to 35% and recompile": the agent rewrites its recipe and reruns the whole backtest and Red Team. You can also edit the recipe by hand.
Be the Mastermind. Split the capital across your crew, fire and rehire agents, or delete them. The War Room shows the fund against the S&P 500 with each agent's contribution as its own line; scrub back and it rewinds, let go and it replays. Holdings shows what the fund held every month since 2017. The Live floor replays the trading log from any year, including your own decisions.
A judged API serves the fund's portfolio and scores 100/100 on the organizers' official checker.

How we built it

Engine and API: Python 3.12, FastAPI, polars and NumPy on the organizers' state-vector dataset and SDK, with /backtest ported from the scorer's own math. Each month, every eligible stock $i$ gets a score from the recipe's features $f$ with weights $w_f$ and direction $d_f = \pm 1$:

$$s_i = \sum_f w_f \, d_f \left(\operatorname{pct}_f(i) - \tfrac{1}{2}\right)$$

where $\operatorname{pct}_f(i)$ is the stock's cross-sectional percentile on that date. The top $N$ are held equally from the day after the decision, paying 5 to 25 bps per trade depending on liquidity. The fund combines the agents' books by your capital split, caps each position at 5%, and always sums to 100%, long-only.

AI: OpenAI (gpt-5.4-mini) turns words into recipes, explains results and edits recipes on request, with Google Gemini as an automatic fallback chain and a deterministic answer from the agent's own facts if every model fails. The AI never sees a price or a return and never picks a portfolio weight; Python validates every recipe. ElevenLabs reads answers aloud.

Database: Tiger Data (TimescaleDB): agents, runs, equity curves, monthly holdings, the trading log and every conversation, with hypertables for the time series.

Frontend: Next.js 16, React 19, TypeScript, Tailwind CSS, Zod schemas mirroring the API, and hand-built SVG charts.

Quality and shipping: test-first, with 245 API tests (including the organizers' scorer on synthetic data), 190 frontend unit tests and Playwright browser tests on every push; Docker on a Vultr server behind Caddy, deployed by GitHub Actions.

Challenges we ran into

"Nothing on screen is invented." The evidence under every AI answer is the stored data's own text, never model output.
No lookahead. The final 30 days are never stored, rows from a 2026 analyst snapshot can never feed a signal, and every decision reads only data dated on or before it.
Testing skill, not size. Our first crash tests compared small portfolios to the S&P 500 and failed every agent on company size alone. They now compare against random portfolios of the same size from the agent's own stocks.
Automatic firing that fired everyone. A 12-month Sharpe of a 10-stock book has a standard error near 1, so automatic firing was firing agents on noise. We handed that decision to the human.
Making the AI act, not just talk. An agent once said "I'm recompiling" without doing it. We gave agents their conversation, separated chatting from recipe editing, and let the code, not the model, decide whether an action happens.
AI rate limits mid-hackathon, which led to the model fallback chain, timeouts and a deterministic backup answer.

Accomplishments that we're proud of

100/100 on the organizers' official checker, locally and in production.
Honest results: with an equal split the crew returned +381.5% vs the S&P 500's +236.8% (Feb 2017 to Aug 2026) at about the same risk-adjusted return (Sharpe 0.78 vs 0.79), and our own Red Team shows on screen that none of the five seed agents beats random picks from its own stocks.
Research over showing off: scanning all 48 signal and direction combinations, one strategy (buying the least-traded stocks) showed over +2,000%. We traced it to survivorship bias and left it out instead of showing a fake number.

What we learned

A leaky signal passes every test except the one that looks for leakage, so that test has to be fatal on its own. Honest results make a stronger product than inflated ones. And AI is great at turning words into structured strategies and explaining them, but whether an action happened should be decided by code.

What's next

Native AI tool calls for editing agents, per-user memory, agent versioning with rollback, a survivorship-free universe that includes delisted stocks, correction for testing many agents at once, and automatic re-evaluation as new data arrives.