8 AI trading github repos that print $$$ (ranked)

8 AI Trading GitHub Repos: Setup Guide

How to use this file: drag it into your AI coding agent and type:

Set these up for me.

It works with any AI that can run commands on your computer: Claude Code, or Codex if you use ChatGPT. Your AI reads the install plan below, asks which repos you want, installs them one at a time, tests each one and gives you a pass/fail table at the end. Two of the eight (Anthropic financial-services and day-trader-skill) are Claude Code plugins, so they're marked Claude Code only.

Under the install plan there's a plain-English guide to each repo with prompts you can copy, including the exact prompts from the video.

No AI agent? Each repo section below has the manual steps.

Install steps were copied from each repo's README on 27 October 2026 and this guide was updated on 29 October 2026 to match the video. If a README has changed since, the README wins.

Read once: none of these make money on their own. Nothing in this guide uses real money. The only broker connection is an Alpaca paper account (fake money) for Vibe-Trading, and Freqtrade stays in dry-run. This is software, not financial advice.

The tier list

What each one costs

INSTALL PLAN (instructions for your AI)

AI assistant: the user gave you this file so you can install these repos for them. Follow these steps.

Rules

1. No real money. Paper and dry-run only. Never turn on live trading, never set Freqtrade's dry_run to false, and never connect a broker or exchange account that uses real money.
2. The only broker connection is Alpaca paper, for Vibe-Trading, and only if the user wants that step. Don't connect a broker to any other repo, even if its README offers one.
3. Never ask the user to paste an API key, password or token into the chat. When a key is needed, create the .env or config file with an empty placeholder. Tell the user which file to open and which line to fill in, then wait for them to say "done". For logins that open a browser, give them the exact command to run in their own terminal.
4. Don't run `curl … | bash` installers or anything not listed here without asking first.
5. Before installing each repo, read its current README on GitHub. If the steps below conflict with it, follow the README and tell the user what changed.
6. Put everything in ~/ai-trading-repos/, with one folder per repo and a separate Python environment for each one.
7. Install one repo at a time and run its smoke test before moving on. If a step fails twice, write down the error, skip that repo and keep going.
8. Explain what you're doing in plain English as you go. Assume the user isn't a developer.

Step 0: Ask, then check prerequisites

Show the user the tier list above and ask which repos they want. The default is all 8. Also ask:

• Are you running this in Claude Code or Codex? (In Codex, skip Anthropic financial-services and day-trader-skill: they're Claude Code plugins.)
• Do you have a ChatGPT Plus or Pro plan? (TradingAgents can run on it instead of an API key.)
• Which AI API key do you have, if any: Anthropic, OpenAI or another?
• Your watchlist: 3-10 stock tickers, e.g. NVDA,AAPL,TSLA,MSFT.
• Do you want Telegram messages from daily_stock_analysis and Freqtrade? (Free bots from @BotFather.)
• Do you want Vibe-Trading's paper-trading step? (Needs a free Alpaca paper account.)

Then check for each tool and install anything missing (ask first):

• git
• Python 3.11 or newer
• uv (https://docs.astral.sh/uv/) or pipx
• gh, the GitHub CLI, logged in. Optional, but it makes daily_stock_analysis much faster

1. TradingAgents (S)

mkdir -p ~/ai-trading-repos && cd ~/ai-trading-repos
git clone https://github.com/TauricResearch/TradingAgents.git
cd TradingAgents
uv venv --python 3.13 && source .venv/bin/activate
uv pip install .
cp .env.example .env

Pick the AI provider:

• ChatGPT plan: tell the user to run this in their own terminal and finish the browser sign-in:

~/ai-trading-repos/TradingAgents/.venv/bin/tradingagents login chatgpt Use provider chatgpt.

• API key: tell the user to open ~/ai-trading-repos/TradingAgents/.env and fill in ANTHROPIC_API_KEY= or OPENAI_API_KEY=. Use provider anthropic or openai.

Smoke test: run a cut-down analysis on the last completed trading day. Run it in the background, because it takes a few minutes:

cd ~/ai-trading-repos/TradingAgents && source .venv/bin/activate
export TRADINGAGENTS_LLM_PROVIDER=<chatgpt|anthropic|openai>
export TRADINGAGENTS_QUICK_THINK_LLM=<quick model> TRADINGAGENTS_DEEP_THINK_LLM=<deep model>
export TRADINGAGENTS_OUTPUT_LANGUAGE=English TRADINGAGENTS_MAX_DEBATE_ROUNDS=1 TRADINGAGENTS_MAX_RISK_ROUNDS=1
tradingagents --ticker NVDA --date <last trading day, YYYY-MM-DD> --analysts market --save --no-show

Set both model variables, because a run without a terminal can't ask for them. For anthropic use claude-sonnet-5 (quick) and claude-opus-5-5 (deep); for openai use gpt-6-luna and gpt-6-sol; for chatgpt the models depend on the plan, so have the user run tradingagents once in their own terminal to see the list. The full list per provider is in tradingagents/llm_clients/model_catalog.py. If it stops with "No terminal to answer the setup questions. Set: …", set every variable it lists and retry.

Pass when it prints "Report saved to:". Open decision.md in that folder (under ~/.tradingagents/logs/reports/NVDA_<timestamp>/) and read the **Rating**: line (Buy / Overweight / Hold / Underweight / Sell). A rating of REVIEW means no rating could be read. Don't connect it to a broker.

2. Anthropic financial-services (A) · Claude Code only

claude plugin marketplace add anthropics/financial-services
claude plugin install financial-analysis@claude-for-financial-services
claude plugin install equity-research@claude-for-financial-services

financial-analysis is the core, with /dcf, /comps and /lbo. equity-research adds /earnings, /earnings-preview, /catalysts, /thesis and /screen.

Then show the user the named agents and install the ones they want. The four from the video:

claude plugin install meeting-prep-agent@claude-for-financial-services
claude plugin install market-researcher@claude-for-financial-services
claude plugin install earnings-reviewer@claude-for-financial-services
claude plugin install valuation-reviewer@claude-for-financial-services

The full list is in the README's Agents table (pitch agent, model builder, GL reconciler, month-end closer, statement auditor and KYC screener are the others). Tell the user what the agents need:

• The research and advisory agents (meeting prep, market researcher, earnings reviewer, pitch agent, model builder) are built to pull from paid data connectors (S&P Capital IQ, FactSet, Daloopa, a CRM).
• The fund-admin and operations agents (valuation reviewer, GL reconciler, month-end closer, statement auditor, KYC screener) expect a fund's own internal systems. The valuation reviewer, for example, reviews private-equity valuation packages, so it's only useful if you run or work at a fund.
• The agents can't search the web, so without those connections they only work from files the user gives them. The slash commands run in the normal session and work from public filings and the web.

Installing financial-analysis also adds 12 data connectors (FactSet, Morningstar, S&P Global and others). They show as not connected until someone signs in to a paid account. That's expected; leave them. Excel output needs Python with openpyxl on the machine (pip install openpyxl).

Optional: better data with FMP. FMP (Financial Modeling Prep) has an official connector for Claude. Ask the user if they have an FMP account (sign up with 20% off: https://tinyurl.com/FMPMiles). If they do, they copy their API key from the FMP dashboard and run this in their own terminal, so the key never goes into the chat:

claude mcp add --transport http fmp "https://financialmodelingprep.com/mcp?apikey=THEIR_FMP_KEY"

Claude can then pull FMP data when it runs the slash commands. The named agents stay wired to their own connectors listed above.

Smoke test: claude plugin list shows the plugins. Tell the user to start a new Claude Code session so the commands load, then type /dcf.

3. Vibe-Trading (A)

uv tool install vibe-trading-ai --with alpaca-py   # or: pipx install vibe-trading-ai && pipx inject vibe-trading-ai alpaca-py
vibe-trading --help

alpaca-py is only needed for the paper-trading step. Leave it out if the user said no.

Pick the AI provider. Vibe-Trading reads its settings from ~/.vibe-trading/.env.

• Claude Code users (no API key needed): skip vibe-trading init, because its menu has no Claude Code option. Create ~/.vibe-trading/.env yourself (it holds no secrets):

  LANGCHAIN_PROVIDER=claude-cli
  LANGCHAIN_MODEL_NAME=claude-opus-5-5
  VIBE_TRADING_DENY_TOOL_PREFIXES=etoro_

The last line matters for paper trading: by default the Claude Code provider hides all the trading tools, so without it Vibe-Trading can't see the Alpaca account or place paper orders. Then check the login with vibe-trading provider login claude-cli (it only reports the login; if it says not logged in, the user runs claude auth login).

• Codex / ChatGPT users (no API key needed): tell the user to run vibe-trading init in their own terminal and pick OpenAI Codex (ChatGPT OAuth), then run vibe-trading provider login openai-codex, sign in in the browser and paste the callback URL back when asked. It needs a ChatGPT plan with Codex access.
• API key users: tell the user to run vibe-trading init in their own terminal and pick their provider. For an Anthropic key, install with the extra instead (uv tool install "vibe-trading-ai[anthropic]" --with alpaca-py), then create ~/.vibe-trading/.env with LANGCHAIN_PROVIDER=anthropic, LANGCHAIN_MODEL_NAME=claude-opus-5-5 and an empty ANTHROPIC_API_KEY= line for the user to fill in.

Optional: add it as an MCP so Claude Code can call its research tools directly. The MCP can read a broker account but can't place orders, so paper trading always runs inside Vibe-Trading itself:

claude mcp add vibe-trading --scope user -- vibe-trading-mcp

Paper trading on Alpaca (only if the user said yes in Step 0):

1. The user signs up free at https://alpaca.markets and switches the dashboard to Paper Trading. The paper account runs on fake money; they can reset it to $100,000.
2. In the paper dashboard they generate an API key. They get two values: an API Key ID and a Secret Key. Paper keys only work on Alpaca's paper server, so they can't touch real money.
3. Create ~/.vibe-trading/alpaca.json with empty placeholders and owner-only permissions (chmod 600):

   {
     "api_key": "",
     "secret_key": "",
     "profile": "paper",
     "feed": "iex"
   }

Tell the user to open the file, paste the Key ID into api_key and the Secret Key into secret_key, and save. Wait for "done". Never change profile from paper.

1. Select the paper trading profile and check it:

   vibe-trading connector use alpaca-paper-trade
   vibe-trading connector check
   vibe-trading connector account

Pass when the account shows the paper balance. Never select alpaca-live-trade or alpaca-live-sdk-readonly. If anything suggests a live account, stop and tell the user.

1. Tell the user: run paper-trading prompts inside Vibe-Trading (vibe-trading for the chat, or vibe-trading run -p "..."), not through Claude Code's MCP. Orders sent outside US market hours are accepted but only fill at the next open.

Smoke test (the README's own first task):

vibe-trading run -p "Backtest a BTC-USDT 20/50 moving-average strategy for 2024 and summarize return and drawdown"

Pass when it prints a return and a max drawdown.

Warning for the user: the X account VibeTrading_HKU and any Vibe-Trading crypto token are fake. The project has never launched a token.

4. daily_stock_analysis (A)

This one runs on GitHub's servers every weekday, so nothing stays on the user's computer.

1. Fork it. With gh: gh repo fork ZhuLinsen/daily_stock_analysis --clone=false. Without it, the user clicks Fork at https://github.com/ZhuLinsen/daily_stock_analysis.
2. Set the settings that aren't secret. You can do this with gh, replacing <user> with their GitHub username and the list with their watchlist:

   gh variable set STOCK_LIST --repo <user>/daily_stock_analysis --body "NVDA,AAPL,TSLA,MSFT"
   gh variable set REPORT_LANGUAGE --repo <user>/daily_stock_analysis --body "en"
   gh variable set MARKET_REVIEW_REGION --repo <user>/daily_stock_analysis --body "us"
   gh variable set ANTHROPIC_MODEL --repo <user>/daily_stock_analysis --body "<a current Claude model ID>"

Set ANTHROPIC_MODEL only if they're using an Anthropic key. The workflow's built-in default is a 2024 Claude model, so set a current one, e.g. claude-sonnet-5-5 (model list: https://platform.claude.com/docs). Without REPORT_LANGUAGE=en, reports come out in Chinese, and without MARKET_REVIEW_REGION=us the market recap covers China instead of the US.

1. Help the user make a Telegram bot: message @BotFather on Telegram, send /newbot and copy the token. Then message the new bot once and open https://api.telegram.org/bot<TOKEN>/getUpdates to find "chat":{"id": ...}.
2. Have the user add the secrets themselves. Either they run gh secret set NAME --repo <user>/daily_stock_analysis, which asks for the value hidden, or they add them in the browser at https://github.com/<user>/daily_stock_analysis/settings/secrets/actions:

• one AI key: ANTHROPIC_API_KEY, OPENAI_API_KEY or GEMINI_API_KEY
• TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID
• optional but recommended, for better news: SERPAPI_API_KEYS or BRAVE_API_KEYS

1. The user opens the Actions tab of their fork and clicks "I understand my workflows, go ahead and enable them".

Smoke test: gh workflow run 00-daily-analysis.yml --repo <user>/daily_stock_analysis -f mode=full -f force_run=true. In the browser: Actions → 每日股票分析 (Daily Stock Analysis) → Run workflow, with "force run" ticked. Force run matters on weekends and holidays, when it otherwise skips itself. Pass when the report arrives in Telegram. By default it runs every weekday at 10:00 UTC, before the US market opens.

5. Freqtrade (B)

cd ~/ai-trading-repos
git clone -b stable https://github.com/freqtrade/freqtrade.git
cd freqtrade
yes n | ./setup.sh -i      # installs into .venv; "n" skips the optional extras
source .venv/bin/activate
freqtrade create-userdir --userdir user_data

Before running setup.sh: make sure no virtual environment is active (it exits if one is). On a Mac, check that Homebrew (brew) is installed; if it isn't, the script downloads the Homebrew installer, so ask the user first (Rule 4). On Linux it runs sudo apt-get, so it may ask for the user's password. Answering "n" skips the machine-learning extras (hyperopt, FreqAI); they can be added later with pip install -r requirements-hyperopt.txt.

Write user_data/config.json for dry-run only. Start from config_examples/config_binance.example.json and set:

• "dry_run": true
• "dry_run_wallet": 1000
• "timeframe": "1h"
• pair_whitelist: BTC/USDT and ETH/USDT
• the exchange key and secret left empty

Use Binance. If Binance is blocked where the user lives (it is in the US, Canada, Malaysia and the Netherlands), use binanceus for US users, or OKX. Avoid Kraken here: its API only returns 720 candles, so backtests need extra steps.

Telegram control (only if the user said yes in Step 0): have them make a separate bot with @BotFather (not the daily_stock_analysis one) and find its chat ID the same way. In config.json add a "telegram" block with "enabled": true and empty "token" and "chat_id" placeholders, then tell the user to fill them in. Start the bot with freqtrade trade --config user_data/config.json --strategy SampleStrategy and have them send /status, /profit and /daily from Telegram.

Smoke test:

freqtrade download-data --config user_data/config.json --days 60 -t 1h
freqtrade backtesting --config user_data/config.json --strategy SampleStrategy --timeframe 1h

Pass when the backtest table prints. (The --timeframe 1h matters: the bundled SampleStrategy defaults to 5-minute candles, and without it the backtest finds no data.)

6. day-trader-skill (B) · Claude Code only

cd ~/ai-trading-repos
git clone https://github.com/Jakeschincariol/day-trader-skill.git
cd day-trader-skill && python3 -m unittest discover -s tests -v
claude plugin marketplace add Jakeschincariol/day-trader-skill
claude plugin install day-trader-skill@day-trader-skill

The SEC tools need the user's name and email as an ID. Ask for them, then set SEC_USER_AGENT="Their Name their@email.com" in their shell profile, or "sec_user_agent" in trader/config.json. Leave "paper": true alone and don't connect a broker for the broker skill.

Smoke test: the offline unit tests pass. Tell the user to start a new Claude Code session. The commands show up as /day-trader-skill:trader-scanner and so on.

7. ai-hedge-fund (B)

uv tool install aihf       # or: pipx install aihf

Create `~/.hedge-fund/.env` with empty `FINANCIAL_DATASETS_API_KEY=` and one AI key line, e.g. `ANTHROPIC_API_KEY=`. The user fills these in. Financial Datasets is a paid key from https://financialdatasets.ai, so tell them before they sign up. It's required: the app asks for it before every run, and it can't use FMP or any other data provider instead. There's no live mode or broker connection in the current version, so it can only backtest and paper-trade.

Smoke test: tell the user to run aihf in their own terminal, because it's an interactive app. In Backtesting, they build a fund with all the investor strategies on their watchlist and run it. Pass when the equity curve draws.

8. LLM-Trading-Lab (C)

Nothing to install. It's a record of an experiment.

cd ~/ai-trading-repos
git clone https://github.com/LuckyOne7777/LLM-Trading-Lab.git

Smoke test: read Experiments/chatgpt_micro-cap/csv_files/Daily Updates.csv (the filename has a space, so quote it) and tell the user the final account value: $84.48 on 26 December 2025. It started with $100 on 27 June; the CSV's first row (30 June) already shows $104.21.

Finish

Give the user a table with these columns:

• repo
• PASS / FAIL / SKIPPED
• what the smoke test returned
• where it's installed
• one first prompt to try, taken from the guide below

List anything they still need to do themselves, such as a key to fill in or a session to restart.

How to use each one

S: TradingAgents

What it does

• Works like a real investment firm made of 12 AI agents. It's like having a hedge fund in your pocket
• Analysts look at the market, social media, news and the company's fundamentals
• The research team debates the evidence: a bull argues to buy and a bear argues to sell
• The trader turns that into a proposal, the risk team decides how aggressive, neutral or conservative to be, and the manager makes the final call
• You can read every step of the reasoning
• Out of the box it's research: it ends with a rating. Wiring its decision to a broker is extra work you do yourself, on paper first. Miles has a full video on TradingAgents if you want the deep dive

How to run it

• Type tradingagents (with its folder's environment active) and answer the menu: ticker, date, output language, analysts, depth, AI provider and models
• Crypto uses -USD: BTC-USD, ETH-USD. Crypto gets three analysts (market, sentiment, news); the fundamentals analyst is for stocks only
• Other markets use Yahoo Finance tickers: AAPL, 0700.HK, BHP.AX
• Start with Shallow depth: it's faster and cheaper
• Each saved run gives you a full report plus a one-page HTML version you can open in a browser
• It remembers its past calls. The next time you run the same ticker, it checks how its last call played out

Prompts to try

Run TradingAgents on BTC-USD for today with all three crypto analysts (market, sentiment, news) at shallow depth. Show me the final rating, the strongest bull point, the strongest bear point, and what would change its mind.

Run TradingAgents on NVDA for today, once with my ChatGPT plan and once with Claude, same settings. Put the two final ratings side by side with the main reason behind each.

Run TradingAgents on ETH-USD and SOL-USD for today. Tell me which one the bear researcher had the stronger case against, and why.

Know this: a full run takes several minutes per stock. Two runs on the same stock can disagree. Read the reasoning, not just the rating.

A: Anthropic financial-services (Claude Code only)

What it does

• Made by Anthropic, the company behind Claude: the toolkit they built for banks and investment funds
• Less about trading, more about the work a fund does: investment banking, equity research, private equity and wealth management
• 10 named agents that do the jobs of a fund team, grouped the way a fund is:
• Advisory: meeting prep agent (a briefing pack before every client meeting), pitch agent
• Research and modeling: market researcher (researches an industry and shortlists ideas), earnings reviewer (reads the latest earnings call and filings, updates the model, drafts the note), model builder
• Fund admin: valuation reviewer (runs portfolio valuations and stages reporting to investors), GL reconciler, month-end closer, statement auditor
• Operations: KYC screener
• The research and advisory agents are built to pull from paid data (S&P Capital IQ, FactSet, Daloopa, a CRM), and the fund-admin and operations agents from a fund's own systems. They can't search the web, so without those connections give them the files to work from, or use the commands below, which work from public filings and the web
• Analyst commands, including:
• /earnings: an earnings update report for one quarter
• /dcf: what a company is worth, based on its future cash
• /comps: how it compares to rivals
• /earnings-preview: what to watch before earnings
• /catalysts: upcoming events that could move the stock
• /screen: find stock ideas
• /thesis: write down and track why you own something
• It can build the model as a working Excel spreadsheet
• It doesn't trade

Prompts to try

/earnings NVDA, latest reported quarter. Compare the results with expectations, pull out guidance and what management said on the call, and draft a one-page note.

I saved NVDA's latest earnings call transcript and 10-Q in ~/Documents/nvda-q. Use the earnings reviewer agent on those files: update the key numbers and draft the post-earnings note.

/dcf NVDA. Build a discounted cash flow model from the latest public filings. Show your assumptions, the fair value per share versus today's price, and how much the value changes if growth is 5% lower.

/comps AMD against NVDA, AVGO, QCOM and INTC. Which looks cheapest on forward earnings, and is there a good reason it's cheap?

Know this: it's built for professionals. Without paid data it works from public filings and the web, which is fine to learn on but slower and less precise. For faster, more accurate numbers, connect FMP (official connector, steps in the install plan; sign up with 20% off: https://tinyurl.com/FMPMiles). The repo's built-in connectors are for big-firm providers like FactSet, S&P Capital IQ and Morningstar. Check any figure that matters.

A: Vibe-Trading

What it does

• A trading research assistant from a university lab in Hong Kong
• You describe a trading idea in plain English
• It gets the data, writes the strategy and tests it on past prices; ask it to compare the result with just holding
• It can paper-trade the idea on Alpaca, with fake money
• No data keys needed: free sources cover US, Hong Kong and China stocks plus crypto

How to run it

• vibe-trading opens the chat in your terminal
• vibe-trading run -p "..." runs one task
• vibe-trading serve --port 8899 starts its API server. The browser dashboard needs the Docker install from the README (docker compose up --build, then http://localhost:8899)

The prompt from the video (needs the Alpaca paper step from the install plan; run it in vibe-trading, not through Claude Code's MCP. If it simulates the trades instead of sending them to Alpaca, add "(connector alpaca-paper-trade)" after "my Alpaca account")

Find me the best-performing momentum strategy across NVDA, META, AAPL, MSFT and AMZN over the last two years. Backtest it with realistic fees and show me the equity curve. Set it up to paper-trade on my Alpaca account with $100,000 and run the first cycle. Show me the orders it places.

More prompts to try

Test three different momentum strategies on NVDA, META, AAPL, MSFT and AMZN over the last two years with 0.1% fees. Compare each one to buying and holding all five. Show return, max drawdown and number of trades, and tell me honestly if any of them beat holding.

Backtest buying BTC when it closes above its 200-day average and selling when it closes below, since 2020. Compare it to just holding BTC. Show the equity curve.

Know this:

• Alpaca has a paper account and a live account. Only ever connect the paper one, and run vibe-trading connector account first to check you're on it
• If you ask for "the best one", it may test only one strategy. Ask it to compare several
• It does what you tell it. If you ask it to paper-trade, it will, even when the backtest was bad
• Read the result before you act on it

A: daily_stock_analysis

What it does

• Every weekday morning it sends a report on your watchlist to Telegram, Discord, Slack or email
• Each stock gets:
• buy, watch or sell
• a score out of 100
• price levels
• risk alerts
• Runs free on GitHub. Nothing to keep running on your computer
• Open source, so you can change anything about it

How to use it

• Change your stocks: edit the STOCK_LIST variable in your fork (Settings → Secrets and variables → Actions → Variables)
• Run it now: Actions tab → 每日股票分析 (Daily Stock Analysis) → Run workflow (tick "force run" on a weekend)
• Pause it: Actions tab → the workflow → "…" → Disable workflow

Prompts to try (with gh logged in)

Set up https://github.com/ZhuLinsen/daily_stock_analysis for me on GitHub Actions: fork it, evaluate NVDA, AAPL, TSLA and MSFT, and send the report to my Telegram in English every weekday morning before the US market opens. Tell me exactly which secrets to add and where.

Update my daily_stock_analysis fork so STOCK_LIST is NVDA, AMD, AVGO, TSM, ARM, then trigger a run and tell me when it finishes.

Know this: it's quick takes, not deep research, and the price levels are the AI's read of the chart, so treat them as a starting point. The main README is in Chinese; the English one is at docs/README_EN.md.

B: Freqtrade

What it does

• A free, open-source crypto trading bot that's been around since 2017, with hundreds of contributors
• It doesn't come with a strategy. You give it rules and it follows them exactly
• Dry-run mode trades fake money on live prices
• Backtesting tests your rules on past prices, and its optional machine-learning tools (hyperopt, FreqAI) can help tune a strategy
• Control it from Telegram: check your open trades, ROI and daily profit, and tell it what to do
• Works with many exchanges; the docs list which ones

Telegram commands to start with: /status (open trades), /profit (ROI), /daily (daily profit), /stop (stop the bot)

The easy way to use it: have your AI write the rules, then backtest them before anything else.

Set up Freqtrade in dry-run mode for BTC/USDT and ETH/USDT. On the 1-hour chart, write a strategy that buys when the price closes above its 20-day high, the daily RSI is between 50 and 70, and volume is above its 20-bar average. Sell when it closes below the 10-period EMA or the daily RSI goes above 80. Use a 4% stop loss and take profit at 8%. Backtest it over the last 3 months and the 9 months before that, and compare each period to just holding.

Look at the backtest you just ran. Which trades lost the most and what did they have in common? Suggest one rule change, backtest it, and show me before and after. Don't optimise it until it only fits the past.

Start the bot in dry-run with my strategy and turn on Telegram control so I can check it from my phone. Keep dry_run true.

Know this: it's only as good as your rules. A strategy that looks great on past prices can still lose money live. It's crypto only, and setup is more technical than the others. Stay in dry-run.

B: day-trader-skill (Claude Code only)

What it does

• 11 skills that add a day-trading desk to Claude, using free public data
• The main ones:
• Scanner: scans charts for setups
• News: monitors breaking news
• Entry and Exit: times your way in and out
• Time Machine: replays the trade 10,000 times plus every past time the setup appeared, and gives you the odds
• Risk and Budget: size the trade and check it against your limits
• Broker: places orders (paper by default, never without your "yes")
• Price alerts
• Extras: earnings summaries and a Congress stock-trade tracker
• Not on Claude Code? The README shows how to paste a single skill into any AI chat, including ChatGPT. You lose the built-in Python tools, but the method still works

Commands (installed as a plugin, they start with /day-trader-skill:) trader-scanner, trader-news, trader-entry, trader-exit, trader-timemachine, trader-risk, trader-budget, trader-broker, trader-alerts, trader-analyst, trader-pelosi

Prompts to try

/day-trader-skill:trader-scanner Scan the most active US stocks for opening-range breakouts this morning and give me the top 5.

/day-trader-skill:trader-timemachine Take the best setup from that scan and replay it. What are the odds it hits my target before my stop?

/day-trader-skill:trader-news What's the breaking news on NVDA, TSLA and AMD this morning, and does any of it change today's setups?

Know this:

• It's brand new, so expect bugs and updates
• Day trading is the hardest way to make money, and most people who do it lose
• The Time Machine is a simulation built from the stock's recent history, not a prediction
• Congress members can report trades up to 45 days after they happen

B: ai-hedge-fund

What it does

• AI versions of famous investors look at your stocks. The current version has five: Warren Buffett, Charlie Munger, Benjamin Graham, Peter Lynch and Stanley Druckenmiller, plus a quant model. Michael Burry, Cathie Wood and others are on the roadmap
• Each one gives a verdict (bullish, bearish or neutral), a confidence level from 0 to 100 and its reasoning, so you get an investment council's view before you buy
• You can build a "fund", backtest it against a benchmark or paper-trade it with fake money
• There's no live trading yet: a live broker connection (Interactive Brokers or Alpaca) is on the roadmap, not built

How to run it

• Type aihf to open the app
• Paper trading: your funds run on real market days with fake money
• Backtesting: replay a fund over history and watch the equity curve
• Fund settings live in ~/.hedge-fund/mandates/

Prompts to try (after you've built a fund in the app)

Run my ai-hedge-fund mandate on NVDA, TSLA and COIN. Show a table: stocks down the side, investors across the top, each cell is their signal and confidence. Then tell me where the value investors and the growth investors disagree most.

Make two funds in ai-hedge-fund: one with only the value investors (Buffett, Munger, Graham) and one with the growth and momentum investors (Lynch, Druckenmiller). Backtest both on the same five stocks and compare them to the benchmark.

Know this: you need a paid Financial Datasets key; it's the only data source the app supports. The investor views are general, not what those people think today. Treat them as perspectives, not orders.

C: LLM-Trading-Lab

What it is

• In 2025, someone gave ChatGPT about $100 of real money for six months and made every trade it picked
• After the first month it was up about 24%, which made headlines
• It ended at about $84: down roughly 15%, and at one point down 50% from its high
• Charts of the run against the market and of the drawdown are in Experiments/chatgpt_micro-cap/images/
• Every trade, chat and weekly research report is saved in the repo, and it has grown into a framework for studying how AI models behave as portfolio decision-makers

Why it's on the list: it shows what happens when one AI makes every call with no one checking it. That's the gap TradingAgents fills.

Prompts to try

Clone https://github.com/LuckyOne7777/LLM-Trading-Lab. Read the daily updates and trade log CSVs for the ChatGPT micro-cap experiment. Tell me all of the details about the experiment: the starting value, the final value, the biggest drop from a peak, the worst single day, and which stock caused it.

Read the chat logs from the LLM-Trading-Lab experiment. Find the three decisions that cost the most money and explain what ChatGPT was thinking each time. What rule would have prevented each one?

Want to run your own version? The author's follow-up framework is at https://github.com/LuckyOne7777/LLM-Investor-Behavior-Benchmark

Build your own

They're all open source, so you can take the best part of each and combine them. For example: TradingAgents for the research, ai-hedge-fund's investor profiles as a second opinion, and Vibe-Trading to backtest the idea.

I've installed TradingAgents, ai-hedge-fund and Vibe-Trading with this guide. Help me design one workflow that uses TradingAgents for research, ai-hedge-fund's investor profiles as a second opinion, and Vibe-Trading to backtest the idea. Paper only, no broker connection. Then build a simple local dashboard that shows all three for one ticker.

Built something? Post it in the Skool and tag Miles.

Safety notes

• No real money. Keep everything on paper or dry-run, and don't point an AI at a real-money account.
• Never paste API keys or passwords into a chat. Put them in the .env file or settings page the tool asks for.
• Every AI call on an API key costs money. Start small: shallow depth, short backtests, a few stocks.
• Ignore crypto tokens or "official" social accounts claiming to be these projects unless the repo links to them.
• None of this is financial advice.