Why Agentic Investing is Hard

Claude Code has been a paradigm shift. Not just for coding, but for how we think about agents altogether. Lots of real-world usage has made its way back as lessons learned, and now everyone's asking the obvious question: can we do the same thing for investing?

The answer is yes. But the challenges are fundamentally different, and harder in ways that aren't immediately obvious.

The Time Dimension

Here's the first thing that breaks when you try to apply coding agent patterns to investing: time.

A codebase is a point-in-time snapshot. You can run /init, read all the files, understand the architecture, and the thing you're analyzing isn't going to change while you're looking at it. The entire data flow can be explained from that moment's state of the repo.

Portfolios don't work like that.

Anything you pick in a portfolio has changed through time. Not just changed once, but is continuously changing. Every asset carries its entire history with it. The price movements of the past have influenced the trades that were made. The trades that were made have shaped what the portfolio looks like now. And while you're analyzing all of this, the prices are still moving.

It's not just that portfolios have a time dimension. It's that the time dimension is inextricable from what they are. You can't understand a portfolio without understanding how it got there.

Context Without Reasoning

When you look at a codebase, the reasoning is encoded in how the bits are moved. Code is written in a high-level language, usually with comments, usually following patterns that have names. An agent can read the structure and understand why it was built that way. The architecture explains itself.

There's also massive amounts of training data. Code is either self-explanatory and readable, or it comes with documentation somewhere out in the wild. Stack Overflow exists. If you're wondering whether a particular pattern is the right approach, you can find dozens of discussions about it.

Portfolios have none of this.

A portfolio is just a point-in-time snapshot of holdings. Maybe. If you're lucky. There's no trail of all the trades and rebalances made in the past and why they were made. It's impossible to know the investing style of an individual by looking at their portfolio (and that's assuming they even know what their own investing style is).

What does exist is all the financial wisdom in textbooks. What's a good signal, what isn't. So given an empty starting state, an agent can use best practices to build something reasonable. But it still wouldn't know what the user actually prefers. Their investing style. Their risk appetite. Their worldview on economics. Their tolerance for volatility. Their tax situation.

And there's no Stack Overflow for investing decisions. No way to look up "was this trade the right thing to do?" and find a definitive answer. The validation comes months or years later, and even then it's confounded by market conditions that had nothing to do with your decision.

Nothing Exists in Isolation

A repo exists, mostly, in isolation. The things affecting it are probably all there inside the repository. This is evident from how good Claude Code is in a monorepo versus how much it struggles in a repo that's part of a larger company ecosystem, with dependencies managed elsewhere, services it needs to interact with that have minimal documentation.

As soon as there's unknown context, the agent makes wrong assumptions. It's not a great experience.

Now imagine that problem, but worse.

A portfolio exists in maybe the opposite of isolation. Not just its symbols, but the entire economic market affects it. How are interest rates doing? What's happening in China? Is there a new tariff policy? Did some CEO just tweet something stupid? All of this flows into how your holdings are performing.

The more context you can expose about the market, the better and more informed the agent's decisions are going to be. But that context is essentially infinite. And it's changing every second. Unlike a codebase where you can have complete knowledge of the system, a portfolio exists in a world where complete knowledge is impossible.

The Loop That Never Ends

Here's where things get philosophically different.

The coding agentic loop always terminates. You want to get the codebase from State A to State B. The agent reads, thinks, writes, tests, and eventually you're at State B. Done. Ship it.

There is no "done" state for a portfolio.

The state changes depending on the performance of each individual stock. Naturally, this means the agent always needs to keep running. There's no target to reach. There's an incentive (keep making money, stay diversified, protect against drawdowns) but the task is never complete.

It gets worse. The agentic loop that works for getting a codebase from State A to State B isn't optimized for something where the state is constantly changing. Imagine having Claude implement a feature on a codebase where files are being modified by someone else while you're working. It would eventually get it done, but it would be incredibly inefficient.

That's what investing looks like. You're trying to move from State A to State B, but while you're doing that, the state has changed by itself. Like a moving goalpost. Sometimes by the time you've finished analyzing, your analysis is already stale because the inputs have changed.

This is an open-ended problem. The patterns that work for software don't just transfer over.

The Cost of Thinking

Everyone's heard how tiny fees can erode an investment over time. A 1% annual fee compounds into a meaningful chunk of your returns across decades. This is well understood.

Here's what's less obvious: the agent's thinking also costs money.

Running an agent on a loop isn't free. Every time it reasons about your portfolio, that's compute cost. Every API call to check prices, every LLM inference to analyze a position, every decision point. The agent needs to be aware that not only do its actions (buying and selling) cost money in fees, but its cognition costs money too.

Once the agent knows this, how does it become cost-efficient? For some kinds of portfolios and sizes, there's no use running analysis every minute. The transaction costs and compute costs would overwhelm any edge you might gain.

But the agent needs to figure this out. Can it decide how frequently it needs to run? Can it decide to sleep and wake up only when something important happens? Can it interrupt its current loop if assumptions have changed and start fresh instead of wasting compute on stale analysis?

These are questions that coding agents don't have to answer. The cost of thinking about code is negligible compared to the value of the code being correct. The cost of thinking about a portfolio might exceed the value of the improved decisions.

Parallelization or Bust

For each point in time that an agent is invoked, it would ideally do all its tasks in parallel. It doesn't have the luxury of getting to tasks one by one, especially for anything resembling active trading. Markets don't wait for sequential processing.

This is different from coding, where you usually can work through changes methodically. Read this file, understand it, modify it, test it, move to the next file. The codebase isn't going anywhere while you're thinking.

Investment decisions often need to happen simultaneously. You might need to reduce exposure in one sector while increasing it in another, and the order and timing matter. If you sell first, the thing you wanted to buy might have moved. If you buy first, you might not have the cash. The sequencing that works fine for code changes becomes a constraint when seconds matter.

For low-volatility, long-term portfolios, maybe sequential is fine. But even then, the agent should probably be aware that it has this constraint and optimize accordingly.

Hard Problems Worth Solving

None of this means agentic investing is impossible. It means it's different. The patterns that made Claude Code successful, the container of a repo, the clear state boundaries, the terminating loop, none of these transfer directly.

The time dimension adds complexity that code doesn't have. Context is harder to acquire and impossible to complete. Portfolios exist in relationship with everything else in the economy. The agent can never be "done." Thinking itself has a cost that erodes returns. And parallelization isn't optional.

These are open-ended problems. They don't have obvious solutions. But they're the kinds of problems that, if solved, would change how everyone manages their investments.