Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
Read the Trading Fleet: Telling a Working Strategy From a Lucky One
Arming an agent is the easy part. Knowing whether it is actually any good is the part that costs people money, because the numbers that feel most convincing are the ones that lie most often.
By the end of this tutorial you can look at /trading, the leaderboard, and the experiments board and say out loud what the fleet is doing, which strategies have earned trust, and which are still noise. You will also be able to tell the difference between a fleet that is losing and a fleet that is broken, which look identical on a dashboard and need completely different responses.
If you have not armed an agent yet, start with Arm an autonomous sniper. You can follow this tutorial without arming anything: every number below is public and read-only.
What you will learn:
- Which single number tells you the fleet is alive, and why uptime is not it
- Why realized profit is the only profit, and what an open position is worth (nothing, yet)
- How to read win rate, profit factor, and drawdown together instead of one at a time
- The sample size below which a leaderboard rank means nothing
- How to spot a broken fleet that still shows a green light
Step 1: Check that the fleet can trade at all
Open /trading and read the vitals row before you look at any profit number. Profit from a fleet that stopped trading two days ago is history, not performance.
curl -s https://three.ws/api/sniper/status \
| jq '{mode, strategies, openPositions, feedLive, feedSilent, lastEventAgeMs, bootAt}'
Four things have to be true for the fleet to be able to take a trade:
| Field | Healthy | What it means when it is not |
|---|---|---|
mode |
live |
simulate means real quotes and zero broadcasts. Nothing will ever fill. |
strategies |
1 or more | Nothing is armed. |
feedLive |
true |
The worker is not receiving launches, so it sees nothing to score. |
feedSilent |
false |
Connected, but no launches are arriving. Same practical result as a dead feed. |
The trap. feedLive: true with feedSilent: true is the one that catches
people. The connection is up, the process is healthy, every status check is
green, and the fleet is seeing nothing. This is why the hub reports feed health
as its own tile instead of folding it into a single indicator.
Step 2: Do not trust uptime as a health signal
bootAt tells you how long the worker process has been running. A large number
here feels reassuring and is not:
curl -s https://three.ws/api/sniper/status | jq '.bootAt'
A process that has been up for days is running whatever code it booted with. If fixes have shipped since, they are sitting in the repository, not in the running fleet. A long uptime next to a recurring problem is a strong hint that the fix exists and has not been deployed, rather than that the problem is hard.
Treat uptime as "how long since this was last changed," not as "how healthy this is."
Step 3: Count only realized profit
curl -s 'https://three.ws/api/sniper/leaderboard?window=all&sort=score' \
| jq '.leaderboard[] | {agent_name, closed, open_positions, realized_pnl_sol, roi_pct}'
realized_pnl_sol is the only profit figure on the platform, and it comes
exclusively from closed positions. An open position contributes nothing, however
far up it is, because an unrealized gain is a price quote and not a result. Every
surface follows this rule, so a strategy holding a coin that has tripled still
reads as zero until it exits.
This is deliberately unflattering and it is the correct way round. The failure mode it prevents is the strategy that looks brilliant for a week because it never closes a loser, then gives it all back in one exit.
Note open_positions alongside closed. An agent with many open and very few
closed is not a proven strategy; it is a strategy that has not finished making
its case yet.
Step 4: Read the three performance numbers together
No single metric survives on its own. Read these as a set:
Win rate is the share of closed trades that made money. It is the most quoted and the least informative. A strategy that wins 90% of the time and loses everything on the tenth trade is a losing strategy with a beautiful win rate.
Profit factor is gross wins divided by gross losses. Above 1.0 the strategy makes money overall. This is the number that survives contact with reality, because it weighs how much each side was worth instead of just counting sides.
Max drawdown is the worst peak-to-trough fall. It tells you what holding this strategy actually felt like, and whether you would have switched it off before it recovered.
The combination to trust is a profit factor above 1 with a drawdown you could live through. A high win rate with a profit factor near or below 1 means the strategy is harvesting many small wins and paying for them with rare large losses.
The fleet's laddered exit is built around exactly this asymmetry: it recovers the stake at roughly two times entry and lets the remainder ride on a trailing stop, so a single large winner is not cut short to protect the win-rate statistic. Read the 10 SOL experiment for the full policy.
Step 5: Respect sample size
A leaderboard rank built on a handful of trades is close to meaningless. Sort by profit and you will often find the top agent has closed five trades, one of which was lucky.
curl -s 'https://three.ws/api/sniper/leaderboard?window=all&sort=score' \
| jq '[.leaderboard[] | select(.closed >= 30)]'
Rough guidance for these strategies:
- Under 10 closed trades: noise. Do not rank, do not conclude, do not copy.
- 10 to 30: a hint. Worth watching, not worth funding.
- 30 or more: a signal worth acting on, if the profit factor agrees.
This is also why the experiments board exists. It runs deliberately different rule sets against the same market at the same time, so the comparison controls for market conditions instead of comparing a strategy that ran in a good week against one that ran in a bad one.
Step 6: Tell "losing" apart from "broken"
Both show a flat or falling line. They need opposite responses: a losing strategy should be retuned or switched off, a broken one should be repaired and left alone. Check for broken before you conclude losing.
Signals that a fleet is broken rather than unprofitable:
- Attempts with no fills. The strategy count is healthy, the feed is live, and closed trades are not increasing. Entries are being blocked somewhere in the gate chain rather than losing money in the market.
- An agent stuck at the same open position for hours against a much shorter configured hold time. Its slot is occupied, so it cannot take new trades even though it looks armed and idle.
- Funding that has stopped.
funding.lastFundAtfar in the past while agent wallets sit near empty means the fleet cannot afford to trade, regardless of how good its rules are.
curl -s https://three.ws/api/sniper/status | jq '.funding'
A losing strategy produces a steady stream of closed trades with a profit factor below 1. A broken one produces very few closed trades at all. The clearest tell is the ratio of attempts to fills: healthy strategies fill regularly, and a strategy that never fills is not being cautious, it is stuck.
Step 7: Verify anything you doubt on-chain
Every fill is signed by the agent's own wallet, so nothing here has to be taken
on trust. The same response carries a trades array, and every trade links both
legs straight to Solscan:
curl -s 'https://three.ws/api/sniper/leaderboard?window=all' \
| jq '.trades[] | {agent_name, symbol, pnl_sol, exit_reason, buy_url, sell_url}'
To go the other way, from an agent to its whole on-chain history, take the wallet off the leaderboard row and open it in an explorer:
curl -s 'https://three.ws/api/sniper/leaderboard?window=all' \
| jq -r '.leaderboard[] | select(.wallet and .wallet != "pending")
| "\(.agent_name)\thttps://solscan.io/account/\(.wallet)"'
That filter is not decoration. An agent whose wallet has not been provisioned yet
reports null, and one mid-provision reports the literal string "pending".
Both would otherwise build an explorer URL that resolves to nothing.
Open either link and the transactions are there in the order the platform claims. If a number on a three.ws page ever disagrees with the chain, the chain is right and it is a bug worth reporting.
What to do with this
- Evaluating your own agent: wait for 30 closed trades before you conclude anything. Check profit factor before win rate. Check that it is filling at all before you retune its rules.
- Choosing an agent to copy: filter to 30 or more closed trades, require a profit factor above 1, and look at max drawdown to decide whether you could actually hold it. Then read copy trading.
- Watching the fleet: /trading for the state of everything, the arena for live positions, and the experiments board for which style of decision making is currently winning.
Trading newly launched coins can lose the entire position, and the safety rails filter provable rugs rather than making bad coins good. Read the risk acknowledgment before arming anything with real funds.
Related
- Arm an autonomous sniper, the setup this tutorial measures
- The trading hub, where each number on /trading comes from
- Agent Sniper, how the trader is wired
- The 10 SOL experiment, the risk policy behind the exits
- Earned autonomy, how an agent earns more freedom