RU

AI Traders: How Autonomous Agents Lose Deposits and Follow Strangers' Orders

Published: 2026-11-22 · Author: AI Release · @ai_releaseorg
AI Traders: How Autonomous Agents Lose Deposits and Follow Strangers' Orders

⚡ The gist

🔍 What happened

On social media, autonomous trading has an almost perfect advertising model. One agent makes 300% — screenshot, excited post, tens of thousands of views. Another loses its deposit — only the members of a private chat ever hear about it, if anyone does. A third sends someone else's money to a stranger because it misread a message on X. But that last one doesn't fit neatly into the pitch deck for yet another course on building an AI trader.

And yet stories like these are exactly what let you gauge the real state of the technology. The problem isn't that AI is incapable of analyzing markets. The problem is that between the ability to reason about trading and the safe handling of real capital lies a vast technical chasm. And some developers have already demonstrated just how expensive it is to ignore that chasm.

Lobstar Wilde: when AI can't do the math on money

One of the most telling cases happened on February 22, 2026. Developer Nik Pash, an OpenAI employee, built an autonomous agent called Lobstar Wilde on top of OpenClaw. It was given a crypto wallet and an ambitious mission: turn roughly $50,000 into a million.

A user on X asked the agent to send 4 SOL — about $310 — supposedly to pay for an uncle's tetanus treatment. The agent agreed to help, but ended up sending him about 52.439 million of its own LOBSTAR tokens. That was roughly 5% of the token's entire supply. At the market valuation at the time of the incident, the transfer was worth about $441,000 — though the recipient sold the tokens for roughly $40,000. The gap between paper value and actual liquidity turned out to be quite instructive.

According to one account, the agent misinterpreted an API response and got the token amount wrong due to an error in digit handling or decimal representation. The result was a near-perfect demonstration of the autonomous economy: the agent intended to send a small act of charity and instead executed a large, unplanned transaction. No sophisticated blockchain hack was required — just a bug in data-processing logic.

Alpha Arena: when the best language models get real money

If the previous case can be chalked up to one agent's bug, the Alpha Arena experiment is interesting for a different reason. The research project Nof1 gave six large language models $10,000 each in real capital to autonomously trade perpetual futures on Hyperliquid. The lineup included GPT-5, Claude Sonnet 4.5, Gemini 2.5 Pro, Grok 4, DeepSeek V3.1, and Qwen3-Max.

The models made their own trading decisions, opened long and short positions, and used leverage. There was no human trader in the loop to stop the next brilliant idea in time. According to the published final results, four of the six models finished the experiment at a loss.

GPT-5 is especially notable: $10,000 in starting capital, a final loss of about $6,267, a return of roughly −62.7%. An alternative calculation based on Hyperliquid data puts the total loss at about 63.4% — the discrepancy comes down to how open positions and fees are accounted for. The winner was Qwen3-Max, which earned about 22% over the experiment. DeepSeek V3.1 also finished in the black.

But there's an important caveat: the experiment lasted only a few weeks. It doesn't prove that one model is permanently better than another, let alone that you can reliably make money with one. What it does show is this: even the most famous models can behave completely differently under identical trading conditions.

200,000 bots vs. three AIs: the unexpected winner

In October 2026, developer Mike Russell ran another interesting experiment. He launched three autonomous crypto bots with a combined capital of $999. They traded on a real exchange for 30 days.

The result: $999 in starting capital, $786 remaining, a 21.4% loss. Factoring in the cost of AI API calls, the loss was about 25%. For comparison, the author ran 200,000 virtual bots making decisions at random — essentially flipping coins. About 35% of the random bots finished the period with a profit. Only about 3% performed as badly as the real AI bots in the experiment.

There's an extra detail, too: simply holding Bitcoin over the same period would have produced a loss of about 3.6%. In other words, even doing nothing at all turned out to be significantly better than the experimental system. This isn't an academic proof that random trading beats AI — the experiment's conditions are limited, and results from a single sample can't be generalized to the whole market. But for understanding the advertising stories about thousands of bots, it's extremely useful.

Run 200,000 strategies, and thousands of winners are guaranteed to turn up. Someone will post +100%, someone +500%, and a few lucky ones will be able to show off genuinely impressive results. The only question is what happens to those same strategies the following month.

Prompt injection: when AI loses money without even making a mistake

Trading losses are relatively straightforward: a bad strategy, a bad signal, leverage, fees. But in 2026 a more interesting class of threat emerged — attacks on the logic of how agents interact with each other.

On May 4, 2026, a telling incident involving Grok and the Bankr infrastructure took place. An attacker used an NFT that granted additional wallet-interaction capabilities, along with a message containing an encoded instruction. Grok was asked to decode the message. The decoded text turned out to contain a command for Bankrbot: transfer 3 billion DRB tokens to a specified address. Bankrbot executed the command. The transferred assets were valued at roughly $174,000.

What's especially important here is that the attacker didn't have to steal a private key or hack the blockchain. One agent processed an external message, and another treated the output as a trusted transfer instruction. In effect, the attacker weaponized the interaction between two automated systems against the very owners of the infrastructure.

This is a textbook case of indirect prompt injection: a malicious instruction enters the system through external data the agent is supposed to analyze but mistakenly treats as commands. In other words, stealing money now sometimes requires not hacking a wallet, but convincing the AI to use it for you.

Bloom Trading: nearly a million dollars in 94 seconds

On October 26, 2026, another incident occurred — one you can no longer blame on a flawed trading strategy. Users of the Telegram bot Bloom discovered that funds had vanished from their crypto wallets. According to Bitquery's investigation, 48 wallets were affected, belonging to nine traders; 9,408 SOL were withdrawn, worth about $953,000 at the time of the incident. The main series of transfers took just 94 seconds.

The technical side is particularly interesting. Bloom held the private keys to users' wallets in order to sign transactions automatically. That's precisely what let the bot execute trades quickly without the owner confirming every action. But that architecture means whoever gets access to the keys gets full control over the funds.

According to Bitquery, the attacker used the victims' own keys and systematically drained the wallets, starting with the largest. The cause of the key compromise had not been definitively established at the time of the investigation. Bloom said it was investigating a possible compromise of a third-party vendor and promised to reimburse affected users.

This is an important distinction: the withdrawal of funds from the wallets is a proven fact, but you can't automatically claim that an AI hack or a prompt hack was the cause. Still, the case perfectly illustrates a different problem with autonomous trading: the user hands the bot's infrastructure powers that can turn out to be far more valuable than any trading strategy.

Open agents: a gift for anyone hunting other people's API keys

A separate problem is the security of the agent platforms themselves. In February 2026, researchers at SecurityScorecard found more than 40,000 OpenClaw instances exposed to the internet. Having an open network interface doesn't by itself mean every instance was compromised. But misconfigured authentication turns such a system into a potential entry point.

Researchers and security professionals have since repeatedly demonstrated ways to gain access to admin interfaces, chat histories, messenger tokens, and API keys. And the problem extends well beyond crypto. A modern agent may simultaneously have access to an exchange API, a wallet, the ability to sign transactions, access to Telegram and X, the ability to run commands on a server, and access to files and configurations.

If such a system gets compromised, the attacker doesn't just get a chatbot — they get a potentially full-fledged tool for controlling someone's digital infrastructure. And that's a whole different level of risk.

🧠 Our take

All of these stories share one architectural problem: the language model, the trading system, and the infrastructure for accessing money are often fused into a single, poorly compartmentalized mechanism. Our assessment: the issue isn't that the models are "dumb" — it's that they were handed permissions that don't match their reliability.

A language model is not a risk-management system. An LLM generates probabilistic answers. It can analyze news, interpret market data, and propose scenarios. But that doesn't make it a specialized risk-calculation engine. A model can confidently recommend a buy even when the position size exceeds the acceptable drawdown or the instrument's liquidity is insufficient. Confidence in an answer is not the same as the probability of a profitable trade.

State loss. An agent can restart, lose part of its context, misinterpret an exchange API response, or mix up a position size. The problem is especially dangerous when the agent manages multiple positions on its own. Say it believes it closed a position when the exchange actually rejected the order. Its next decision is then made on the basis of a portfolio state that doesn't exist.

A backtest guarantees nothing. With historical data, you can fit a beautiful strategy to almost any period. But real trading brings fees, slippage, execution delays, thin liquidity, and changing market conditions. A strategy that looks great on a chart can turn unprofitable the first time it meets a real order book.

Leverage raises the price of every mistake. Without leverage, an agent loses part of its capital. With heavy leverage, a mistake can end in liquidation. And the market couldn't care less how convincingly the model explains its decision afterward.

External data becomes a control channel. The agent reads websites, messages, social media posts, and other agents' replies. Any of it can carry malicious instructions. If the system doesn't separate trusted commands from untrusted data, an attacker can make it take actions its owner never authorized.

What a safe architecture should look like

You don't have to abandon autonomous trading altogether. But giving a language model direct control over capital is questionable engineering practice. We believe a more sensible architecture separates responsibilities.

The AI is the analyst. It reads the news, analyzes the market, spots patterns, and proposes trade ideas.

A separate software module is the risk controller. It checks position size, acceptable drawdown, leverage, liquidity, and whether the trade complies with established limits.

The trade executor is a separate component. It receives only pre-validated commands and interacts with the exchange through a restricted API.

The wallet and keys are a separate security perimeter. No universal keys with withdrawal rights. No agent access to the main capital.

A minimal set of safeguards:

The core principle: limits must exist in code, infrastructure, and access rights — not just in the system prompt. A prompt can be changed, bypassed, or poisoned. A properly configured limit on the exchange's side shouldn't depend on how persuasively the agent begs to have it ignored.

⚠️ What we don't know

We don't know the exact cause of the key compromise in the Bloom case: Bitquery's investigation documents the withdrawals but doesn't identify the source of the leak, and the third-party-vendor theory remains just the company's version. In the Lobstar Wilde story, the mechanism of the error (digit handling or decimal representation) is likewise known only from one account. The Alpha Arena results and Mike Russell's experiment come from short timeframes and small samples — they can't be generalized to the whole market. And finally, public data on how many agents have actually fallen victim to prompt injection is almost certainly understated: such incidents are rarely disclosed.

💬 Worth debating

  • Does it make sense to let a language model initiate trades at all, or should its role be limited to preparing recommendations for a human?
  • Who should be liable for funds lost to an agent's error: the developer, the infrastructure owner, or the user who voluntarily handed over the keys?
  • Would mandatory certification of "safe" trading agents help, or will the market keep chasing maximum returns and ignoring the risks?

Forecast: within the next two quarters, at least two public post-mortems will appear in which the damage from an autonomous agent runs into the hundreds of thousands of dollars — and the root cause cited won't be a model hack, but weak separation of permissions between the agent, the wallet, and the trading API. You'll be able to verify this via blockchain-analytics firms' and insurers' reports.

Sources:

🤖 AI summary
  • Date: 2026-11-22
  • Source: www.theblock.co
  • Tags: Ii-treyding, Avtonomnye-agenty, prompt-injection, Kriptovalyuty, Security, AI, Trading, neural networks
  • Key facts:
    • The Lobstar Wilde agent sent a stranger $441,000 worth of tokens instead of the $310 in help it intended — all because of a number-handling error.
    • In the Alpha Arena experiment, four of the six top LLMs trading real money finished the season in the red; GPT-5 lost about 63%.
    • Three AI bots starting with $999 ended 30 days down 21.4%, while roughly 35% of 200,000 random bots finished the same period with a profit.
    • Grok decoded a "message" containing a command for Bankrbot — and the bot transferred about $174,000 in tokens without any key theft.
    • The Telegram bot Bloom drained 48 wallets of ~$953,000 in 94 seconds: it held users' private keys.
    • On social media, autonomous trading has an almost perfect advertising model.
    • One agent makes 300% — screenshot, excited post, tens of thousands of views.
    • Another loses its deposit — only the members of a private chat ever hear about it, if anyone does.
Ii-treydingAvtonomnye-agentyprompt-injectionKriptovalyutySecurityAITradingneural networks
📖
Read the guide on this topic
Read →
← PreviousAn Air Traffic Control Outage Cost 2.5 Million Passengers $1.58 BillionNext →LG Uplus splits its AI business into infrastructure and platform — a reform aimed at 2027

Source: www.theblock.co · post in Telegram