Yesterday a hedge fund engine dropped where Buffett, Soros, Burry and Cathie Wood all analyze the same stock, then fight about it. It’s called Lumina Capital (v6.0.0), it showed up on r/PromptEngineering, and the twist is not the personas. Step 4 is where it gets interesting.
What’s new
Lumina is a multi-agent quant engine built with LangGraph. Seven personas (Buffett, Soros, Burry, Cathie Wood, Graham, O’Neil and a CIS agent) each do an independent analysis in parallel. Each one reads the same ticker through a different lens: Buffett looks for durable moats and fair prices, Burry hunts for what the crowd is ignoring, Wood bets on disruption curves, Graham cares about the balance sheet margin of safety. Because they run in parallel, none of them gets to anchor on another persona’s answer.
Then comes an adversarial bull vs bear cross-debate. Instead of a polite summary where everyone nods, one side is forced to attack the other’s reasoning directly. The idea is to fight the usual LLM problem where agents politely agree with each other and the “council” collapses into one opinion repeated seven times. If you’ve ever watched a multi-agent setup produce a confident answer that all agents somehow reached in the first round, you know why this matters.
The twist
The LLMs never touch the math or the exits. The author splits probabilistic reasoning from deterministic computation, which is a cleaner line than most agent projects draw:
- Qlib Alpha158: a pure Python, vectorized version of Microsoft Qlib’s 158 factors, with a LightGBM filter making the meta-decision. Factor math is the kind of thing a model will happily get subtly wrong, so it lives in code.
- Google TimesFM: 5-day forecast fan charts with 80% confidence bands and a crash probability. You get a range and a tail risk number, not a vibe.
- A 10-second sentinel thread: watches dynamic ATR stop-loss floors and exits positions without waiting for any LLM loop. An LLM call can take many seconds and can fail or time out. A stop-loss cannot.
- A CRO agent: has absolute veto power over tail risks, so even a unanimous, enthusiastic council can be overruled.
So the models argue, but the numbers and the stop-losses are plain code. That’s the part worth stealing, even if you never touch finance. The same split applies to a support bot (LLM drafts the reply, code enforces the refund limit) or a content pipeline (LLM writes, code checks length, links and banned words).
Mini-workflow to borrow the pattern 🛠️
- Run your specialist agents in parallel, each with its own lens, so none of them sees the others’ answers first. Give each a narrow job and a different success criterion, not just a different name.
- Add a debate round where one side must argue against the consensus. Tell it explicitly to find the weakest assumption, not to be contrarian for fun.
- Put a veto agent at the end whose only job is to find the way this goes wrong. Make its output structured (approve, reduce, block, plus a reason) so code can act on it.
- Move anything time-critical or numeric (stops, scoring, forecasts) out of the LLM and into deterministic code. ⚡
- Log every council decision so you can audit it later. 📋 Store each persona’s input, the debate outcome and the veto reason, because you will want to replay the bad calls.
The repo also adds a Neo4j GraphRAG layer for supply chain choke-points and a Streamlit dashboard, if you want to see the whole thing running. The graph layer is a good example of giving agents structured context (who supplies whom) instead of asking them to recall it from memory.
Pro tips
- The two top comments asked the right questions: how much do the personas still hallucinate, and has anyone run walk-forward tests with realistic slippage and transaction costs? I didn’t see answers in the thread. Until there are some, treat this as an architecture to learn from, not a proven strategy. Backtests that ignore costs routinely look great on paper and fall apart live.
- License is CC BY-NC 4.0, for research, education and simulation. No commercial use, and no real money until you’ve stress-tested it yourself. Paper trade it first and compare the council’s calls against a dumb baseline like buy and hold.
- To check whether your own council is actually independent, swap one persona’s prompt for its opposite and see if the final call changes. If nothing moves, you built a very expensive echo chamber. Run it on a handful of tickers, not just one, so you don’t mistake luck for signal.
None of this is financial advice. It’s a build worth reading.
Call to action 🚀
GitHub: https://github.com/ramuza0113-sketch/lumina-ai-hedge-fund
Open the repo, read how the council graph and the sentinel are wired, and tell me which one you’d copy first. Have you built a veto agent into your own stack?
Frequently Asked Questions
Q: Does the strict separation between LLM reasoning and quant math still leave room for hallucinations?
Yes, but the risk moves. Prices, indicators, and factor scores come from deterministic Python code, so the LLM never has to calculate them. The remaining risk is in the narrative, where a persona can misquote a figure or invent a justification, so check any number a persona cites against the quant output before acting on it. No measured hallucination rate was reported in the thread.
Q: What backtest results does Lumina have, and how does TimesFM handle black swan events?
The post and comments don’t include published backtest numbers, so ask for the full walk-forward report before treating the engine as proven. TimesFM forecasts from historical patterns, so it can’t anticipate a shock with no precedent. The fan charts widen as uncertainty grows, which makes them a risk gauge rather than a prediction. The 10-second ATR stop-loss sentinel and the CRO veto are the layers meant to limit damage when the model is wrong.
Q: Have the walk-forward tests included realistic slippage and transaction costs?
This was asked in the thread, and no answer was posted, so check the backtest config before relying on any result. A backtest without commissions and slippage can look far better than live trading. Use walk-forward splits, where the model trains on past data and is tested on the next unseen window, and charge a realistic cost on every trade. This matters most for a strategy that trades often.
Q: Does the 7-persona council add measurable value over the quant model alone?
Nobody in the thread has measured this yet, and it’s the most useful test you can run. Run the same walk-forward backtest twice: once with the full council and once with the council bypassed, so only the Alpha158 and LightGBM signal drives decisions. Compare returns, drawdown, and hit rate on identical data. If the council doesn’t beat the quant baseline, its extra latency and LLM cost aren’t justified.
[Project] Built an open-source autonomous AI Hedge Fund engine with LangGraph, Qlib Alpha158, and TimesFM
by u/OpenComplaint524 in PromptEngineering