DEV Community: Jerry Chen

84% of crypto traders lost money last year. Their analysis wasn't the problem.

Jerry Chen — Sat, 06 Jun 2026 16:38:31 +0000

Start with the number, because the number is the whole argument. An August 2025 survey of more than 1,000 retail crypto traders found that 84% lost money inside their first year.

The reflex, when you read a stat like that, is to picture the losers as clueless. Couldn't read a chart. Bought every top, sold every bottom, fell for the obvious rug pulls.

That story is comforting and mostly wrong.

Plenty of losing traders find perfectly good setups. They read the chart fine. They size the first trade sensibly. And then they lose anyway — because of what they do after the setup goes live. They oversize the next one. They move a stop the second it's tested. They panic out of a position that was working. They revenge-trade the loss. They grab a tiny profit too early while letting a real loser run and run.

The analysis was never the bottleneck. The behavior was.

Two layers, and only one of them gets taught

Think of trading as two stacked layers.

The top layer is analysis: finding an entry with positive expectancy — a setup that, repeated a hundred times, makes money. The bottom layer is execution: actually taking those hundred trades the way the plan says, at the size the plan says, with the exit the plan says, while your own nervous system is screaming at you to do something else.

Almost all trading education sells the top layer. Indicators, patterns, frameworks, the perfect entry. But a positive-expectancy edge is fragile. It only survives if you execute it cleanly across a large sample.

Skip three losers because they scared you. Double-size two winners because you felt certain. Now the distribution you backtested is gone. You're trading a different, worse system — one you invented in real time, under stress, with money on the line.

Most traders don't have a strategy problem. They have a problem staying the same person between the moment they make the plan and the moment the plan gets tested.

Where the edge actually leaks

It helps to picture a sound setup entering on the left at full value, then passing through a chain of human decisions. At each one, a slice of that value leaks out. By the time the trade closes, you're left with a fraction of what you started with.

[suggested chart: where the edge leaks — a sound setup losing value at each behavioral stage]

Stage	What happens	What it costs you
FOMO entry	You chase a green candle	A worse price than the setup offered
Oversized	The position is too big to hold calmly	You can't sit through normal noise
Moved stop	Risk quietly widens	The loss you planned for grows
Panic / revenge	You exit at the worst tick, then re-enter angry	The remaining edge is gone

Direction was never the problem. Discipline was.

FOMO isn't a character flaw. It's the default setting.

It's tempting to read all of this as "weak traders lose, strong traders don't." The data says otherwise.

A 2024 Kraken survey of 1,248 crypto holders found that 84% admitted making investment decisions based on FOMO, and 63% reported portfolio losses tied to those emotional choices. Eighty-four percent. That's not a fringe of degenerate gamblers. That's nearly everyone.

FOMO works on you because the market is engineered to manufacture it. A green candle on your screen while you're flat is a direct, physical prompt to act. It feels like information. It's usually just the worst available entry wearing a costume of urgency.

The traders who survive aren't immune to that pulse. They've simply put something between the pulse and the buy button.

The math that makes emotion expensive

There's a reason these mistakes cluster on the loss side.

Prospect theory — the work that won Kahneman a Nobel, built with Tversky — established that the pain of a loss is roughly twice as powerful as the pleasure of an equal gain. Loss aversion isn't a metaphor. It's a measurable asymmetry in how the brain weighs outcomes, and it quietly bends every decision you make under pressure.

Behavioral force	The finding	What it does to a trade
Loss aversion	A loss hurts ~2x as much as an equal gain feels good	Distorts every decision under stress
Disposition effect	Sell winners early, hold losers long	The exact opposite of "let winners run, cut losers fast"
Overtrading	More activity, worse returns	Drags performance before fees even hit

Watch that 2x play out. A winner moves into profit, and the dread of giving it back gets so sharp that you close early — booking a small gain just to make the bad feeling stop. A loser moves against you, and closing it would lock in that double-weighted pain, so you hold and hope.

That's the disposition effect — selling winners too soon, holding losers too long. It's one of the most replicated findings in behavioral finance, and it's the precise inverse of what a sound system needs.

Then layer on overtrading. Barber and Odean's research on retail traders showed, again and again, that the more people traded, the worse they did. Activity itself dragged returns down, before fees even entered the picture.

Put it together: a brain wired to chase, to oversize when confident, to bail when scared, to overtrade when bored, and to do exactly the wrong thing with both winners and losers. None of that gets fixed by a better indicator.

So the real question isn't "what's the strategy"

If the leak is at the execution layer, the fix has to live there too. And here's the uncomfortable part for anyone who loves the craft of analysis: the highest-leverage improvement most traders can make has nothing to do with finding better setups. It's removing the moments where they break their own plan.

You can attack that two ways.

The first is willpower — journaling, rules, meditation, screen-time limits. It helps, and it's worth doing. But it's fighting a 2x asymmetry with conscious effort, at 3 a.m., while your position is red. Willpower is a renewable resource that happens to run dry exactly when you need it most.

The second is structural: take the decision out of the moment entirely. That's the honest case for a rules-based approach. The value isn't that automation predicts better than you — it very likely doesn't. The value is that it doesn't feel FOMO when the candle is green, doesn't revenge-trade after a loss, doesn't move a stop because the position is uncomfortable, and doesn't size up because it feels sure. It runs the same plan at trade one and trade five hundred — the only condition under which an edge actually survives.

The takeaway most people learn the expensive way

The 84% figure isn't a verdict on anyone's intelligence. It's a verdict on a setup where a human is asked to be the disciplined executor of their own plan, in real time, against a brain wired to do the opposite. Most people lose that fight. Not because they couldn't find the trade — because they couldn't get out of their own way once they had it.

So before you go hunting for a better indicator, ask the more useful question: where does your edge leak after you find the setup?

That's the gap. Closing it — with rules, with structure, with something that doesn't feel the urge to break the plan — is worth more than any entry signal you'll ever find.

Author's note: I write about discipline-first, rules-based trading at KYO Markets. If you want the longer version of this argument, with the full source list and the structural pieces that close these leaks, here's the full piece on KYO Markets.

Educational, not financial advice. Crypto is volatile and you can lose capital.

Your trading bot automated the wrong thing

Jerry Chen — Sat, 06 Jun 2026 16:38:27 +0000

Ask someone why their trading bot lost money and you'll get a story about the signal. The RSI threshold was off. The moving-average crossover was too slow. So they tune the entry again, like the entry was ever the thing that broke.

It almost never was.

Here's the part nobody sells a course on: a bot is just your rules, executed without hesitation. Good rule, and automation makes a good rule faster. Fragile rule, and automation makes a fragile rule faster — now running at 3 a.m. while you sleep, through a leverage move you'd have closed out of by hand. Industry reviews say this plainly: bots automate your strategy, a bad strategy still loses, and even semi-automated tools still need someone watching them (Blockster, 2026).

So "do crypto trading bots work" is the wrong question. The honest one is narrower: which part of trading did the bot actually automate, and is it the part that decides whether you keep your capital?

The trigger is the easy 5%

Pick almost any retail bot and look at what it does. It watches a feed, checks a condition, fires an order. Condition true, buy. Other condition true, sell. That's the entire decision surface for a huge number of "automated strategies." It's a thermostat with a brokerage account.

The trigger feels like the system because it's the visible part — the part you backtest, the part with the satisfying chart of green dots. But the entry signal is the cheapest, most replaceable component of any real trading process. Two traders can run the exact same crossover and one compounds while the other blows up, because everything that separated them happened around the trigger, not at it.

Most people pour their effort into the 5% that's easy to measure, because optimizing it produces a number and a chart. Meanwhile the 95% that actually decides the account — sizing, invalidation, behavior in a drawdown — gets a shrug and a manual override "when it matters." It always matters. And the manual override is you, tired, mid-drawdown, doing the exact thing the rules existed to prevent.

A bot without risk architecture is not a system. It's faster emotion.

The five questions a bot usually skips

[suggested chart: what most bots automate (signal → buy → signal → sell) vs. the five questions a system must answer]

Each of these is a decision that determines whether a string of trades compounds or quietly bleeds out. Almost none of them live inside a typical entry-signal bot.

Is the signal actually strong? One indicator on one timeframe is a coin flip dressed up as conviction. Confirmation across independent indicators is the difference between a setup and a hunch — and most bots fire on the first condition that turns true.
Do independent models agree? If two methods that share no inputs both point the same way, that's information. If your "system" is one model repeated, agreement is an illusion.
How much do I deploy right now? The single most outcome-defining number in trading, and the bare trigger never touches it. Go all-in on a signal and a slightly better one later doesn't matter — you're already maxed at the worst price.
What invalidates this trade? A real position has a price at which the thesis is simply wrong and you're out. "Hold and hope" is not invalidation. Many bots have an entry rule and a vibe for the exit.
What happens after a losing streak? Variance isn't optional. Strings of losses happen to correct strategies. Without a rule for the drawdown, the human takes over at the worst possible moment — and that's where accounts die.

The community reaches this the hard way, over and over. A widely shared breakdown of why most retail day-trading bots fail lands on three causes: untested strategies, zero built-in risk controls, and no live optimization (crypto.news, 2026). Two of those three are risk architecture, not signal quality. Sentiment on popular platforms reflects the same split — reviews of tools like Cryptohopper are mixed precisely because outcomes hinge on the user's own strategy and configuration, not the automation itself (Trustpilot).

Automation adds an attack surface, too

There's a second cost to handing a machine the keys, and it has nothing to do with strategy. Every bot that trades for you holds credentials that can move your money — API keys, exchange permissions, sometimes withdrawal rights. That's a surface that didn't exist when you traded by hand.

Not hypothetical. As reported, the 2022 3Commas incident exposed roughly 150,000 user API keys — a blunt reminder that "set and forget" widens the blast radius when something goes wrong (AMBCrypto, 2026). The regulatory side carries its own caveats: as reported, Pionex Inc. entered a multi-state US consent order in 2025 over unlicensed money transmission in some states, pionex.com was blacklisted by France's AMF, and warnings were issued in the Philippines and Malaysia (DayTrading.com). None of that is a verdict on any product's trading logic. The point is narrower: automation is a custody and operational decision, not only a strategy one — and the risk architecture has to cover that layer too.

Number	What it represents
~150K	user API keys exposed in the 3Commas incident, as reported (2022)
5	questions a system must answer beyond the trigger
1	risk layer most retail bots skip entirely

The real design question

Here's a sharper frame. The interesting question in automated trading isn't "what's the best entry signal." Best is unstable, crowded, and overfit the moment you find it. The interesting question is: what does the system do when it's wrong? Because it will be wrong, often, and the behavior in those moments is what separates a strategy from a story.

That reframes the whole build. You stop automating the part that feels smart and start automating the part that's hard to do under stress: sizing down instead of up, honoring the invalidation, sitting still through a losing streak, refusing to add leverage into a falling position. Those are exactly the actions a human fails at — which is the strongest argument for automating them, and the weakest argument for leaving them manual while you automate the easy trigger.

The right question isn't "what's the best entry?" It's "what does this do when it's wrong?"

So whatever you build, automate the part that decides outcomes and the part you fail at by hand. If your bot answers only "when do I enter," you've automated a thermostat and left the trading to your nervous system.

Author's note: I write about automation and risk design at KYO Markets. If you want the longer version — with the full decision stack and a worked example of automating the risk layer instead of the trigger — it's the full piece on KYO Markets.

Educational, not financial advice. Crypto is volatile and you can lose capital.

I watched 351,000 traders get liquidated in a day. Here's the part that actually matters.

Jerry Chen — Sat, 06 Jun 2026 16:38:23 +0000

On June 5, 2026, Bitcoin printed a $59,100 low and a single 24-hour window erased more than 351,000 leveraged accounts. Most people called it a crash. I don't think that word explains anything.

Here's the uncomfortable version. A lot of the traders who got wiped out that day were not wrong about direction. Plenty of them held positions that would have been perfectly fine a week later. They weren't removed from the market by a bad thesis. They were removed by a mechanism that doesn't care about the thesis at all.

That mechanism ran twice in four days. On June 2, roughly $1.8 billion in leveraged positions got force-closed, taking out about 272,000 accounts. Three days later it happened again, bigger: a $1.75 billion sweep, over 351,000 accounts, and Bitcoin tagging its lowest level of the year at $59,100 intraday. The derivatives data showed the same fingerprint both times.

Metric	Value
Accounts liquidated in 24h (June 5)	351,000+
Leveraged positions force-closed	$1.75B
Bitcoin intraday low (lowest of year)	$59,100
Total wiped across the two-day window	~$3B

A cascade is not a crash. It's a feedback loop.

A crash is a story about sellers and buyers deciding things. A cascade is a story about plumbing.

When a market is stuffed with leverage, every position has a price at which the exchange stops asking permission and closes it for you. That forced sale is itself a market sell order. It pushes price down a little. A little is enough to reach the next cluster of liquidation prices. Those close too. And the loop just runs until the leverage is gone.

Here's the shape of it:

Price breaks a key support level.
Stop and liquidation prices start triggering.
Forced selling dumps more market sell pressure into the book.
Price falls further, reaching new clusters of liquidation prices.
Repeat — until the excess leverage is cleared out.

That's why the people who got hurt the most weren't the bears or the bulls. They were the over-leveraged, on both sides. CoinDesk's read on the same window was blunt: the derivatives market was sending an unambiguous warning well before the second leg even started. The leverage was the fuel. The support break was just the match.

The asymmetry that does the real damage

There's a second mechanism stacked underneath the cascade, and it's pure arithmetic. Losses and recoveries are not symmetric. The deeper you fall, the more absurd the climb back gets.

[suggested chart: loss taken vs. gain needed to break even]

Loss taken	Gain needed to break even
-20%	+25%
-50%	+100%
-70%	+233%
-80%	+400%

Look at the bottom row. Down 80% — the kind of number a high-leverage liquidation produces — needs a 400% gain just to return to the starting line. Not to profit. To break even.

Leverage doesn't just increase your risk. It moves you up a curve where being wrong once becomes mathematically unrecoverable.

Put the two mechanisms together and you've got the full picture of June 5. Leverage pulls traders into positions that can be force-closed. The cascade guarantees those force-closes happen in clusters, at the worst possible prices. And the recovery math means that for the deepest accounts, there was no "wait for it to come back." The hole was too steep to climb out of.

So what actually survives a day like that?

Not a better prediction. Anyone telling you they have a model that called the exact $59,100 low is selling something, and you should keep your wallet closed.

The honest answer is structural. What survives a cascade is a position that was never sized to be a forced seller in the first place — plus a system that keeps following its own rules while everyone else is panicking.

This is the part that gets no airtime, because it isn't dramatic. There's no screenshot of a 50x win to post. But it's the entire game. A few things matter more than any forecast:

Capped, staged exposure. Instead of committing everything at one price, spread entries across planned levels with a hard cap on total exposure. A position that's capped and staged just isn't the kind of position that becomes a forced seller at the bottom of a wick.
A reserve buffer. Set aside part of your gains during the good periods so you have room to keep operating through a drawdown instead of getting knocked off plan. It's a buffer, not a guarantee — but it's the difference between a stressful week and a terminal one.
Rules that don't negotiate. The hardest thing to do at 3 a.m. during a $1.75B liquidation event is nothing. A rules-based approach does the nothing for you. It doesn't revenge trade, it doesn't move a stop, and it doesn't add leverage to "average down" into a falling knife.

None of this predicts the low. That was never the point. The point is to make a cascade something you watch from a position you can hold, instead of something that closes you out at the worst tick of the year. Survival first, performance second — because, as that recovery curve shows, you can't compound from zero.

The takeaway most traders learn too late

Every cycle produces a June 5. The dates change; the mechanism doesn't. Elevated leverage in perpetual futures, a break of an obvious level, a cascade that runs faster than any human can react, and a recovery curve that punishes the deepest accounts hardest.

You don't get to opt out of volatility. You do get to decide, in advance, whether a day like that is an inconvenience or an ending. That decision gets made when you choose your position size and your system — not when the candle is already red.

The traders who were fine on June 5 made it weeks earlier, quietly, by refusing to be the leverage that fuels the next cascade.

Author note: I write about risk architecture at KYO Markets, where surviving variance is treated as the design problem rather than an afterthought. If you want the mechanism broken down further, with the cascade diagram and the recovery math in full, here's the full breakdown on KYO Markets.

Educational, not financial advice. Crypto is volatile and you can lose capital.

Even BlackRock stopped trusting a single AI model. Retail traders should take the hint.

Jerry Chen — Sat, 06 Jun 2026 16:38:19 +0000

Open any crypto channel and you'll hear the same argument on repeat. Which model is smartest. Which indicator actually works. Who's got the one signal that prints. The whole conversation assumes a single oracle exists somewhere, and the only job left is finding it.

That assumption is the bug, not the feature.

Here's what keeps getting buried under the hype: when the people with the most money, compute, and incentive to build that one magic model actually went looking, they didn't build a bigger oracle. They built a committee and put a referee on top of it.

What the serious research actually did

In August 2025, BlackRock published a framework called AlphaAgents — a multi-agent system for equity portfolio construction. The interesting part isn't that it uses large language models. Plenty of things do. The interesting part is the shape: instead of one model deciding, several specialized agents analyze a stock from different angles and then debate. Disagreement is the mechanism, not a bug to be smoothed over. (coverage here)

Around the same time, a peer-reviewed paper called TradingAgents landed on arXiv with a similar architecture. It assigns roles — Bull researchers building the case to buy, Bear researchers building the case to sell, and a risk-management team sitting over the top. In backtests, the framework reported better cumulative return, a higher Sharpe ratio, and smaller max drawdown than the baselines it was tested against. (paper)

Read that carefully. Backtests are not promises. A result on historical data is a hypothesis about the future, not a guarantee, and anyone telling you otherwise is selling something. But the direction is what matters here, and it's not subtle. Two independent serious efforts — one from the largest asset manager on earth, one peer-reviewed — both walked away from "find the best single model" and toward "make several specialists argue under a risk authority."

Industry coverage through 2026 has popularized this into a tidy mental model: a Bull, a Bear, and a Risk Supervisor who can overrule both. (one writeup) That framing is a useful shorthand. Just hold it loosely — it's the journalistic compression of the primary work above, not a law of nature.

Why a single signal is always half a story

Step away from the headlines and the logic stands on its own legs.

Every indicator is a lossy compression of the market. It throws away almost everything and keeps one slice. That slice is genuinely useful. It's also reliably wrong at the worst possible moment.

RSI flashes "oversold" and screams buy right as a trend is collapsing — because a falling knife is, by definition, oversold the whole way down.
MACD prints a clean bullish cross in the middle of a bear market, catching a dead-cat bounce that reverses the next session.
Bollinger Bands flag a breakout that turns out to be a fake-out, price poking through the band only to snap back inside.
Volume spikes that look like conviction are often just a cascade of stop-losses getting hit in sequence.

None of these tools are broken. Each is answering a narrow question honestly. The trap is that a narrow honest answer looks most convincing exactly when it's most dangerous. The cleanest oversold reading shows up at the start of the worst declines. The crispest breakout candle is the one that traps the most buyers.

An indicator doesn't warn you it's about to be wrong. It states its case with the same confidence either way. The only thing that catches a confident-but-wrong reading is a second input that disagrees.

Now step it up a level. If one indicator is a partial description of the market, then one model — however large — is a single point of view, trained on a particular slice of history, carrying its own blind spots. Asking it to be right alone is asking it to never have a bad assumption. That's not a thing you can buy.

Consensus, not unanimity

The lazy fix is to demand that everything agree before acting. That sounds safe and is actually fragile. Wait for five indicators to line up perfectly and you'll trade roughly never — and when you finally do, the move is usually half over. Unanimity is just a slower way of being late.

The version that holds up is weighted consensus. Each input gets a vote. Votes are weighted by how much they're worth in the current context. A decision emerges from the balance instead of from one hero indicator.

And then — this is the part people skip — the consensus doesn't get the last word. A risk layer sits downstream and can veto. Even a strong buy gets blocked if exposure, volatility, or position sizing say no. That veto is the entire reason the "Risk Supervisor" role exists in these frameworks. It's the difference between a confident system and a reckless one.

[suggested chart: single signal → fragile decision, vs. five weighted inputs → consensus → risk gate that can veto → execute]

	The fragile way	The reliable way
Inputs	One indicator, one model	Several independent views
Combination	Whatever the loner says	Weighted by context
Final check	None	Risk layer with a hard veto
Failure mode	One blind spot sinks the trade	A second view catches the first

It's less exciting than "we found the model." It's also much harder to blow up.

Why the "one magic signal" pitch should lose your trust

Put it bluntly. If the single best model were the answer, the firms with the most data, the most compute, and the strongest incentive to find it would have shipped it by now. Instead the serious work — BlackRock's AlphaAgents, the peer-reviewed TradingAgents framework, the broader multi-agent research crowd — keeps moving the other direction. Toward committees of specialists with a referee holding veto power.

When that's where the deep-pocketed research lands, a landing page promising one secret signal isn't ahead of the curve. It's behind it.

The honest framing is humbler and more durable: no indicator is reliable alone, no model is right alone, and reliability is a property of the system — independent views that can disagree, a method for weighing that disagreement, and a risk layer willing to say no. None of that promises profit. It's just a more defensible way to make decisions under uncertainty, which is the only kind of decision crypto ever offers.

Author note: I write about AI trading architecture at KYO Markets, where the engine cross-validates five technical indicators — RSI, EMA, MACD, Volume, and Bollinger Bands — through weighted consensus with a risk layer that can veto a trade before execution. If you want the longer, mechanism-level version of this argument, here's the full piece on KYO Markets.

Educational, not financial advice. Crypto is volatile and you can lose capital.

We automated the easy half of trading and called it a trader

Jerry Chen — Sat, 06 Jun 2026 16:38:15 +0000

Here's the part everyone keeps skipping. The AI-agent trading boom is not a scam, and it is not vaporware. There are agents in production right now signing transactions, paying for compute, and moving capital between protocols faster than you can refresh a chart. That part is real. It's funded. It is not going away.

My problem isn't with whether the agents work. It's with where all that capability is pointed.

Because nearly all of it is aimed at one half of the trade. The execution half. Get filled faster, find the better rate, rebalance on schedule, route a payment without a human. And the other half — the half that decides whether your account is still standing after a bad month — is being left almost completely undesigned.

The hype is earned. That's not the issue.

Look at the actual deployments and it's hard to call this a bubble in the usual sense.

Number	What it measures
$15.3B	AI-agents sector market cap, Q1 2026 (KuCoin)
~$22.6–27B	Broader AI-crypto sector mcap by May 2026, up from ~$9B (MEXC)
~1,000	Developers contributing to Coinbase's x402 agent-payment protocol (VaaSBlock)
~3x	Growth of AI-crypto from early 2025 to mid-2026

Coinbase's x402 protocol — agents paying for services with stablecoins straight over HTTP — moved from demo to production, with AWS, Coinbase, and Stripe all shipping products on top of it. This is not three guys and a whitepaper.

And the trading use cases are genuinely useful. The honest write-ups describe agents doing yield optimization, arbitrage execution, and portfolio rebalancing — three jobs that are tedious, latency-sensitive, and perfect for something that never sleeps and never gets bored. An agent will catch a funding-rate spread at 4 a.m. that you would have missed. It will rebalance to target weights without flinching. Good. Keep it.

But notice what every one of those jobs has in common

Yield optimization. Arbitrage. Rebalancing. Payment routing.

They're all execution. Every one of them assumes the hard decisions have already been made. The agent is told what to hold, how much to risk, and when the thesis is wrong — and then it does the mechanical part beautifully. It's a phenomenal pair of hands. It is not a brain deciding whether your hand should be on the stove at all.

That's the split I keep coming back to. Every trade has two halves.

[suggested chart: the two halves of a trade]

Solved by agents today — the hands:

Faster execution and routing
Yield optimization
Arbitrage execution
Portfolio rebalancing and payments

Still undesigned — the judgment that keeps you solvent:

How much to deploy (sizing)
What invalidates the trade
Behavior after a losing streak
Hard exposure caps and drawdown response

The agent economy of 2026 has gone almost entirely to the left side of that list. An agent that executes flawlessly on an unsound sizing rule just loses money faster.

An autonomous agent with no risk architecture is not an edge. It's just faster emotion at machine speed.

Automation amplifies your process — including the bad parts

This is the piece I want you to sit with before you hand a wallet to anything autonomous. Automation does not improve your process. It scales whatever process you already have.

A disciplined process, automated, becomes a disciplined process that runs without you getting tired. A weak process, automated, becomes a weak process at scale — executing its mistakes perfectly, around the clock, with no one awake to notice the account bleeding.

If your underlying logic is "go all-in on the signal and hope," an agent will go all-in faster, more often, and at 3 a.m. when you'd have been asleep and safe. The agent doesn't add judgment. It removes the friction that was, accidentally, protecting you. Speed is only an asset on top of a sound decision. On top of an unsound one, speed is the problem.

So the question to ask any agent product isn't "how fast does it execute" or "how clever is the model." It's: what does it do when it's losing?

Does it have a defined point where the position is wrong and it gets out? Does it cap how much of the book sits in one idea? Does it change behavior after a drawdown, or keep pressing because the model said so? If those answers are missing, you've bought a very fast hand attached to no brain.

What designing the second half actually looks like

None of this is an argument against automation. It's an argument for automating the right thing. The survival half isn't exotic — it's four boxes most execution agents simply assume someone else filled in:

Signal validation, not signal worship. Require agreement across methods before a setup counts. The point is to reject more, not to trade more. A fast agent firing on a single weak signal is exactly the failure mode above.
Capped, staged sizing. Spread entries across planned levels with a hard cap on total exposure, so no single idea can grow big enough to end the account. This is the "how much to deploy" box.
A reserve buffer. Set aside part of gains during good periods so the system can keep operating through a drawdown instead of being forced off plan. A buffer, not a guarantee — but it's the difference between riding out a rough stretch and getting knocked out.
A large-numbers framework. Treat results as a distribution over many trades, not a verdict on the last one. That's what keeps a system rules-based after a losing streak instead of revenge-trading.

Put those four together and you have something an arbitrage agent doesn't: a defined answer to what happens when it's wrong. Not a better prediction — a designed response to being wrong, automated so it actually gets followed at the moment discipline is hardest.

The boom and the gap are the same story

Here's what happens next, and it's not a contradiction of anything above. Agents keep getting better at execution. Yield, arbitrage, payments, rebalancing — all of it gets faster, cheaper, more autonomous. The capability curve is real and it bends up.

None of that closes the gap, because the gap isn't a capability problem. It's a design-priority problem. The risk half doesn't get solved by a smarter model. It gets solved by someone deciding, before the agent is switched on, what the rules of survival are — the sizing cap, the invalidation point, the drawdown behavior, the buffer — and then encoding those rules so the agent obeys them even when the market is screaming to do otherwise.

That's a choice. Right now most of the industry isn't making it. They're shipping the hands and calling it a trader.

So enjoy the boom. It's real, and parts of it are genuinely good. Just be clear-eyed about which half it solves. The execution half is getting world-class infrastructure. The survival half — the one that decides whether your account is still here next quarter — is still mostly up to you to design. Automate that part first.

Author's note: I work on these problems at KYO Markets, where the focus is the survival half rather than shaving milliseconds off a fill. If you want the longer, fully-sourced version of this argument, it's the full piece on KYO Markets.

Educational, not financial advice. Crypto is volatile and you can lose capital.

I open-sourced a World Cup 2026 prediction model — and tested it honestly

Jerry Chen — Sun, 31 May 2026 15:08:33 +0000

Every World Cup, "supercomputer predicts the winner" headlines show up everywhere — and almost none of them let you see how the sausage is made. I wanted a forecast I could actually read, run, and argue with. So I built one for the 2026 World Cup, and I open-sourced the whole thing:

👉 github.com/Hicruben/world-cup-2026-prediction-model (MIT)

No machine-learning black box, no scraped bookmaker odds — just three classic, transparent pieces. And, more importantly, an honest, reproducible test of how good it actually is.

The model in three layers

1. Team strength (Elo). Every nation gets an Elo rating, seeded from long-run strength and then calibrated on hundreds of recent real internationals. Wins over strong sides in important games move a rating more than friendlies; recent form outweighs old form.

2. Each match (Dixon-Coles bivariate Poisson). Two ratings become expected goals, which feed a Dixon-Coles model to produce win/draw/loss probabilities. Dixon-Coles (1997) fixes a well-known flaw of plain Poisson: it under-counts the low-scoring draws (0-0, 1-1) that are so common in football.

import { matchProb } from "./elo.mjs";

// Elo 2056 vs Elo 1951, neutral venue
const p = matchProb(2056, 1951);
// → { winA: 0.45, draw: 0.26, winB: 0.29, expectedGoalsA: 1.6, expectedGoalsB: 1.2 }

3. The tournament (Monte Carlo). Play all 104 matches through the real bracket 10,000 times. Count how often each team reaches each round → championship and advancement probabilities.

There's a tiny CLI to poke at it:

$ node predict.mjs brazil argentina

  brazil (Elo 1994)  vs  argentina (Elo 2064)   [neutral]
  brazil           win   26.7%  ████████
  draw                   28.3%  █████████
  argentina        win   45.0%  █████████████

The part I actually care about: is it any good?

Anyone can spit out percentages. The hard question is whether they mean anything. So I tested it the honest way — walk-forward, out-of-sample. The script steps through 920 real internationals (Oct 2023 → May 2026) in date order, predicts each match using only data available before kickoff, then reveals the result and updates the ratings. No hindsight, no curve-fitting. One command reproduces it:

$ node backtest.mjs

=== Walk-forward backtest — 770 of 920 matches ===
MODEL
  Accuracy (top pick):   61.0%
  Favourite acc (p≥50%): 66.8%
  Brier (3-way, ↓):      0.536
BASELINES (same matches)
  Always pick home:      48.6%
  Coin-flip (uniform):   Brier 0.667

So: ~61% correct on a three-way (win/draw/loss) outcome, versus 49% for "always pick home" and ~33% for a coin toss. When the model had a clear favourite, it was right about two times in three. The Brier score (0.54 vs 0.67 for uniform) says the probabilities carry real information, not just the top pick.

What I learned (and what I won't claim)

It is not state-of-the-art, and it does not beat the betting market. A 61% hit rate also means ~2 in 5 matches surprise it — by design. Draws are genuinely the hardest thing to predict, and a 7-game tournament is dominated by variance.
Transparent baselines are underrated. No deep learning, ~300 lines of plain Node, zero dependencies — and it still lands in the same ballpark as far fancier models for tournament-level questions.
Calibration > accuracy. Getting the probabilities shaped right matters more than the headline hit rate, especially for a bracket simulation.

Try it / see it live

Clone it and run the backtest yourself (Node 18+, no deps):

git clone https://github.com/Hicruben/world-cup-2026-prediction-model.git
cd world-cup-2026-prediction-model
node backtest.mjs      # reproduce the numbers
node predict.mjs spain germany

The full 48-team tournament simulator (10k sims, live title odds, an interactive bracket) runs the same engine at cup26matches.com, and there's a plain-English write-up of the methodology and the backtest here.

I'd genuinely love feedback on the modelling — the Dixon-Coles ρ, the home-field handling, the best-third tiebreaks. Tear it apart in the comments or open an issue. ⭐ the repo if it's useful!