A self-improving AI trading agent is a system that does not just take a prompt and return an answer — it runs a strategy, scores the outcome of every trade, forms a hypothesis about what to change, and rewrites its own rules before the next cycle. In a May 2026 walkthrough, creator Lewis Jackson builds exactly that: a 24/7 agent wired into Claude Code, hosted on Railway, and pointed at a live Bittensor subnet strategy with real money behind it.

This guide breaks down the architecture Jackson demonstrates, the four criteria he says separate a genuine trading agent from a “dumb” bot, and the honest risks of handing capital to software that edits itself. It is an explainer, not an endorsement — the assets involved are highly speculative.

Key takeaways

  • A self-improving AI trading agent closes the loop. Instead of prompt → output, it runs prompt → strategy → scored outcome → new hypothesis → updated strategy, iterating without a human rewriting the rules each time.
  • Jackson’s four criteria for a good agent: accurate data in, 24/7 reliability, a well-defined goal with explicit success/failure conditions, and a genuine feedback loop that changes behaviour.
  • The scientific method is the guardrail. The agent changes one variable at a time, sets each improvement as the new baseline, then iterates — so it can attribute results.
  • The stack is Claude Code + a one-shot prompt + Railway, with an autonomous “Hermes agent” as the learning brain; the whole pipeline installs in a single session.
  • Real money, real risk. The live strategy trades Bittensor subnets on a “read-only first” cycle before going live — but subnet tokens are volatile and you can lose your entire stake.

What a self-improving AI trading agent actually is

Most AI trading bots are stateless. You give them a prompt, they return an output, and nothing is remembered — Jackson likens it to “a calculator, not a researcher.” A self-improving AI trading agent adds memory and a feedback loop on top of that base.

The difference is the shape of the loop. A basic bot runs prompt → outcome. Jackson’s design runs a longer chain: a prompt produces a strategy, the strategy produces an outcome the agent can measure, and that measurement generates a new prompt that folds back into the strategy. Repeat that thousands of times and the agent is, in effect, tuning itself toward a goal instead of waiting for you to rewrite it.

That is the same convergence we cover in why AI agents need crypto rails: once software can act autonomously with money, it needs infrastructure that runs at machine speed, around the clock, without a human in the loop for every decision.

The four criteria for a good trading agent

Jackson’s most useful contribution is a framework — four bars any autonomous trading agent has to clear. Treat these as a design checklist before you trust one with capital.

1. Accurate data in

Garbage in, garbage out applies twice over when the “brain” is a language model. Jackson says he tested “every single AI in existence” for trading and found that models supposedly pulling from the same source produced different numbers — an inherent accuracy problem. The fix is engineering, not vibes: strong, reliable API connections for price data, and explicit rules so that when the agent interprets a news article, it reaches an objective conclusion rather than a creative one. Two agents handed the same headline should not disagree.

2. Reliable 24/7 operation

An agent that only runs when your laptop is open is not reliable. The system must keep executing if your machine sleeps, closes, or loses power. In this build that reliability comes from Railway, a cloud host the agent deploys itself to — the same 24/7 deployment pattern used in our Claude Code trading bot with TradingView guide.

3. A well-defined goal

This is where Jackson says most people fail: they build a strategy with no destination. An agent that improves toward a goal needs to know what the goal is — and, crucially, what failure looks like. Define success concretely: a target return over a fixed window, a minimum Sharpe ratio (a standard measure of risk-adjusted return), a maximum drawdown you will tolerate. In the demo, the agent extracts a target of roughly 47% every 30 days, a minimum Sharpe of one, and a maximum drawdown, plus a “failure reflection” trigger after a set number of days. With those numbers written down, the agent can label any result as toward the goal (good) or toward failure (bad) and steer accordingly.

4. A genuine self-improvement loop

The final bar is learning. The agent must organise incoming information, analyse whether each outcome moved it toward or away from the goal, form a hypothesis about why, propose what to change, and apply that change to an updated strategy — on its own. Without this fourth criterion you have automation, not intelligence.

How the scientific method keeps it honest

Left unchecked, a “self-improving” agent can fool itself. If it changes ten variables at once and profit goes up, it has no idea which change was responsible — and it will happily carry forward the useless ones.

Jackson’s constraint is the scientific method: change one variable at a time. Run a series of tests, and every time a change produces a better result, that becomes the new baseline. The next iteration builds on the new baseline, one variable again. This is the difference between an agent that compounds real improvements and one that drifts on noise — the same discipline that separates careful investing from the most common mistakes retail traders make.

The stack: Claude Code, a one-shot prompt, and Hermes

The build itself is designed to be copy-paste simple. Here is the architecture Jackson walks through.

Claude Code as the terminal environment. The whole thing is set up by pasting a single “one-shot prompt” into Claude Code (Anthropic’s command-line coding agent). The prompt runs a multi-phase installer: an environment check (Mac vs. Windows, Node.js, Claude Code present), then strategy definition, scaffolding, deployment, and hand-off.

A defined strategy. During setup the agent asks what you are trading and what success and failure mean. You can point it at an existing strategy, ask it to generate a basic starter, or build one interactively. In the demo Jackson points it at his own “Wacko Alpha” strategy — a Bittensor (TAO) momentum-and-yield system he says he had already run manually for six to eight weeks across roughly 1.5 million analysed data points.

Railway for 24/7 hosting. The agent deploys to Railway so the strategy keeps firing regardless of your computer’s state. Login is interactive, so the installer hands that one step back to you in a separate terminal, then continues.

“Hermes” as the learning brain. Jackson frames an autonomous tool he calls the Hermes agent as the self-learning engine — something he pitches as an alternative to the widely discussed “OpenClaw” autonomous framework. Once installed, Hermes owns the portfolio mechanics and the trade scorer, reviews trades on a weekly cadence, and decides when to flip the strategy from read-only to live. A second agent, “Cornelius,” tunes the learned-parameters file on its own weekly schedule, offset by three days.

A note on those tool names: Hermes agent, OpenClaw and Cornelius are terms used by the creator, and their capabilities here are presented in a promotional walkthrough rather than independently verified. Treat the specific claims — especially “outperforming” comparisons — as marketing until you have tested them yourself.

The live strategy: Bittensor subnets, read-only first

The first live deployment targets Bittensor subnets — the specialised sub-networks of the decentralized-AI protocol Bittensor, whose native token is TAO. The agent runs a daily rebalance and a 30-minute rebalance, hunting the target return within the defined drawdown and Sharpe limits.

Sensibly, the first Hermes cycle is read-only and review-only: it produces a markdown review with no live writes, and the human approves going live by editing the strategy’s mode. Only then does Hermes begin trading on the next weekly cycle.

This staged rollout is the one piece of risk management that matters most. Bittensor subnet tokens are thin, fast-moving and speculative; an agent rebalancing them every 30 minutes on real capital can lose money quickly if its “learning” locks onto a bad pattern. Start in review mode, keep position sizes small, and treat early live runs as paid tuition.

Should you build one?

As an engineering exercise, a self-improving AI trading agent is a genuinely useful way to learn agent architecture: data pipelines, cloud deployment, scoring functions, and iterative optimisation. The four-criteria framework and the one-variable scientific loop are sound principles that outlast any particular tool.

As a way to make money, temper expectations hard. The demo puts real capital behind an unproven, self-editing system trading one of crypto’s more volatile corners. Nothing here is financial advice, past performance says nothing about the future, and “the agent learns” is not a substitute for understanding what it is doing. If you build one, run it read-only, watch how it forms hypotheses, and only risk money you can afford to lose entirely.

Frequently asked questions

What is a self-improving AI trading agent?

It is a trading system that scores the outcome of each trade against a defined goal, forms a hypothesis about what to change, and rewrites its own strategy before the next cycle — without a human editing the rules each time. It differs from a normal bot, which simply takes a prompt and returns an output with no memory or learning.

Can an AI trading bot really learn from its own trades?

It can adjust parameters based on measured outcomes, which is a real form of learning. The key discipline is changing one variable at a time using the scientific method, so the agent can attribute a better result to a specific change rather than to noise. It is optimisation within a defined strategy, not magic — and it can just as easily learn the wrong lesson from a lucky streak.

Is it safe to let an AI agent trade real money?

No automated trading is “safe.” In this build the agent trades volatile Bittensor subnet tokens and rebalances every 30 minutes, so losses can accumulate fast. Sensible precautions include running the first cycle in read-only mode, setting explicit maximum-drawdown and failure conditions, using small position sizes, and only risking money you can afford to lose entirely.

What is the Hermes agent Lewis Jackson uses?

Hermes agent is the autonomous tool Jackson frames as the self-learning “brain” of his setup, positioned as an alternative to the widely discussed OpenClaw framework. It owns the portfolio mechanics and trade scorer and reviews trades on a weekly cadence. These names and capabilities come from the creator’s own walkthrough and should be verified independently before you rely on them.