Building Aegis, and Why I Stopped

Why I Built Aegis

First of all, I like money.

The first money I ever earned actually came from the financial markets—specifically, crypto.

This happened around 2021, during the pandemic. I was in my final year of high school and had already finished my college entrance exams, so I had roughly four months of free time before university started.

Four months of doing absolutely nothing would've driven me insane. I have this tendency where, if I stay idle for too long, I start thinking that I'm falling behind or won't become the person I want to be.

At the same time, crypto was in a raging bull market. Monetary conditions were extremely loose during COVID, and almost everything seemed to go up.

Naturally, everyone suddenly became "very smart" at investing.

Including me.

Like many beginners who made some money and immediately wanted more, I started wondering how I could make money faster. That eventually led me into futures trading.

I learned from online materials and other traders. At first, I was obsessed with chart patterns: triangles, flags, wedges, and everything in between.

Basically, I was worshipping patterns.

Then the beginner's luck ended.

A large market flush wiped out essentially all of my trading capital, including the profits I had made.

That experience changed how I looked at trading. I stopped trading futures for a while and became much more interested in understanding what was happening underneath price movements.

I started studying support and resistance, supply and demand, volume, price compression, fair-value gaps, market structure, and trader behavior.

Over time, this approach felt much more natural to me, especially on longer timeframes. Instead of trying to guess where the next candle would go, I felt like I was developing some ability to "read" what the market was doing.

And being an engineer, I eventually had the obvious thought:

Can I automate this?

That question became Aegis.

Attempt #1: Predicting Price with an LSTM

As a relatively new engineer, my first instinct was theory-first: look for existing research before trying to invent something myself.

I found several papers using LSTMs for financial time-series prediction. The argument made intuitive sense to me: LSTMs are designed to learn sequential dependencies, and market data is inherently sequential.

At the time, I completely bought into this idea.

I collected historical BTC/USDT data and started building features such as price changes, candle amplitude, volume, number of trades, and taker ratios.

Initially, I followed features used in previous research. Later, I added my own, mostly technical indicators such as RSI, MACD, ATR, Bollinger Bands, and stochastic oscillators.

I also changed the target.

Instead of asking the model to predict an exact future price, I thought it would be more useful to predict direction: whether the price would move enough upward, downward, or neither within some future window.

My thinking was that I didn't really need to know the exact future price. If I could reliably predict direction, risk management such as stop losses and trailing stops could handle the rest.

Then came the tuning.

I experimented with different lookback windows, batch sizes, numbers of LSTM neurons, learning rates, profit/loss thresholds, and time barriers.

After more than ten experiments, however, the results kept hovering around the same place: roughly 50% accuracy and around 51% F1.

At the same time, I was reading more about quantitative finance and financial machine learning.

And the more I read, the less surprised I became by those results.

The problem was slowly changing in my head.

Instead of asking:

"How do I tune this model better?"

I started asking:

"What information am I expecting this model to discover in the first place?"

What I Got Wrong About Indicators

Initially, I thought adding more technical indicators would improve the model.

After all, I personally looked at RSI, MACD, volume, and other indicators while trading. Surely giving the model more of them should help.

But eventually I realized something obvious in hindsight:

Most technical indicators are transformations of information I already had.

RSI comes from historical price movements. MACD comes from moving averages of price. ATR measures historical volatility. Bollinger Bands are also constructed from previous prices.

So I wasn't necessarily giving the model new information.

I was often doing something closer to:

price history → mathematical transformation → model → future price

That doesn't mean technical indicators are useless. A transformation can still expose useful structure or make certain relationships easier to detect.

But an indicator visually moving together with price is not evidence that it contains a reliable predictive edge.

This was where one of those simple sentences finally clicked for me: Correlation does not imply causation.

RSI, MACD, or another indicator moving alongside price doesn't mean the indicator is causing, or even reliably predicting, the next price movement. In many cases, the correlation exists precisely because the indicator itself is mathematically derived from historical price. I had been looking at that relationship and unconsciously treating correlation as predictive information.

It also made me much more skeptical whenever I saw someone advertising a "100% accurate indicator."

If something publicly available could reliably print money with almost no effort, I would first ask why that opportunity hadn't already been competed away.

Attempt #2: Encode How I Actually Trade

So I changed direction.

Instead of asking a model to discover a trading strategy for me, I decided to encode the discretionary strategy I was already using manually.

The goal became conceptually simpler:

Build a rule-based system that trades according to explicitly defined market conditions.

Aegis would try to detect things I normally looked for myself:

• supply and demand zones
• market structure
• higher highs and higher lows
• lower highs and lower lows
• sideways consolidation
• volume confirmation
• breakouts
• entry confirmation
• risk management

The idea wasn't just to ask whether price was going up or down.

It was to understand the context around the movement.

Why is price reacting here? Is this area significant? Is market structure changing? Is a breakout supported by volume? Are multiple signals pointing in the same direction?

Turning Trading Intuition Into Code

This turned out to be much harder than I expected.

Humans can look at a chart and casually say:

"That's a support zone."

But a computer immediately asks questions.

Where exactly does the zone start?

How wide should it be?

How many times can price touch it before it becomes weak?

When does support become resistance?

What exactly counts as a swing high?

How large does a move need to be before it becomes meaningful?

A large part of Aegis became an attempt to convert these fuzzy human concepts into deterministic rules.

Eventually, I had separate components responsible for market structure, supply and demand zones, sideways markets, signal generation, position management, and live exchange data.

Then I built my own walk-forward backtesting engine around it.

Initially, the results looked promising.

That optimism didn't last very long.

After auditing the backtesting implementation, I found mistakes in areas such as compounding and other calculations. Some of the bugs were embarrassingly trivial—but trivial bugs inside a backtester can create very non-trivial conclusions.

That taught me another lesson:

If you build both the strategy and the system responsible for judging that strategy, bugs in the judge can make the strategy look much better than it actually is.

Even after fixing those issues, I still wasn't completely comfortable with the historical data.

Most of my dataset covered roughly 2019–2024: COVID, extraordinary monetary stimulus, a massive crypto bull market, aggressive monetary tightening afterward, and several crypto-specific events.

That's a lot of candles.

But it isn't necessarily a lot of independent market regimes.

I eventually deployed Aegis against live market data in paper-trading mode.

I gave it $10,000 of simulated capital and let it run for roughly eight weeks.

It finished down around 3%.

The 3% loss itself wasn't enough to prove that the strategy didn't work. Any profitable strategy can experience drawdowns.

What bothered me more was that I was becoming less and less confident about why the strategy should work in the first place.

And that eventually became a much bigger problem than the drawdown.

Where Is the Edge?

After reading more books and research papers, I started questioning something much more fundamental.

Where was my edge actually coming from?

Most of the concepts I was using—support and resistance, supply and demand, market structure, volume, momentum, and breakouts—have been known and used by traders for decades.

That doesn't necessarily mean they cannot work. I've seen traders use very similar strategies successfully.

Maybe they found better parameters. Maybe they apply the strategy only under particular market conditions. Maybe their real advantage comes from execution, discipline, or risk management.

But it made it much harder for me to justify why my implementation should consistently generate excess returns.

Professional quantitative firms spend enormous amounts of effort researching signals, testing hypotheses, building models, improving execution, and continuously evaluating whether their strategies still behave as expected.

And those models aren't exactly "fire and forget."

An edge can weaken as market participants adapt, conditions change, or more capital starts exploiting the same opportunity.

Strategies therefore need to be monitored and reevaluated continuously.

When I compared that process with what I was doing, the gap felt too wide.

Not just in mathematical knowledge or modeling experience, but simply in experience itself.

I was still very new to systematic trading.

Why I Stopped Aegis

Eventually, I decided to stop developing Aegis.

Not because the code was impossible to build.

Not because it lost around 3% during paper trading.

I stopped because I realized that I was engineering the system much faster than I was discovering the edge behind it.

I could keep improving the architecture, adding detectors, tuning parameters, fixing the backtester, and making the execution engine better.

But none of those improvements answered the most important question:

Why should this strategy consistently make money?

My perspective on short-term trading also changed.

At very short horizons, you're competing against other traders, algorithms, market makers, and professional firms for relatively small opportunities.

In derivatives especially, trading P&L is largely a transfer between participants before transaction costs.

Then you add fees, spreads, slippage, and execution differences.

That made me realize that I wasn't only trying to predict the market.

I was trying to outperform everyone else who was trying to do the same thing.

What Aegis Changed About How I Trade

Long before I stopped Aegis completely, my preferred timeframe had already started shifting.

I gradually moved from active short-term trading toward longer-term positions and investing.

Fortunately, I can do that now because I have a stable active income. That wasn't the case when I first entered the market, when making money quickly was a much bigger motivation behind trading.

Now I'm much more interested in compounding.

I would rather find something that I believe is worth owning after doing deeper research—especially fundamental research—and then use parts of my old discretionary strategy to improve my entry price.

Interestingly, my experience also became much better after moving toward larger timeframes.

I don't have a calculated win rate to prove this, so I won't pretend that I do. But personally, the returns have felt more reasonable compared with constantly trading short-term moves.

More importantly, the mental cost is dramatically lower.

I don't need to check my PnL every few minutes, every morning, or every time the market moves.

I can simply let the position sit and give the thesis time to play out.

This is similar to an idea I took from Morgan Housel's writing: investing doesn't necessarily need to be perfectly rational in some mathematical sense. It needs to be reasonable enough that you can actually stick with it.

Short-term volatility becomes something closer to the admission price for pursuing long-term returns.

My emotions changed too.

Years ago, opening a trade made me excited. I would constantly imagine the position closing in profit.

Now, most of the time, I feel almost nothing.

The goal of the transaction changed.

I'm no longer primarily looking for an immediate result. I'm positioning capital based on something I believe may play out over a much longer period.

Eventually, I asked myself:

If the slower approach already gives me returns that I consider reasonable, why should I deliberately enter a harder game with more risk just to chase returns that aren't guaranteed anyway?

Of course, I'd still love to build a system that can steadily generate returns.

Maybe one day I'll discover some ridiculously simple, non-ubiquitous mathematical relationship mixed with discretionary information that somehow lets me beat the hell out of the quants.

Who knows.

But Aegis isn't there yet.

Lesson Learned: AI Can Build the System, but It Can't Give You the Edge

AI was heavily involved throughout Aegis's development.

Claude, Gemini, and other models helped me implement components, debug problems, review ideas, and sometimes challenge my assumptions.

And on days when I was lazy, I would absolutely just ask the AI:

"How should I solve this?"

But eventually I realized there was a dangerous implication here.

AI is extremely good at helping you implement knowledge that already exists.

It can explain established strategies, combine known ideas, generate code, suggest statistical methods, and explore a huge conceptual space much faster than I can manually.

But none of that means the resulting strategy contains an edge.

If I can ask an AI:

"Give me a trading strategy using RSI, market structure, volume, and supply/demand,"

then millions of other people can ask essentially the same question.

AI dramatically reduces the cost of building trading systems.

But reducing the engineering cost doesn't automatically increase the informational advantage of the strategy.

That might be one of the biggest things Aegis taught me.

AI can help me build the machine much faster. It cannot guarantee that the machine knows something the market doesn't.

What I'd Do Differently If I Built Aegis Again

If I ever revisit Aegis, there are several things I would approach differently.

First, I would spend much more time on the literature and mathematical foundations before committing to an implementation.

During Aegis, I sometimes moved too quickly from reading about an idea to asking AI to help me build it. If I tried again, I would want a much stronger understanding of the underlying modeling assumptions before touching the implementation.

Second, I would keep a proper experiment log.

Every hypothesis, parameter change, dataset, result, and failure should be recorded in a way that makes the experiment traceable and reproducible.

A lot of my early experimentation was closer to:

"Let's change this and see what happens."

That makes it surprisingly difficult to understand later why one version behaved differently from another.

Third, I would never underestimate the backtesting engine again.

Initially, I more or less one-shotted the backtester with AI because I assumed it would mostly be:

buy here → sell there → calculate the difference.

It wasn't.

After a few experiments, a significant part of my effort shifted away from the actual strategy and toward validating and fixing the system that was supposed to evaluate it.

Finally, I would rely much less on AI for discovering the edge itself.

AI can help me understand papers, implement models, challenge assumptions, write experiments, and audit code.

But I shouldn't outsource the core research question to it.

If I'm looking for something genuinely underexplored, then I need to do the work myself: study the market, form hypotheses, gather evidence, test them, and potentially find something that isn't already ubiquitous.

AI should amplify that process.

It shouldn't replace it.

Conclusion

Aegis started from a pretty simple idea: if I could understand how I trade, maybe I could teach a machine to do the same thing for me.

What I didn't expect was that the engineering would become the easier part.

I could build the models, detectors, execution logic, backtester, and eventually even run the system against live market data.

But none of that automatically answered the most important question:

Where does the edge actually come from?

That question eventually became more important to me than whether Aegis could technically place profitable trades.

Looking back, I don't really see Aegis as a failed project.

It forced me to learn about financial machine learning, systematic trading, backtesting, market structure, risk, and—probably most importantly—how easy it is to convince yourself that something works when you're also the person building the system that evaluates it.

It also changed how I think about AI.

AI can drastically accelerate research and engineering, but making something easier to build doesn't necessarily make the underlying idea better.

So for now, Aegis is stopped.

Maybe I'll return to it one day if I find something that I genuinely believe gives me an edge worth testing.

Until then, I'd rather leave it unfinished than keep engineering a very sophisticated machine without being able to explain why it should make money.