Backtests Are Bragging, Live PnL Is Proof: How to Publish an Honest Agent Trading Log

There's a running joke in the algorithmic-trading community that captures the whole credibility problem in one line: for every one post showing live PnL, there are roughly 50,000 posts bragging about a backtest that beat Renaissance's Medallion fund. Backtests are free, flattering, and easy to fake. A live trading log is none of those things — which is exactly why it's the only thing worth trusting. If you're running an AI agent that places real orders, the question isn't how good your backtest looked. It's whether you can show a tamper-evident record of what the agent actually did with real money. This is a guide to publishing that record: what to log, why the audit trail beats a spreadsheet, and a copy-paste spec that makes your agent keep an honest log on its own.

Why a Backtest Is a Story You Tell Yourself

A backtest is a claim about the past made with full knowledge of the past. That's the whole problem. You picked the strategy, the parameters, and the date range after seeing the data, so the result is contaminated by every choice you made to get there. Run enough variations and one of them will look brilliant by luck alone. The market you tested against already happened; it isn't trying to fill your orders at a worse price, and it never front-runs a stop you telegraphed.

Live markets are adversarial in a way a CSV file never is. Your fill is worse than the mid-price you assumed. Your fee is real and recurring. The liquidity you counted on evaporates in the exact minute you need it. Slippage, funding, and latency are line items a backtest quietly rounds to zero, and together they're often the difference between a curve that climbs and one that bleeds. None of that shows up until money is on the line — which is why the community's credibility filter isn't the backtest at all. It's the live log.

For an AI agent, the gap is wider still. A model can hallucinate a rationale, misread a balance, or repeat a trade it already made. It won't be embarrassed by a bad week and it won't quietly stop when the edge disappears. The only way to know what your agent is really doing is to make it write down every action as it happens, in a place it can't later edit to make itself look smart. Honesty, for software, is an audit trail.

What Does an Honest Trading Log Actually Record?

An honest log records every executed trade at the moment it executes, with enough detail that a stranger could reconstruct your account from the log alone. That means, per fill: the timestamp, the instrument, the side, the size, the actual fill price, the fees paid, the running account balance after the trade, and the reason the agent gave for making it. Miss any of those and the log stops being proof and starts being marketing.

The reasoning field matters more than people expect. A price and a size tell you what happened; the rationale tells you whether the agent was thinking or gambling. When you read back a week of entries and every "reason" is a vague gesture at momentum, that's a finding — you've caught a problem before it caught you. The log isn't just a scoreboard. It's the transcript you review to decide whether the thing deserves more size.

Two more fields separate a real log from a highlight reel. Record fees and slippage explicitly, because they're where paper strategies go to die, and a log that hides them is hiding the answer. And record drawdowns — the running peak-to-trough of the balance — not just the wins. A log that shows only green days is either a very short log or a dishonest one. The whole point of publishing live PnL is that it includes the ugly parts, because the ugly parts are what a backtest conveniently left out.

Why the Audit Trail Beats a Spreadsheet

Here's the difference that makes the whole exercise credible: a spreadsheet is a document its author can edit, and an audit trail is a record its author cannot. If you log your trades to a Google Sheet, nothing stops you — consciously or not — from deleting the row where the agent blew up, rounding a fill in your favor, or backfilling a "reason" that sounds smarter than what actually happened. Every trader who's ever kept a manual journal knows the temptation to tidy the losses. A self-edited log proves nothing, because the person it's supposed to convince is the same person who can rewrite it.

A platform audit trail closes that loophole. When every agent action is written by the system to an append-only record — one you read from but can't reach in and rewrite — the log becomes evidence instead of a claim. That's the property that turns "trust me, it's up 12%" into something a skeptical stranger can actually check. It's also the reason the spec below sources its entries from executed-order events rather than from whatever the model felt like typing. The agent reports; the platform records; you publish what the record says, including the parts you'd rather it didn't.

This is the backbone of the whole approach, and it's why where your agent runs matters as much as how it trades. An agent on your laptop, logging to a file you own, is producing a diary. An agent on infrastructure that keeps a full, tamper-evident trail of every action is producing something closer to an audited statement. Only one of those survives contact with a doubter — see the safety rails guide for how those controls fit together.

A Copy-Paste Spec for an Honest Log

Below is a plain-English skill spec you can adapt for an OpenClaw agent. It tells the agent to append every executed trade to an immutable log, capture the fields that matter, and post a weekly summary to Telegram so you can't avoid reading your own numbers. The caps are deliberately conservative — this is a spec for someone who wants proof, not a spec for someone chasing a number. Adjust the whitelist and limits to your own account before you use it.

SKILL: honest-live-log

PURPOSE
  Keep a tamper-evident record of every real trade this agent makes,
  and report it honestly every week. Backtests do not count. Only
  executed orders get logged.

ON EVERY EXECUTED ORDER
  Append one entry to the immutable trade log. Never edit or delete a
  past entry. If a value is unknown, write "unknown" -- do not guess.
  Each entry records:
    - timestamp        (ISO 8601, UTC, from the fill event)
    - instrument       (e.g. BTC-PERP)
    - side             (buy / sell / close)
    - size             (contracts or base units)
    - fill_price       (actual average fill, not the intended price)
    - fees             (paid on this fill, in quote currency)
    - slippage         (fill_price minus intended price)
    - balance_after    (account balance read AFTER the fill)
    - rationale        (one honest sentence: why this trade, now)

SAFETY CAPS (refuse the trade if any is breached)
  - max notional per trade: 2% of account balance
  - max leverage: 2x
  - instrument whitelist: BTC-PERP, ETH-PERP, SOL-PERP only
  - no new position if realised drawdown this week exceeds 10%
  - read balance and open positions BEFORE every order

WEEKLY SUMMARY (post to Telegram, Sundays 20:00 UTC)
  Read the trade log for the past 7 days and report, verbatim from
  the log -- no rounding in your favour:
    - number of trades, and win/loss count
    - starting balance and ending balance
    - net PnL after fees, in currency and percent
    - total fees paid
    - largest single loss and current peak-to-trough drawdown
  If the week was down, say so plainly in the first line.
  Attach or link the raw log entries so the numbers can be checked.

RULE OF HONESTY
  Report the drawdowns as loudly as the gains. A summary that hides a
  losing week is a bug, not a feature.

Notice what the spec refuses to do. It won't guess a value it doesn't have, it won't edit a past entry, and it won't round the weekly number in a flattering direction. Those three rules are the whole game. Wire the summary to run on a schedule so it happens whether or not you feel like looking — the same pattern we cover in scheduling agent cron jobs. A report you have to remember to run is a report you'll skip on the weeks you most need it.

How Small Should You Start?

Smaller than you think. The most-repeated advice among people who actually trade live, as opposed to those who only post backtests, is to cut your intended allocation hard — a common version is "keep your live size to about 10% of what you're thinking right now." That's not timidity. It's the recognition that the first few weeks live are a data-collection exercise, and the data you're collecting is expensive to gather wrong.

Run the agent read-only first, if the venue allows it, so the log fills with the trades it would have made and you can judge the reasoning with nothing at risk. When you do go live, size for the drawdown you can stomach seeing in the weekly Telegram summary, not the gain you're hoping for. A steady dollar-cost strategy is a gentler place to build that record than a leveraged directional bet — see the DCA skill for buying dips on a schedule if you want a first strategy whose log is easy to read.

The point of starting small isn't to make money slowly. It's to make your mistakes cheap while your log is still short. A blown-up account teaches you the same lesson as a 10%-sized scare, but only one of them lets you keep trading afterward. And there are limits no amount of logging removes — for the honest reckoning of what a model still can't do with money on the line, read what AI still can't do in markets.

What Publishing an Honest Log Buys You

Credibility, mostly — and not the cheap kind. Anyone can screenshot a green equity curve. What almost nobody publishes is a live log with the fees itemized, the losing weeks intact, and the drawdowns shown at the same volume as the gains. When you do, you separate yourself from the 50,000 backtest posts by doing the one thing they never do: showing what happened after the idea met the market. For example, a log might show a strategy that looked flawless in simulation quietly giving back a third of its edge to slippage and funding once live. That's not a failure to hide. That's the most useful thing the log ever tells you.

It also changes how you treat the agent. When every action lands in a record you'll read on Sunday, you stop letting it run on vibes. You catch the repeated trade, the drifting rationale, the fee drag you'd assumed away. The log disciplines the operator as much as it documents the bot. That feedback loop — trade, record, review, adjust — is the actual work of running a trading agent, and it's invisible to anyone who stops at the backtest.

---

Sources: r/algotrading — the community's standing "live PnL vs backtests" sentiment, OpenClaw Direct — tamper-evident audit trail for every agent action, and OpenClaw Direct — safety rails for trading agents.