Most bots fire signals based on a crossing of lines or a threshold hit. They don't know *why* they entered — they just did.

I took a different approach. Every trade starts with a written thesis from the AI agent:

> *"MARKET CONTEXT: BIP-20DEC30-CDE is trading at $68,700 in clear price discovery above Macro POC ($63,994.60); 6H Macro Tide (+575,192.53) and 1H Macro Trend (+501,316.74) demonstrate dominant institutional spot and futures buyer aggression; order book reflects sustained bullish asymmetry (3,362 immediate / 39,404 deep bids vs 2,658 / 25,213 asks) reinforced by primary bid wall at $68,550 (3,034 contracts); Open Interest is expanding robustly at 220,248 with balanced 8.76% annualized funding.

| ALPHA THESIS: Uncontested multi-timeframe CVD momentum combined with thick passive bid absorption provides high-velocity continuation setup; executing momentum market buy with 2.5x 1H ATR ($523.93) downside insulation and targeting 4.5x 1H ATR expansion into overhead liquidity voids.

| EXIT CONDITIONS: Hard invalidation stop at $67,390.17; take profit target at $71,057.69 (R:R 1.80:1); trailing stop tripwire activated upon +0.8% advance with 0.25% trail step."*

Original Working Thesis

That thesis is attached to the trade. It's not just a log entry — it's the framework WATCHDOG uses to manage the position.

**Here's what happens while the trade is open:**

The AI that manages risk (WATCHDOG) reads the original thesis and checks: *"Is the market still behaving the way the thesis predicted?"*

Gemini 3.7 Flash analyzing current open trade and thesis

If BTC drops but the macro structure is intact → WATCHDOG holds position.

Active trade that the agent decides to HOLD

If the regime flips from expansion to distribution → WATCHDOG exits regardless of price.

**When the trade closes:**

The system runs an autopsy. Did the thesis predict correctly? Was the lesson learned worth remembering? The result gets scored across 6 factors — recency, PnL impact, regime match, and crucially, a **+50% loss bonus** so bad trades are weighted heavier in memory.

Post Mortem after every closed trade dissected and saved to core memory on next signal

**The loop:**

Signal → AI writes thesis → Trade executes with thesis →

WATCHDOG manages against thesis → Trade closes →

Autopsy grades thesis → Core memory stores lesson →

Next signal: AI reads past lessons before writing new thesis

| Feature | Most bots | This system |

| Entry reason | Lines crossed | Written thesis from AI |

| Trade management | Hard TP/SL | Thesis-aware risk management |

| Post-trade | Nothing | Autopsy + scored memory |

| Next trade | Same as last | Informed by past lessons |

Most platforms do ONE piece of this. This does the whole loop.

A month ago, I shared an initial overview of the quantitative engine I've been building (Archon/Vortex stack). The main feedback was clear: stop talking about lines of code or architecture and show actual, live performance.

Source (excl. tests): 858 files — ~198k non-blank lines
Tests: 301 files — ~61k non-blank linesSource (excl. tests): 858 files — ~198k non-blank lines
Tests: 301 files — ~61k non-blank lines

Here are the 30-day live trading results on Alpaca from July 14 to August 16:

• Starting Portfolio Value: $94,840.00
• Current Portfolio Value: $99,468.84
• Net Realized Gain: +$4,628.84 (+4.88%)
• Asset Focus: Liquid large-cap equities (e.g., INTC blocks)
• Execution Model: Automated entry/exit routing with strict local risk limits and automated fail-safes.

What Changed & How It's Operating:

• Execution over Theory: All trades shown are executed live via broker API handshakes, factoring in all real fees and slippage.
• Strict Risk Budgeting: Maximum Adverse Excursion (MAE) circuit breakers prevent runaway drawdowns on volatile opens.
• Local Footprint: The execution layer runs fully locally (under 500 MB RAM), keeping operational and cloud infrastructure overhead at zero.

Date	Fills	Round Trips	Avg Edge/sh	Fees	Rejections	Maker %	Daily Realized PnL	Portfolio NAV
2026-07-10	4	1	+0.00006	$0.01	64	100%	+$0.00	$94,840.00
2026-07-13	0	0	+0.00000	$0.00	900	0%	+$0.00	$94,840.00
2026-07-14	26	6	+0.00196	$0.02	1,975	100%	+$2.10	$94,842.10
2026-07-15	137	24	+0.00321	$0.68	17,205	100%	+$13.20	$94,855.30
2026-07-16	138	26	+0.00296	$0.65	15,852	100%	+$13.20	$94,868.50
2026-07-17	55	12	+0.00183	$0.26	20,383	100%	+$3.70	$94,872.20
2026-07-20	67	17	+0.00214	$0.36	13,390	100%	+$6.20	$94,878.40
2026-07-21	60	13	+0.00171	$0.29	19,481	100%	+$3.70	$94,882.10
2026-07-22	104	23	+0.00334	$0.43	19,022	100%	+$13.40	$94,895.50
2026-07-23	220	33	+0.00338	$3.60	11,769	100%	+$16.50	$94,912.00
2026-07-24	131	23	+0.13736	$0.67	12,375	100%	+$568.00	$95,480.00
2026-07-26	0	0	+0.00000	$0.00	45	0%	+$0.00	$95,480.00
2026-07-27	774	157	+0.03696	$4.59	8,800	100%	+$1,040.00	$96,520.00
2026-07-28	602	133	+0.01223	$2.76	8,656	100%	+$290.00	$96,810.00
2026-07-29	507	119	+0.01370	$3.41	10,174	100%	+$290.00	$97,100.00
2026-07-30	771	160	+0.00844	$2.98	10,245	100%	+$240.00	$97,340.00
2026-07-31	860	177	+0.00576	$3.59	8,881	100%	+$180.00	$97,520.00
2026-08-03	720	139	+0.00174	$3.59	6,547	100%	+$40.00	$97,560.00
2026-08-04	785	172	+0.00528	$3.62	8,154	100%	+$160.00	$97,720.00
2026-08-05	658	136	+0.01074	$2.91	18,262	100%	+$260.00	$97,980.00
2026-08-06	838	174	+0.01194	$3.81	7,395	100%	+$370.00	$98,350.00
2026-08-07	206	41	+0.00824	$0.81	1,363	100%	+$60.00	$98,410.00
2026-08-10	643	128	+0.01361	$3.64	11,578	100%	+$310.00	$98,720.00
2026-08-11	877	174	+0.01067	$4.18	16,122	100%	+$330.00	$99,050.00
2026-08-12	0	0	+0.00000	$0.00	0	0%	+$0.00	$99,050.00
2026-08-13	707	163	+0.00797	$3.74	7,297	100%	+$230.00	$99,280.00
2026-08-14	788	167	+0.00641	$3.82	15,228	100%	+$188.84	$99,468.84

After months of development, I’ve added a visual no-code strategy builder to CoreCandle. It’s already working in beta.
Instead of writing Pine Script or MQL, you build strategies by connecting conditions visually, then backtest them on historical market data.
Current beta features include:
Visual no-code strategy builder
Historical backtesting
Backtest data sourced directly from MetaTrader 5 (MT5) or imported from CSV files
Multiple technical indicators
Configurable entry and exit conditions
Performance statistics after each backtest
I’m looking for feedback from traders and strategy developers before the public release.
Some questions:
Is MT5 and CSV import enough for your backtesting workflow, or would you want additional data sources?
What feature would make you switch from Pine Script or MQL?
What’s missing from current no-code strategy builders?
What would you test first if you had access?
Constructive feedback is appreciated. My goal is to make strategy development accessible to traders who don’t want to write code.

One of the metrics I consider most relevant when evaluating a systematic strategy is mathematical expectancy (Expected Value / EV).

In trading, it is quite common to use the win rate as an initial measure of a strategy’s quality. However, the percentage of winning trades by itself tells us very little about its expected profitability.

A strategy can have a high win rate and still have negative mathematical expectancy. Likewise, a strategy with a relatively low win rate can have a positive expectancy.

Mathematical expectancy aims to quantify the average expected outcome per trade if a strategy were executed a sufficiently large number of times under comparable conditions.

In simplified terms:

EV = (P(win) × Avg. Win) − (P(loss) × Avg. Loss)

To make this more tangible, rather than keeping it purely theoretical, I wanted to show it using a real backtest example.

At first glance, there is one number that immediately stands out: only 35.92% of the trades were winners, while 64.08% were losers.

If we only looked at the win rate, we could quickly conclude that the strategy does not work. However, once we take the average size of the winning and losing trades into account, the picture changes.

The average winning trade was 2,756.75, while the average losing trade was 1,082.42.

In other words, the winning trades were, on average, considerably larger than the losing trades. The report shows an Expected Payoff of 1.43, indicating a positive expected value per trade within this backtest.

And this is, in my opinion, one of the most interesting aspects of quantitative analysis:

A strategy does not need to win the majority of its trades to have positive expectancy.

The win rate is only one part of the distribution of outcomes. To properly evaluate a strategy, we need to consider the win rate, average win, average loss, number of observations, and the stability of the results together.

Of course, a positive Expected Payoff in a backtest is not enough to conclude that a strategy has a robust statistical edge. We would still need to analyze factors such as the period tested, out-of-sample data, overfitting, execution costs, slippage, parameter stability, and how the strategy behaves under different market conditions.

I’ve spent the past several months building a proprietary Market Intelligence (MI) engine for my trading platform.
Rather than generating opinions like a chatbot, the engine combines multiple market factors into a probability-based assessment. It continuously evaluates historical outcomes and adjusts the weighting of different signals based on how accurately they aligned with actual market behavior.
It currently analyzes factors such as:
Trend
Momentum
Volume
Support & resistance
Chart patterns
Multi-timeframe alignment
Economic events
The goal isn’t to replace a trader’s judgment, but to provide a concise view of market conditions, confidence, and risk before making a decision.
I’m still validating and improving the engine, so I’d really appreciate feedback from experienced traders.
What would you want a tool like this to show?
What would make you trust it?
What would make it genuinely useful instead of just another indicator?
I’m happy to answer questions about the design and validation process.

BACKGROUND

I’m a Python programmer by profession. Eight years ago, I quit my job and started building crypto arbitrage bots. In the beginning, even the most primitive script running across exchanges could be profitable. Then the market became increasingly professional, and I had to look for more and more complicated and sophisticated algorithms.

About a year ago, I shut down all my arbitrage bots because they simply stopped working, and I was no longer able to come up with anything new. I did make good money from them, though, and essentially without taking much risk (delta-neutral arbitrage).

I started looking for a different approach, this time with actual market risk on perps. I combined several ideas that had occurred to me over the years.

I should point out upfront that I don’t use, or even believe in, technical analysis - especially when it comes to crypto.

EDGE

The main thesis behind the strategy is that ~100% of tokens are shitcoins with no fundamental value beyond speculation, driven almost entirely by retail greed.

Over the long term, every shitcoin will lose most of its ATH - it’s simply a matter of time. The downward gravitational force on price is further amplified by continuous inflation (emissions, unlocks) and market dilution from constantly listing new shitcoins.

ALGORITHM

In very simple terms, we take the top 50–200 tokens by market cap, with a primitive filter requiring them to be at least 1.5 years old. The goal is to minimize the risk of a speculative 10x–50x pump in a newly launched asset.

The position is built using limit SELL orders, but the grid is dynamic and designed to target mean reversion.

Each token has a predefined maximum dollar position size up to which the strategy is allowed to average in. During each loop cycle (typically every 1–2 hours), the algorithm places a SELL order for each token representing a fraction of its target position size.

Typically, we place the order at a price 3–6% above the current market price. If the order doesn’t fill, it is cancelled during the next cycle and replaced based on the current market price and current total equity.

In other words, we are trying to capture local spikes and betting on a retracement.

The basket of shitcoin shorts is hedged with a BTC long at roughly a 1:1 ratio. The BTC long is primarily there to maximize margin efficiency and mitigate the effects of altseasons.

Profit is realized gradually whenever reducing the token position plus the corresponding portion of BTC results in a profit. Typically, we start reducing the position once the combined P&L reaches around +2%.

If a token position exceeds its target value, it is cut using a market order at a loss.

The parameters are slightly adjusted in real time based on a hype_score (Google Trends, volume, price momentum). The algorithm switches into defensive mode as the market starts heating up.

The strategy currently runs across 20 instances, each slightly differently tuned for diversification.

RESULTS / RISKS

The strategy will blow up during an extremely strong altseason - something like 2021: COVID + stimulus + a young market, where literally every shitcoin was doing 10x every month.

Individual token explosions will reduce profitability, but they are not necessarily a threat given how broad the basket is.

I built a very detailed exchange-engine model to simulate execution down to 1-minute candles.

Based on numerous simulations, I’m targeting a CAGR of >150–200% with a maximum drawdown of 50–60%. I put $2.1M into production (21 instances per 100k).

Obviously, the potential risk/profit profile can be reduced, but personally I believe crypto altseasons will become weaker over time, so YOLO.

The main backtests start from 2024. Going further back doesn’t make much sense because there simply aren’t enough old tokens to construct the basket properly.

Funding fees eat up around 10–20% of the profit.

The high drawdown is unfortunately an expected consequence of the strategy during altseasons (12/2024, 07/2025).

Under the fundamental assumption that we don’t include very young shitcoins, it is difficult to find a set of parameters under which the strategy generates a loss.

I also ran stress tests by drastically reducing the token-age filter to just a few months. The strategy still produces high returns, but with an even deeper maximum drawdown.

So far, the live production results are consistent with the model, although the program has only been running for a few months.

WILL IT BLOW ME UP OR NOT?

Hello Reddit community!

This is my first post on this platform, and I'd like to introduce myself. I'm 29 years old and currently finishing my CMT certification (it was taken by Ivan Scherman, a world champion futures trader). In parallel, I develop algorithmic and quantitative systems applied to the market.

What I'm looking for is to find recurring market patterns and, based on them, develop strategies with a positive expected value.

I'm not simply looking to do trend following or mean reversion, etc. My approach is to first study the specific statistics of each asset and timeframe.

For example: How does this asset move on this timeframe? (Because you can have a system that's mean reversion on the 1-hour chart and trend following on the 4-hour or daily chart for the same asset; that also reveals portfolio mismatches.) What patterns does it repeat? Under what conditions does the behavior I'm looking for appear? And, above all, does that behavior have enough statistical evidence to become a strategy with a positive expected value? From there, I develop and test different strategies and algorithmic systems. These are some of my trades. Feel free to ask me anything you want about them, the strategies, what variables I analyze, or how I'm testing them. I would also appreciate your feedback.

I also have a Telegram group where I share the development of the systems, trades, analyses, and various tests I conduct.

The idea is to share the process and build a community interested in quantitative trading, algorithmic systems, and statistics applied to the market.

so i’ve been building this crypto quantative rebalancer with deleverage and made a lot of backtracking strategies , but i realized a big problem: my backtests assumed perfect execution. buying exactly on the dot every time.
but nobody trades like that…..people get paid late, get lazy, or just straight up forget. if my risk algo only works for a perfect robot, it doesnt work at all.
so i did a "human stress test" on 6 years of data. i messed up the execution to simulate a real lazy human (delays, wrong amounts, skipped months). the main point wasn't to see if sloppy DCA is worse than perfect DCA (obviously it is). i wanted to see if the drawdown protection breaks when the operator is sloppy.
honestly the results shocked me. the protection barely cared.
the absolute worst case with everything going wrong at once only messed up the max drawdown by like 0.5%. on a log scale, the perfect robot line and the chaotic human line look almost exactly the same. the protection hit the exact same depths at the exact same times;)
i did hit one weird glitch though. the skipped month scenario showed a slightly HIGHER sharpe ratio. for a second i thought being lazy was alpha?? but no, it was just a math illusion. skipping months meant less total capital. in a rising market, deploying less total money makes the invested part look like it had a higher % return. the denominator just got smaller.
it held up because the risk engine is completely decoupled from when cash arrives. it calculates signals based on portfolio volatility, not deposit schedules.
long story short, test your strategies against your own future laziness. it costs nothing to feed messy schedules into your backtester. if your protection breaks just because you were a few days late, you want to know about it before the market crashes.
anyone else ever tried messing up their backtest data like this?

He claims he started with only $68, made $6,732 during his first night and later reached around $750,000 in total profit. Crazy numbers, although I’d definitely want to see verified trading history before believing all of it.

What interested me more was how this bot supposedly works.

It monitors more than 50 markets simultaneously and receives live BTC price data every second. When a short-term price difference appears between markets, software detects it and can react within seconds.

Instead of sitting in front of charts all day and manually comparing prices, he automated almost everything.

He even used an iPad as a second screen to monitor what was happening while his system kept scanning markets 24/7.

Even if that $750K number turns out to be exaggerated, building a working trading system in around 48 hours is still pretty interesting.

A few years ago, creating something like this required much more coding experience and development time. AI tools have made it possible for individual developers to prototype complicated systems much faster.

Building a bot is still one thing. Making it consistently profitable after fees, slippage, latency and changing market conditions is completely different.

But a 19-year-old building this over a weekend shows how much easier automated trading has become to experiment with.

Has anyone here tried building something similar? How did it perform once you moved beyond backtesting?

I’ve been working on this algo for a few weeks and this is roughly 3 weeks of results.

Current crypto strategy is around 59% win rate across ~214 trades, but performance varies a lot depending on strategy, direction, and market conditions.
I’m trying to figure out the next step.

Would you focus on:
reducing the number of trades and making the entry filters stricter,
keeping trade frequency similar and improving the logic,
or just collecting more forward data before making more changes?

I’m especially interested in how you decide when an algo is trading too often versus when it simply needs better filtering.