Why currently how I see the future for hedge funds is to codify your process rather than agents trading on PnL without material human intervention:
Why automation worked for code
Verifiable reward and infinite parallel practice against an environment that doesn’t change because you got better. Millions of rollouts, instant unambiguous feedback.
Markets are singular
One world, one history, no reruns (in even simpler terms, time flows in only one direction, at least according to the physics we know :)). A backtest could easily turn into a single past trajectory you can memorize, which is overfitting with a Sharpe ratio. The true test environment would be live capital: slow, expensive, unrepeatable feedback. This is one of my key concerns, especially when combined with the next point.
Markets are reflexive
Soros’ Alchemy of Finance. The compiler doesn’t adapt to your improvement; markets are made of agents (being the other investors) who do. Every exploitable pattern decays through its own exploitation. In my understanding, non-stationary, unsimulable and reflective environments are properties RL hates most.
And PnL is a hackable reward
Point an agent at maximize returns in a system this complex and it would actually try to find the (degenerate?) maxima with hidden leverage, liquidity illusions. Worse, the signal would get noise dominated especially in the short-term. A great decision can lose money for two years. Enduring losses could be the quality signal for a shop.
So my understanding is that you can’t train judgement end-to-end from market outcomes currently (for fundamental investing), as the training signal doesn’t (fully) exist.
You have to build it from the process. Was the thesis explicit, were the claims source-grounded, were the drivers falsifiable. That is / could be turned into a verifiable reward. And it’s why the model of codifying the process of great fundamental investors could be the key signal needed.
Back to the starting point. Is judgement already automatable?
It automates in layers. Information gathering is automated. Synthesis and verification are automating now. Thesis construction is hybrid. Models to propose, humans to object. The last layer, allocating real capital under uncertainty at fundamental horizons, does not automate for the training-signal reasons above. At those horizons the decision count is small, the system is singular and reflexive, and the outcome signal is too sparse and noisy to train on. What happens instead is that I see a future where judgement concentrates. Fewer people, each making more decisions, better tooled.
So what does alpha come to?
So then what does alpha come to, 5 years from now, when every fund has codified its process and the labs have everyone’s decision traces? A version of this is already playing out. Everyone runs the same base model, you can change the harness around it but the model reads an earnings print with the same sentiment, and (my analysis) post-earnings volatility in large cap TMT went from c. 3% to 7% between ’23 and Aug ’26 (AI capex turning every print into a macro event could be a caveat).
I think alpha comes down to two legs. One, being on the field and gathering proprietary information. The model only reads what everyone reads, so the stuff you can’t buy (relationships, being inside the technical community) is worth more now. Two, keeping your data sovereign and codifying every decision trace that ever happened at the fund, on top of the research process. Here I had an oxymoron in my thinking: we say you can’t replay markets and a backtest is just overfitting, and then we say train on your own decisions.
You can’t learn the market from your past, but you can learn yourself from your past.
The fix here could be that you can’t learn the market from your past (too few decisions, one history, one era), but you can learn yourself (aka your decisions) from your past. Thought experiment: a fund with a habit of selling their winners too early. Take every sale of the last 10 years, compare the sold stock against what they bought with the money and against just holding, at 1/2/3 years, split by reason (thesis broke, valuation, position too big, cash for a new idea). The cost will sit in one bucket, which is sold on valuation with the thesis intact. Then make “expensive” a claim that gets scored like any other claim, and put the record in front of the PM at the next sale. Something like: Your last 12 valuation related sells lost you X% vs holding, which driver broke? So for a fund with deep heritage, the edge might be sitting in its own past, used as a mirror, and that is extremely hard to copy because nobody else has those scars.
Pre-AI you could run this audit, and people did (Selling Fast and Buying Slow paper came out of Inalytics, which sold exactly this to funds for a decade), and funds kept selling early, so the report was not the bottleneck. What changes now is that the reason for every sale sits in 10 years of memos and emails, and a model can actually read them, so the audit becomes, “Here are your 12 valuation sells with the thesis intact,” in your own words, instead of your sells underperforming randomly. And the record sits inside the decision, at the moment of the next sale, with the live thesis. The last step is that once the decisions are tagged with reasons and outcomes, you train a critic on the house’s own judgement, what Bridgewater is trying to do with Thinking Machines at a much smaller scale - on earnings call analysis, and that critic is yours because the scars are yours.
Things I am researching that could change my ideas on judgement automation
- Continual learningIf models can keep learning from sparse live feedback without retraining, a model could learn from live capital the way a PM does, one decision at a time, and the “one history, no reruns” constraint gets weaker.
- Recursive self-improvementIf (which is an if I don’t see coming soon) models improve their own reasoning without a domain-specific reward, judgement could arrive by transfer from other domains, with no market training signal needed.
- Rubric-based rewardsIf rubric grading turns out to be hard to game, process can be trained end to end, which helps our model, but also means the last layer is more trainable than I assume today.