I Built an AI Investment Team. Here's What Actually Happened.

I've been rethinking how I can better use AI in my day-to-day work, not from a tooling perspective, but from a workflow perspective.

AI generates quickly, but turning outputs into work I can trust still takes time. Most of my effort wasn't spent writing prompts. It was spent reviewing, questioning, and correcting the result. When something seemed wrong, I couldn't tell whether the problem was the data, the analysis, or the conclusion because everything arrived as a single answer.

So instead of writing better prompts, I changed how the workflow itself was structured.

The Problem With One Model

The more I worked with large language models, the more I noticed the same failure patterns recurring. They weren’t unique to one model. They weren’t occasional bugs. They were consequences of how I was using AI.

Reasoning drifts over long conversations. Earlier assumptions become the starting point for later conclusions, whether or not they were ever validated. A conclusion reached at the end of a long session is shaped by everything that came before it: the assumptions already made, the way questions were framed, and the direction the conversation gradually took. That makes extended interactions feel productive. It also makes it difficult to know whether the conclusion reflects the evidence or simply the path the conversation followed.

When information is incomplete, the model doesn’t usually stop with “I don’t know.” It produces the most plausible answer it can from what’s available, often without making it obvious which parts came from evidence and which were inferred. The output looks complete. It isn’t.

By the time the answer reaches you, every step that produced it has been compressed into a single response. You can disagree with the conclusion. You can’t see whether the problem started with missing evidence, weak interpretation, or an unsupported assumption.

None of these is an unusual failure. They’re natural consequences of asking one conversational process to gather evidence, interpret it, review its own reasoning, and recommend an action at the same time.

The question wasn’t whether the models would improve. It was whether I should keep asking one reasoning process to do four different jobs.

The Architecture

I split the analysis process into three roles and implemented each as a separate agent. The logic: inputs, interpretation, and review are different jobs. Combining them gets you output. Separating them makes the gaps visible.

Kabee gathers the evidence. Historical price data, volume, trend direction, and market data from approved sources. He returns facts only. He doesn’t interpret them. He doesn’t recommend actions. If he can’t verify a number, he returns None — he doesn’t infer.

Deen Wong turns evidence into analysis. He identifies patterns, evaluates technical signals, and produces a structured recommendation with supporting rationale. His job isn’t to verify the data. His job is to explain what the data suggests.

Mira is my cognitive partner. She decides how the work should be approached and which agents should do it. Before anything reaches me, she reviews the result. She doesn’t repeat Deen Wong’s analysis. She challenges it. She checks the evidence, questions the assumptions, flags risks, and preserves the full reasoning chain so I can inspect it myself.

Each role has a different responsibility. More importantly, each can fail independently.

I retain all final decisions. The agents produce decision support, not decisions.

The False Floor

When I first built the system, role separation was the only architectural principle I had implemented.

Mira reviewed a pool of shortlisted swing trade candidates each week and recommended which stocks had the potential to enter the market. The system worked from price, trend direction, and basic market signals. Like most AI-assisted analysis, it formed a view from whatever information was immediately available.

The second iteration changed one thing that mattered: the analysis could now be challenged before it reached me.

Kabee no longer worked from a snapshot. He built a growing historical dataset, fetching 60 days of market data at setup and adding a new trading day with every review. Deen Wong became responsible for the analysis, working from that historical foundation. Mira no longer analyzed the market herself. She reviewed Deen Wong’s work before anything reached me.

The difference wasn’t just more data; it was whether the system’s assumptions could survive independent review.

One recommendation made the difference obvious.

Alibaba was ranked as the highest-priority setup. Entry at HKD104.50. Support identified near HKD 104-105. Recommendation: place the limit order.

The recommendation looked reasonable.

Mira reviewed the analysis. The support zone wasn’t verified. It was an inference based on a round-number price level.

When she checked the historical price action, the nearest confirmed support sat above the proposed entry. There was no evidence that buyers had ever defended HKD 104.50.

There was nothing proven beneath it.

Mira rejected Alibaba.

The system surfaced a different opportunity instead.

Deen Wong had access to the same data. His job was to interpret the evidence.

Mira’s job was to determine whether the evidence actually supported the conclusion.

The quality of the decision changed because the responsibilities stayed separate.

Independent Review Changes the Outcome

The False Floor is one example of what Mira does, but it understates her role.

Kabee gathers evidence. Deen Wong draws a view from it. Mira’s purpose is different.

Mira doesn’t just check whether Deen Wong’s conclusions are correct. Her only job is to make my decisions better informed. That’s a different job, and it’s the one that changes outcomes.

Sometimes that means questioning the evidence.

Sometimes it means challenging the assumptions behind the analysis.

Sometimes it means looking beyond an individual recommendation and recognizing a risk the analyst wasn’t trying to solve.

When two positions in the pool moved underwater during the same market selloff, Mira flagged the overallocation before I asked. Deen Wong assessed each position individually. Mira looked across the portfolio.

When a stock closed near the bottom of its daily range for three consecutive sessions, Mira questioned whether the same price action could also indicate active distribution. The data hadn’t changed. The decision changed because another interpretation was considered.

She also preserves the complete reasoning chain. If I disagree with her recommendation, I can inspect every step myself before deciding what to do.

She doesn’t make the decision. She makes sure I make a better-informed one.

The System That Accumulates

The trading system doesn’t improve because the models change; it improves because the system remembers.

The first iteration is based on a snapshot of the market. Every review after that builds on a longer history. Kabee appends a new trading day every time the review runs. Every indicator has another observation. Every pattern has another opportunity to prove itself or fail.

The analysis on June 20 was better than the analysis on June 9. Not because the model became smarter, but because the system had eleven more days of evidence to work from.

The same principle appears throughout the rest of my AI system.

Some components accumulate historical data.

Others provide domain knowledge before work begins.

Others preserve the decisions, reasoning, and lessons from previous work so they don’t disappear when the conversation ends.

Different kinds of context. The same purpose.

Intelligence doesn’t compound, but context does.

Every AI system either builds on what it already knows or starts from zero each time.

Cognitive Partnership

The trading system became a reference implementation—a domain I could observe in detail, where failure modes were visible, and results were measurable. The same architecture applies wherever decisions depend on separating evidence, interpretation, and independent review.

That’s cognitive partnership: AI structured not to replace judgment, but to make the inputs to judgment more reliable. The reasoning chain stays visible. The human stays informed.

I started this experiment trying to build a better analyst.

I finished it, realizing I was actually designing an organization.

Better models help. Better architecture changes what the system can do.

I no longer have to wonder whether the problem was the evidence, the analysis, or the conclusion.

I know where to look.

This article is the first in an ongoing series documenting my personal role-based AI architecture. Future articles will explore how context accumulates, how persistent memory changes AI behavior, why cognitive responsibilities matter more than prompts, and how these principles apply beyond investment research.

Notes: The process described here reflects my personal work on my own infrastructure. It does not represent any company practices or policies. Trading involves risk; this is not investment advice.