Lewis Jackson Self-Improving Trading Agent Framework

// When should I use the Lewis Jackson Self-Improving Trading Agent Framework?

Use this skill when you want to build or upgrade an automated trading agent that goes beyond static rules and can adapt its strategy over time. Trigger it when you have a trading strategy (or want one built) and want to architect it into a self-improving system running continuously in the cloud.

// What inputs do I need to set up a self-improving trading agent?

• Existing trading strategy (optional)
  A pre-built strategy file or documentation on your current approach (e.g. entry/exit rules, asset class, position sizing). If absent, the onboarding agent will scaffold a basic baseline strategy for you.
• Target assetrequired
  The asset or market you want the agent to trade (e.g. Bitcoin, Ethereum, Solana, a specific subnet token, forex pair, etc.).
• Success definitionrequired
  A specific, measurable goal — e.g. target monthly return percentage, minimum Sharpe score, maximum drawdown threshold. Must be within realistic bounds given your starting capital.
• Failure definitionrequired
  The threshold or condition that constitutes failure — e.g. drawdown below X%, return below Y% over Z days. Used by the agent to orient improvement direction.
• Starting capital amountrequired
  The capital available for trading. Used to sanity-check whether the success definition is achievable (e.g. targeting $1M/month on $10 capital is flagged as impossible).
• Railway accountrequired
  A Railway.app account for 24/7 cloud hosting of the agent so it runs regardless of whether your local machine is on.

// What core principles make the self-improving trading agent work?

// How do you build a self-improving trading agent step by step?

1. 1

   Define your four agent criteria before writing a single line of code

   Before touching any tooling, answer in writing: (1) How will I ensure data accuracy? (2) How will I guarantee 24/7 reliability? (3) What is my exact success definition (target return, Sharpe score, drawdown limit)? (4) What is my exact failure definition? These four answers become the scoring and improvement backbone of the entire agent. Do not skip this — without a well-defined goal, the self-improvement loop has no direction.

2. 2

   Obtain the oneshot prompt from the creator's community resource

   Retrieve the most current version of the oneshot prompt (Lewis Jackson stores these in 01 Systems community > Classroom > YouTube Video Prompts). Always use the latest version — these prompts are themselves iterated based on community feedback and supersede any version shown in the video.

3. 3

   Open Claude Code in your terminal and paste the oneshot prompt

   Launch a terminal session with Claude Code. Paste the oneshot prompt in full. The prompt initiates a guided multi-phase onboarding flow — do not try to shortcut or pre-answer phases; let the agent walk through each phase in sequence.

4. 4

   Complete Phase 1 — Environment Check

   The agent detects your OS (Mac or Windows) and available runtimes (e.g. Node.js). It will fork into OS-specific instructions. Confirm your environment when prompted. No action needed beyond confirmation if your environment is detected correctly.

5. 5

   Complete Phase 2 — Strategy Definition

   Choose one of three paths: (A) Point the agent at an existing strategy file on your machine by name — it will locate, parse, and extract goals and parameters from it. (B) Tell the agent you have no strategy and want a basic one scaffolded — it will create a solid baseline. (C) Build a new strategy interactively with the onboarding agent. Whichever path, the agent will output a strategy document including: asset, position limits, slippage tolerance, gas reserve, scorer weights, target return, Sharpe floor, max drawdown, and failure thresholds. Confirm or correct these before proceeding.

6. 6

   Complete Phase 3 — Scaffold the Hermes Side-State

   The agent creates all folders, files, and a Hermes-readable trade ledger. Existing trade history (wins and losses) is converted into structured data Hermes can analyze. Review the generated strategy document and goals document to confirm they accurately reflect your intent — this is the source of truth the self-improvement loop will reference.

7. 7

   Complete Phase 4 — Strategy Deployment (if not already live)

   If you already have a live strategy, this phase may be skipped automatically. If not, the agent will walk you through connecting the necessary APIs to make trades execute. Ensure API connections are validated before proceeding — inaccurate API connections undermine the Accuracy criterion.

8. 8

   Authenticate with Railway for 24/7 cloud hosting

   When prompted, the agent will attempt a Railway CLI login. If the interactive login fails inside the session, open a split terminal, paste the provided login command, complete browser authentication, then return and type 'done, continuing'. If you don't have a Railway account, create one during this step — it is free up to a significant usage threshold. This step ensures Reliability: the agent runs 24/7 regardless of local machine state.

9. 9

   Allow the agent to install Hermes automatically

   The oneshot prompt installs Hermes agent as part of the handoff phase. Verify installation by opening a new terminal and typing 'hermes' — if it launches, installation succeeded. Hermes is now the self-learning brain that will review trades on a weekly cadence, own portfolio mechanics and score weights, and write updated strategy iterations.

10. 10

    Review the final configuration summary and confirm

    The agent will output a full confirmation: deployed strategy name, live asset, Railway hosting status, Hermes brain assignment, review cadence, Sharpe floor, max drawdown, and operating mode. The FIRST Hermes cycle is READ-ONLY — Hermes observes and produces a markdown review but does not write to the live strategy yet. You must manually approve the transition to live mode by editing the Hermes trading strategy YAML. Do not flip to live mode until you have reviewed the first cycle's output.

11. 11

    Monitor improvement cycles and approve strategy promotions

    Hermes reviews trades on a weekly cadence. It will produce scored hypotheses, change ONE variable, and run the next cycle against the new baseline. Use the check-in commands provided in the final summary to inspect cycle outputs. When Hermes produces a cycle result that moves toward your success definition, it becomes the new baseline. Track directional progress: toward-goal outputs are good signals; away-from-goal outputs inform the next hypothesis.

// What does the self-improving trading agent look like in real scenarios?

// What mistakes should I avoid when building a self-improving trading agent?

• Defining a success goal that is impossible relative to your starting capital — the agent cannot self-improve toward an unreachable target and will waste cycles. Sanity-check: $10 starting capital cannot target $1M/month.
• Skipping or vaguely defining the failure threshold — without a clear failure definition, the agent has no polarity to orient its improvement direction. 'Losing money' is not a failure definition; 'drawdown exceeding 15% in any 30-day window' is.
• Changing multiple strategy variables between cycles — if you or a secondary agent modifies several parameters simultaneously, the learning signal is corrupted. You cannot attribute the result to any single change. Enforce the scientific method: one variable per cycle.
• Flipping to live trading mode before reviewing the first Hermes read-only cycle — the first cycle exists to validate that Hermes has correctly understood your strategy and goals. Skipping this review risks live capital being managed by a misconfigured loop.
• Using inaccurate or inconsistently sourced data — different AI interpretations of the same news article can produce different conclusions. Establish objective, rules-based interpretation criteria for all non-numerical inputs before deploying.
• Hosting the agent locally instead of on Railway — a local-only agent goes offline when your machine does, violating the Reliability criterion. The 24/7 cloud hosting is non-negotiable for the system to function as designed.
• Treating the oneshot prompt as static — the prompt improves over time based on community feedback. Always pull the latest version from the community resource rather than reusing a version from a video recording.

// What do the key terms in the self-improving trading agent framework mean?

Self-Improving Trading Agent

An autonomous trading agent that completes a continuous loop: execute strategy → observe outcome → analyze toward-goal or away-from-goal → form hypothesis → change one variable → update strategy → repeat. Distinct from a static bot that executes fixed rules without learning.

Hermes Agent

The self-learning AI brain installed into the trading agent stack. Hermes natively learns from every interaction and engagement without requiring manual retraining instructions. It owns portfolio mechanics, score weights, and weekly strategy review cycles.

Oneshot Prompt

A single copy-paste prompt that, when fed into Claude Code, orchestrates the entire agent setup end-to-end: environment detection, strategy onboarding, scaffolding, cloud deployment, and Hermes installation. No multi-step manual configuration required.

Well-Defined Goal

A specific, measurable destination that includes both a success definition (e.g. target return, minimum Sharpe score) and a failure definition (e.g. maximum drawdown, minimum return floor). The agent uses this polarity to orient every improvement cycle.

Sharpe Score

A numerical metric representing the risk-adjusted profitability of a trading strategy. Used as a quantitative success/failure threshold in the agent's goal definition rather than relying on subjective performance assessment.

Hermes-Readable Ledger

A structured file of all historical trades (wins and losses) converted into a format Hermes can parse, score, and learn from. Generated automatically during Phase 3 scaffolding from existing trade history.

Scientific Method Loop

The self-improvement cycle protocol: change only ONE variable per iteration, observe the outcome, promote the better-performing version to the new baseline, then iterate again. Ensures clean attribution of performance changes to specific strategy modifications.

Railway

Cloud hosting platform used to run the trading agent 24/7, independent of the user's local machine. Integrates with the terminal via CLI so strategy updates are pushed automatically without manual redeployment.

Read-Only Cycle

The first Hermes review cycle, in which Hermes observes, scores, and produces a markdown analysis of the strategy but does not write any changes to the live strategy. The user must manually approve the transition to live write mode.

Score Weights

Configurable parameters in the strategy document that determine how different trade outcomes are scored relative to the defined goal. Hermes owns and adjusts score weights as part of its self-improvement process.

Weekly Cadence

The default review and improvement cycle frequency for Hermes — once per week, with a 3-day offset from any secondary agent (e.g. Cornelius) to prevent simultaneous conflicting parameter updates.

01 Systems

Lewis Jackson's free community resource where all oneshot prompts from his videos are stored, versioned, and updated. Always retrieve prompts from here rather than manually transcribing from video to ensure you have the most improved version.

// FREQUENTLY ASKED QUESTIONS