The Self-Driving Portfolio
Last month I stopped writing investment memos.
For about a month, I didn’t publish anything. Part of it was just watching the market—a few of our positions performed pretty well during the silence—but the real reason was a bit more existential. It felt like being quietly replaced by my own idea. The memos still get written — sharper than mine, on a faster clock — I’m just not the one writing them anymore. Somewhere in the building, fifty-odd software agents read the filings, run the models, and argue over what the numbers mean. Another set of methods turns the winning view into candidate portfolos. A meta-agent watches what worked, rewrites the agents that didn’t, and ships the next version of the system over a weekend. I find out what changed on Monday.
I built a good part of that machine. Then I had to decide what it had done to my job — promoted me, or politely retired me. That question is the real subject of the paper I co-authored with Andrew Ang and Andrey Kim, “The Self Driving Portfolio” (https://arxiv.org/abs/2604.02279), even though the paper is too dignified to phrase it that way.
Since we put it out, the paper went quite viral. It struck a massive nerve and became far more important to the industry conversation than we anticipated. Because of that reception, I’m going to try to explain more and more how it all works under the hood in a series of upcoming publications.
Consider this specific post just the first, general observation. Beyond the mechanics of finance, writing this is also a personal experiment. I’m trying to really understand what format of these pieces would work better for us now, as we try to redefine the human’s role and voice in the era of GenAI.
The honest version took me a while to see
Indexing won the active/passive war by making the investor passive. You stopped picking, the fee compressed toward zero, and the arithmetic did the rest. Agentic architectur goes the other way. It makes the machine active again — not the brittle version where someone wires a chatbot to a brokerage and asks it to allocate, but a system that forecasts, builds portfolios, votes on them, and rewrites itself when it’s wrong. The active/passive boundary does not vanish. It moves up the stack.
The new passive role is the human one. You write the Investment Policy Statement — what the system can hold, what it can’t, what its risk budget is, what counts as a violation — and the system runs inside it. The machine does the active work. You do the governing. Same dichotomy, one floor up.
I spent most of my career on the wrong side of that line and didn’t notice the line had moved under me.
The debate that asked the wrong question
For forty years the active/passive war was an argument about who picks the securities. Bogle on one side, the stock-pickers on the other, a whole industry of consultants in the middle billing both. Active meant a human with conviction, a research team, and a fee that assumed both were worth paying for. Passive meant taking the market’s answer and paying almost nothing to get it.
Indexing won on cost. Vanguard pulled expense ratios from around one percent down to a few basis points, that gap compounded for decades, and by the late 2010s passive had crossed active in US equities. The verdict was brutal precisely because it wasn’t close: most active managers don’t beat the index after fees, and you weren’t comparing their alpha to zero — you were comparing it to a competitor charging nothing for the average outcome.
But the thing the verdict never settled was where alpha actually lives. Active management didn’t fail because humans got bad at picking stocks. It failed to scale, because the cost of paying smart people to find an edge grew faster than the edge did. That’s a statement about org charts and fee structures. It is not a statement about whether the picking can be done — only about who can afford to do it and at what size.
Which is the assumption nobody in the fight ever questioned. Active meant a person. Passive meant a rule. A person was expensive and didn’t scale; a rule was cheap and scaled infinitely; so the cheap thing ate the expensive thing, and everyone called it settled. The third option — an active system, governed by a passive human — wasn’t a worse answer to the old question. It just wasn’t a category yet. It is now.
The system, in plain language
Stop picturing one clever model. Picture about fifty narrow ones, each doing a single job, passing work to each other through a defined process.
At the front, specialized agents forecast: one reads filings, one watches macro, one tracks factor exposures, one parses the news. Each produces something small and specific — a revenue path, a margin trajectory, a regime read — and none of them tries to call the whole picture. Behind them, more than twenty portfolio-construction methods take those forecasts and build competing portfolios in parallel, each with its own objective function and risk model and private opinion of what “optimal” means. They’re supposed to disagree. Then a layer of peer review turns the agents on each other: a portfolio built by one method gets graded by agents that didn’t build it, for risk, for policy compliance, for basic sanity, and the survivors go to a vote that picks the construction for the period.
The part everyone fixates on is the last layer — the meta-agent. It compares what the system did against what the market actually did, and rewrites the code and prompts of whatever failed. The system that runs next quarter is an edited version of the one that ran this quarter, edited by itself.
That layer is also where the honest skeptic should plant a flag, because a system that rewrites itself on one quarter of returns is a machine for overfitting to the last regime at machine speed. One quarter is a single noisy draw. You cannot tell a bad agent from an unlucky one on a sample size of one, and a naive meta-agent will happily fire the unlucky one and promote whatever just got lucky.
The version in the paper leans on holdout periods, change thresholds, and shrinkage toward what was already working — guardrails against chasing noise — and even with all of that, this is the part of the design I’d stress-test first, not last. Adaptive systems don’t remove the danger of being confidently wrong. They just let you be wrong faster.
Sitting around all of it is the Investment Policy Statement. The IPS is human-written and dead simple: what the system may hold, what it may never hold, the risk budget, the universe, the definition of a violation. The agents run inside it the way a car runs inside a road network — they pick the route, they can’t drive off the map.
Here’s roughly how one forecast travels the whole length:
An agent reads a 10-Q for a semiconductor name and calls revenue two standard deviations above consensus.
Twenty methods fold that in twenty ways, one leaning into it, one ignoring it as below threshold.
Review checks the resulting books for concentration.
The vote picks a construction, sized inside the IPS limits.
Next quarter the meta-agent checks whether the call was right — and if it was wrong in a structured, repeatable way, say an agent that kept reading every buyback announcement as bullish, that agent gets rewritten before it runs again.
Notice what never happens in that sentence. No model is ever asked to “be the portfolio manager.” There’s no prompt that says you are a CIO, make the call. The intelligence isn’t in any one agent being brilliant. It’s in the structure — fifty bounded specialists composing into a process you can read top to bottom. Every component is small enough to audit; every input and output is named. The system is a workflow, not an oracle.
The output is a portfolio. The more interesting object is the process that made it.
The inversion, named
Hold that whole machine in your head and watch what happens to the active/passive line.
For forty years, “active” lived inside the portfolio: a human picked the securities. “Passive” was the alternative to that human: a rule picked the market. The two defined each other. Fire the human, you got passive; hire one back, you got active. The entire debate balanced on a single axis.
The agentic system snaps that axis. The portfolio is produced by an unmistakably active process — agents, methods, votes, rewrites — but there’s no human inside it picking anything. The human has climbed one level up, to write the document the system lives in. The active layer is the machine. The passive layer is the governance.
Here’s the part the indexing crowd won’t enjoy: indexing did not retire active management. It relocated it. The IPS now does what the index did — bound a system, define what counts, rule whole regions of behavior out of bounds. The agents do what the active manager used to do — take views, run optimizers, hold positions. The line between the thing that picks and the thing that constrains is exactly where it always was. It just moved up a floor, and we were all staring at the old floor.
The obvious objection is that this is just delegation with extra steps. You hired a system instead of a person; the fee line changes, the principal-agent problem doesn’t. And I want to concede more of that than the triumphant version of this essay would. A self-rewriting system can be harder to govern than a human, not easier — a manager can at least explain why she changed her mind, while a system that edited its own prompts over a weekend may have done something no one can fully reconstruct. Adaptivity doesn’t shrink the governance burden. It grows it.
But it’s a different problem, not the same one. A manager you delegate to runs roughly the same playbook until you fire her. The meta-agent rewrites the playbook against measured outcomes, between runs, against itself — which is why you have to govern the rewriting, not just the holdings. Delegation gives you a different driver. This gives you a driver that rewrites itself against the road. The line worth keeping is the symmetric one: indexing won the last war by making the investor passive; agentic architecture wins the next one by making the governance passive — and letting the machine be the active manager indexing thought it had killed.
The active manager did not die. It changed substrate.
What this means if you allocate, build, or argue about this for a living
If the substrate changed, the jobs sitting on top of it change too.
If you allocate capital — a CIO, a family office, anyone who hires managers for a living — the unit of work moves. You used to evaluate people: track record, team turnover, the story behind a good year. With a self-driving portfolio the team is the system and the system is documented, so what you’re really underwriting is the IPS it runs inside and the meta-agent’s rule for changing itself — the thing you’ll have to defend to a board that wants to know how a machine ended up holding what it held. Manager selection becomes IPS design. The scarce skill is writing constraints that survive a market you can’t predict, not picking the human who swears he can navigate one.
And you have to price it honestly, which the breathless version of this story never does. Active management died on cost; fifty agents, a researcher agent, a peer-review layer, and a meta-agent shipping rewrites are not free. You’ve moved the cost from salaries to compute, orchestration, and the standing risk that the whole apparatus quietly overfits. The bet only pays if that new cost stack comes in under the old one and the system clears its own turnover — which is an empirical question the architecture raises and does not, by itself, answer.
If you build the models — quants, ML researchers, AI-fluent PMs — the deliverable changes shape. A single model is no longer the product. It’s one citizen of an ensemble, peer-reviewed by its neighbors and outvoted half the time, and what you tune is how it behaves in that crowd: how your forecast composes with twenty others under a voting rule, how it degrades when the meta-agent rewrites a neighbor and the ground shifts under you. The two-decade career arc — own a model, defend its Sharpe, ride it as long as it lasts — turns into something closer to systems engineering. You design how models compete, not just how they predict.
If you’ve been arguing the active/passive question for years, you were arguing the wrong axis. The fight was always about who: human or rule. The real axis is where: execution or governance. Once the boundary becomes something that can slide up or down the stack, the forty-year argument looks like two camps fighting over which floor the manager lives on while a new floor went up over their heads.
And the thing that breaks all of it is the document everyone treats as boilerplate. The IPS bounds behavior; it does not bound being wrong about the world. A perfectly compliant portfolio can be confidently, correctly-within-its-rails positioned for a decade that isn’t coming — no policy statement can encode the regime you haven’t lived through yet. The meta-agent can rewrite the agents. It cannot rewrite the rails. So if the humans who set the rails treat the IPS as a one-time artifact instead of a living constraint, the system inherits the oldest failure of the human manager — conviction without revision — and runs it at scale and at speed.
Which is why the real human input isn’t returns. It’s the fiduciary judgment about what the system is allowed to want, and how the rules that contain it get to change. Governance is the new alpha. It is also the new way to blow up.
The desk, a quarter later
Back to the memos I stopped writing.
They still get written. I’m not the one writing them, and the month I spent resenting that turned out to be the wrong reaction to the wrong question. The forecasts got sharper without me. The constructions argue among themselves. The meta-agent ships a new version of the system over a weekend and I read the changelog on Monday like everyone else. None of that is my work anymore. My work is the document on the other side of the room — the one that says what the system is allowed to want, and what it must never do no matter how sure it gets.
That document used to be a compliance afterthought, a page near the back of the prospectus that no one read twice. Now it’s the only thing I write that the market ever sees. Everything else I used to do — the views, the trades, the conviction — got copied, sharded, audited, and put on a cron. What’s left is the part nobody ever wanted: drawing the rails, holding the line on what cannot happen, saying no in writing before the system thinks to ask.
For a month that felt like a demotion. It isn’t. It’s the only seat in the building where being right still depends on a human being honest about what he doesn’t know.
I used to write memos arguing the trade.
Now I write the policy the trade has to live inside.
Moving forward, I’m going to use this space to publish more AI-native memos and articles. My goal is to make it easy to understand how to deploy and use these architectures optimally—because missing out on this shift fully or ignoring how to leverage it is not going to end well for anyone trying to stay competitive.
Stay tuned. I’ll be posting soon.