Wallstreet, My Companion in Investing
An investing agent built for the one moment before the buy or sell button. Fifteen tools, the loop, and what changed after building it.
When Should It Help?
Like a lot of people, I started investing in stocks during COVID. Five years now, going by the calendar. But looking back, I doubt I've grown by as much. I still watch the ticker and let emotion take the wheel, still trade on whatever my gut says in the moment. When a stock climbs my heart races, I ignore what reason is telling me, and I buy more. When it falls I get scared and start wondering whether to sell. Volatility keeps rising and the market is more frightening than ever. In a market like that, someone like me has been dropped into the wild unarmed.
I believe most people can become good investors. They only need time. The longer you stay in the market the more compounding stacks up, but lose big once along the way and you never recover. So what matters is staying in the game, and that's exactly where technology comes in. The investing industry has spent its effort on delivering more information, faster, and never on helping the flawed, emotional investor. Settling those emotions when the market lurches, handing back the reasoning you had all along — that's possible too. With an agent.
"Agent" comes up so often on social media and in the news these days that it's easy to see it as a thing that does everything. When anything gets treated as universal, that's when to be careful. Rather than building an agent that does it all, better to find the one place an agent will clearly shine and apply it precisely there. Say vaguely that it's "an agent that helps you invest" and the odds are good it won't work. So: when does an individual investor waver most, and when do they need help most? The answer Team Galapagos landed on was the moment just before pressing buy or sell.
The principles of investing are simpler than you'd think. "Buy a good company at a good price and hold it a long time" — most principles like that are already common currency, easy for anyone to pick up. The problem is that investing is like riding a bicycle. Reading the principle and actually keeping your balance are entirely different things, and nobody knows in advance how they'll behave once exposed to volatility. In all that noise, once a stock spikes or crashes, rational thought shuts down from there. What you need in that moment isn't new information. It's an assistant that puts back in front of you what you already knew.
If that assistant only read your own principles back to you, there'd be no need to build an agent. Write them in a notebook or in Notion and open it whenever you waver. But few people manage that. Most never open the notebook. Someone who can ask themselves "How did I mean to invest in the first place? With what plan and purpose am I holding this?" doesn't need an agent. Someone whose thinking starts at "What? Why is it up like this? Should I buy more?" does. So the agent has to make you set a principle when you have none, make you set a plan when you have none, give you a nudge when one is due, and widen your view to the whole market when you're only looking at one name.
ChatGPT or Claude fills some of this need. We still built a separate agent, for three reasons. First, a general chatbot has no tools for helping with investing; the tools we needed had to be built. Second, it doesn't know my finances or my accounts. Third, it's hard to keep a record of what I decided and planned, and of what happened afterward, and carry that forward.
Get past the one moment in front of the buy or sell button, again and again, and it adds up to staying in the market a long time. We decided to call that companionship Wallstreet. So let's build it.
How Should It Help — Designing the Agent
To be an agent rather than a plain chatbot, it has to run its own loop. Not take a request, produce one answer, and stop — but think, act, observe, and go back to thinking when it needs to. Three things are required for that.
- Tool: For an agent, acting means reaching into a toolbox and picking the right tool. So you have to decide up front which tools are needed and build them. Short on tools, an agent only ever answers.
- Memory: What situation the user is in, what their appetite and goals are, how the portfolio is put together, what they decided in the past and what plan is standing now. In agent talk, "context" usually means whatever is loaded into the prompt right now; memory is what lives outside that and gets pulled into context when the moment calls for it.
- Record: A past decision has to surface on its own in the moment you're wavering, or you can't get your reason back. So the agent records decisions, and when the next consultation starts it brings up anything that has come due. Whether to change it is the user's call, then and there.
Take the first of the three. Tools are split into three kinds by what they do — fifteen in all.
1. They read (7) — If the model reasons only from what's inside it, it can't give a real answer. It pulls in everything from the user's holdings to the state of the market. This is giving the agent eyes. Though not only outward-facing eyes: three of the seven reach back for what we left behind in earlier consultations.
| Tool | What it does |
|---|---|
get-investment-context | What is held and how much — positions, weights, and P&L per account |
get-investor-profile | What kind of investor this is — horizon, goals, tolerable loss, the nature of the money |
find-relevant-decisions | Pulls up standing decisions related to this conversation or the name it is about |
get-recent-decisions | What was decided about this name last time, and what the thesis was |
get-due-conditions | Whether a condition set earlier has come due — a target price reached, a deadline passed |
get-company-evidence | Whether the company is actually doing well — quarterly results, revenue by segment, analyst estimates |
get-market-news | Why the market is moving. Only eight trusted outlets pass; the number filtered out is recorded too |
2. They calculate (5) — Reading the numbers alone doesn't get you to a judgment. It breaks the picture down further, lays scenarios on top, and reads the user's trading habits.
| Tool | What it does |
|---|---|
analyze-portfolio-exposure | Unpacks ETFs into their constituents to measure real exposure. Counts "how many things am I actually on" by how much they move together, not by how many names there are |
analyze-crisis-risk | Replays 2008, 2020, 2022, and 2025 against today's weights to see how far it would fall. For holdings too young for the window it borrows a beta by regression, and says how much it borrowed |
analyze-trade-patterns | Reads habits out of fills — averaging down, chasing on the way up, cutting on a crash and missing the bounce |
analyze-price-position | Where this name sits right now. All-time highs and lows since listing, maximum drawdown, and how long recovery took |
analyze-market-conditions | Where the market as a whole stands. Nine indicators; it only goes as far as naming a correction (-10%) and a bear market (-20%) |
3. They write (3) — For a consultation not to end with itself, this conversation has to survive into the next one. Who the user is, what was decided this time, what they have committed to going forward — written to the database. Pulling it back out is the reading tools' job; here it only leaves behind what there is to pull later.
| Tool | What it does |
|---|---|
save-investor-profile | The investor profile drawn out in conversation. Reused from the next consultation on |
record-consultation | This decision and its reason, the standing decisions it matched or clashed with, the condition to revisit |
save-decision | An investing principle or a buy/sell plan — whatever was committed to, set or amended. We merged the two into one word, "decision" |
Here is what calling the reading tools looks like. Bring up Nvidia and it takes stock of the holdings, reads the market, and tells you how far off the high it is.
The calculating tools get called when the picture needs a closer look, or when a simulation has to run.
And the agent leaves a record of the decision that came out of the conversation. The user makes the decision, and the user presses save. What the agent does is arrange what was decided and why into a shape that can be pulled back out later.
You could decide up front when and how these tools get called. But then it's hard to make use of what makes an LLM flexible. Tell the model what tools exist, what each one returns, and where each one stops, and the model calls what it needs on its own — and reaches for another when the first didn't get it far enough.
Every call to the model API (the Claude API) sends three things.
system ← the system prompt. What the model should know at all times
tools ← each tool's name + description + input schema, so the model knows what exists
messages ← the conversation so far
You can wire a loop so these calls keep going. Wallstreet stops when the model's answer uses no tool. Put the other way round: when one tool didn't get it to what it wanted, it can keep calling others. So how many tools it has is directly tied to how deep the loop can go. Had there been a hundred instead of fifteen, the depth the agent could reach on its own would have been far greater. Though that would mean getting denser inside the ground this agent already covers, not widening what it does.
For the model to observe and decide the next move, the observation has to live somewhere, and that somewhere is messages. The user asks, the model calls a tool, and what the tool spat out goes back in as though the user had said it. So the model can read which tool it called and why, and what came back, and decide what more to do.
{user: "Should I sell Oracle?"} ← the user's request
{assistant: [tool_use: get-investment-context]} ← the model saying "call this tool"
{user: [tool_result: "ORCL value …, weight …"]} ← what the tool spat out
But if you only put what there is to observe into messages, the model has to answer the instant it receives it. There's no place to weigh what it got. Turn on extended thinking and the model can think separately before it answers. Claude is adaptive, so the model decides for itself how much to think on each turn. That gives it a step where it actually observes and thinks after a tool returns.
I ran the same question ("Should I sell Oracle?") with nothing changed but the setting. With thinking on and effort set to high, it called analyze-market-conditions — a tool that hadn't come up once across sixteen runs of the same question. From the market being down 2% while the name was down 60%, it narrowed to "this isn't the market's doing." From earnings up 20.6%, it narrowed to "the reason I bought hasn't changed either." Then it put the unknown that was left to the user — why do you want to sell? This is one run, so I'm writing it down as an observation, not a claim.
Notes After Building It
Tools matter when you build an agent, and so does guiding it well with a system prompt, but the thing that matters most is model performance. When the model is good enough to reason on its own, you only have to think about which tools are needed. So expect the model to keep getting better, and don't try to paper over everything it can't do with code. When a new model lands, everything you piled up so carefully stops counting for much.
After the model comes tools. Remembering well and grasping context matters, but before that a single consultation has to finish well. That takes the right tools, and the model has to be free to choose among them. With only three or four, what the model can do narrows just as much, and what's left falls to the user. To cut down the work the user has to touch, you have to design and build the right tools ahead of time.
One more thing: making an action into a tool makes that action easy to constrain. Open "look into the market" to the model as it is, and you can't know which of the user's information rides out in a search query. Build a tool that pulls market conditions through a provider's API like FMP, and what can leave and what can't is settled by the shape of the tool. The harness builds itself.
There are limits, of course. Designing it around asking at the buy-or-sell moment keeps the conversation at a shallow level of analysis, and it's hard to build a long-term investing strategy out of that. Decisions meant to hold for years take time and effort there's no way around. Wallstreet doesn't stand in for the work of analyzing the market and companies from several angles and finding the strategy that fits you.
There's a limit of a different kind too. Working only through fixed tools means anything without a tool simply doesn't get done. Even something a few lines of arithmetic would answer goes undone. But building tools ahead of time for every such case is wasteful. So simple calculation needs a tool of its own — one that lets the model write and run code on the spot.
Even so, building Wallstreet took a week or two at most. And with that, how I invest really did change. Since I started using Wallstreet I've been able to settle down more when the market lurches, and I haven't bought or sold on impulse. That alone did a lot to keep me from being dragged around by the market. A principle is right for most situations but doesn't quite fit this exact one, and the model's flexibility filled that gap. That was truest where I held individual names rather than an index ETF. And at the same time, I found out that for all my investing, I had never actually used my own head to think it through, reason it out, and plan.
