LLM Trading Lab: a forward-only record of ChatGPT managing a micro-cap portfolio
This repo powers my experiment where ChatGPT manages a real-money micro-cap stock portfolio.
At a glance
- What is it?
- LLM Trading Lab is a Python research repository that documents a six-month live experiment in which ChatGPT selected micro-cap trades under fixed rules, starting from $100. It is a logging and evaluation framework, not a trading system to deploy.
- Who is it for?
- Adopt LLM Trading Lab if you want a documented, forward-only record of an LLM making portfolio decisions and a directory structure to reuse for your own run. Do not adopt it as a production trading system: the README describes a single $100 experiment, no releases are published, and the licence is not stated in the repository metadata, so redistribution terms are unclear.
- Can I use it commercially?
- Not without permission. GitHub finds no licence file in the repository, and without a licence all rights are reserved by default: you may read the code but not reuse it. Check the README, or ask the authors, before using it.
- Is it still maintained?
- Yes. The repository last received commits 144 days ago.
- What is it written in?
- Mainly Python, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- LuckyOne7777/LLM-Trading-Lab7,552 ★ · +49
| Repository | 2026-09-13 | 2026-11-15 |
|---|---|---|
| LuckyOne7777/LLM-Trading-Lab | 7.5k | 7.6k |
49 Stars in the last 63 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The question this repository was built to answer
The README opens with a plain motivation: the author kept seeing advertisements claiming an AI could pick undervalued stocks, assumed they were selling subscriptions, and wanted to know how the claim would hold up. The experiment that followed started with $100 and asked whether a large language model could generate alpha or at least make defensible trading decisions using real-time data. The subject is micro-cap equities, which is the hardest place to test that question, because spreads are wide and published research is thin.
The intended audience is narrow. This is for someone who wants to inspect a real decision record rather than a backtest: the repository keeps daily updates, trade logs, weekly research summaries and a 40 page PDF evaluation under Experiments/chatgpt_micro-cap/evaluation/paper.pdf. It is not aimed at someone who wants a library to import. There is no package to install, no API surface described, and no release has been published. The unit of reuse is the folder layout and the scripts inside it.
What the repository actually contains
The layout in the README shows a single experiment directory with a trading script, a graphing folder holding daily_returns.py and drawdown.py, two CSV files named Daily_Updates.csv and Trade_Log.csv, an evaluation folder holding evaluation_report.md and paper.pdf, and a collected_artifacts folder with deep_research_index.md, chats.md and weekly deep research summaries.
Two claims in the README deserve scrutiny. The feature list mentions a live trading engine used in production and automated stop-loss enforcement, but the tree shows one script, trading_script.py, with no broker adapter, no scheduler and no separate risk module. Either the enforcement lives inside that single file or the description is looser than the layout suggests. The repository also states that historical artifacts remain unchanged and that new work is layered on top without rewriting past results. That is a discipline choice, and it means the CSV files function as an append-only ledger rather than a dataset you can freely reshape.
How the pieces fit together
The data flow implied by the tree runs in one direction. Something outside the repository produces a decision, captured in collected_artifacts/chats.md and the weekly summaries. That decision is recorded as a trade in csv_files/Trade_Log.csv and as a portfolio state in csv_files/Daily_Updates.csv. The graphing scripts, such as daily_returns.py and drawdown.py, sit beside those CSVs, and the evaluation folder holds the written report and paper.
The README does not say how ChatGPT's decisions reach the scripts, and requirements.txt pins the openai and anthropic client libraries, so do not assume the model sits outside the code. Either way, the CSVs are the system of record. The decision log is what makes the experiment auditable: the reasoning is frozen in chats.md before the outcome is known.
Getting it running on your own machine
The README gives a requirements.txt and a Makefile at the root, plus a stated stack of Python 3.11 or later, pandas, yfinance as the primary data source, Stooq as a fallback, and Matplotlib. The conventional sequence would be to create a virtual environment, install the requirements, and then invoke the Makefile targets, but the README does not list the target names, so you have to read the Makefile to find them.
The scripts are addressed by path rather than by package name. The Makefile's trade target runs python trading_script.py and its graph target runs python "Start Your Own/Generate_Graph.py", so check which directory each target expects before using it. Note the mismatch between the tree, which writes experiments/chatgpt_micro_cap, and the README's links, which write Experiments/chatgpt_micro-cap. The top-level folder in the repository is Experiments/ with a capital E, so check the real directory names on a case-sensitive filesystem. The CSV filenames are capitalised exactly as shown: Daily_Updates.csv and Trade_Log.csv. If you write your own loader, match that capitalisation.
The limitation that matters most: one $100 run
The entire empirical basis is a single experiment with a single starting balance of $100. That is enough to demonstrate a method and to produce a readable evaluation, and the forward-only logging makes the record honest. It is not enough to support any general claim about LLM stock picking. A sample of one cannot separate the model's skill from the market regime it happened to trade in, and micro-cap prices in particular are sensitive to liquidity conditions that vary month to month.
The $100 figure creates a second problem. In micro-caps, commission and spread costs are large relative to a small position, so the achievable return is bounded by frictions that a larger account would not face in the same proportion. Any reader tempted to scale the result upward should treat the reported metrics as an upper bound rather than a forecast. The README itself concedes that the project moved past chasing alpha, which is a fair framing: the value here is the process record, not the return.
Where a different tool is the right choice
If your goal is to test whether an LLM can make trading decisions under controlled conditions, the LIBB framework linked from the README is the more appropriate starting point. The author describes it as the general experimental framework built for LLM research, and it is intended for upcoming experiments rather than being tied to this one micro-cap run. The difference in approach is scope: LLM Trading Lab preserves one specific live experiment with its own artifacts and its own rules, while LIBB is designed to be reused across experiments. Choosing between them is a question of whether you want a case study to read or a harness to run.
If your goal is automated execution against a broker, neither repository is the answer as described. There is no broker integration in the layout, and the decision step involves a language model producing text that has to be captured. A conventional backtesting library with historical price data would give you faster iteration and larger samples, at the cost of the forward-only property that gives this experiment its evidential weight.
Maintenance, licensing and what to check before you fork
The repository is not archived and the last push is dated 2026-06-24, so it is active. No releases have been published, which means there is no versioned artifact to pin and no changelog to read. Upgrades arrive as commits to main. Because past artifacts are deliberately left unchanged, a pull can add new experiment folders without altering your existing CSVs, which reduces merge risk but also means the repository will accumulate rather than consolidate. Budget time for reading commit history rather than release notes.
The licence is listed as unknown in the repository metadata and the README does not name one. That is the first thing to resolve. Without an explicit licence, the default position is that no rights are granted, so copying the code into your own project carries risk that a permissive licence would remove. Check for a LICENSE file at the root before you reuse anything, and if none exists, ask the maintainer. This is a factual gap in the repository, not a legal opinion, and it is the kind of gap that should be settled before code moves between projects.
Editorial conclusion
Adopt LLM Trading Lab if you want a documented, forward-only record of an LLM making portfolio decisions and a directory structure to reuse for your own run. Do not adopt it as a production trading system: the README describes a single $100 experiment, no releases are published, and the licence is not stated in the repository metadata, so redistribution terms are unclear. Before building on it, open trading_script.py and the csv_files directory to confirm the accounting logic and the stop-loss enforcement match the feature list, and check the repository for a LICENSE file, because that determines whether you can reuse the code at all.
Frequently asked questions
Does AI trading really work?
That is the question this repository was built to test: a six-month live micro-cap experiment with a real-money portfolio started from $100, using forward-only decisions, full transparency and publicly logged results. The write-up is a 40 page PDF evaluation with benchmark comparisons against the S&P 500 and Russell 2000 plus CAPM, Sharpe, Sortino and drawdown analytics. The project page itself does not summarise what the results were.
Which AI model is best for trading?
The project does not rank models. The experiment ran with ChatGPT as the portfolio decision-maker, and requirements.txt pins both the openai (2.32.0) and anthropic (0.107.1) client libraries alongside the data stack, so switching model is a dependency change rather than a documented comparison.
Can ChatGPT code a trading bot?
The engine in this repository is a Python script: trading_script.py sits under the experiment directory beside a graphing folder containing daily_returns.py and drawdown.py, while requirements.txt and a Makefile sit at the repository root. ChatGPT's role in the experiment is choosing trades under hard constraints with automated stop-loss enforcement. For reusable LLM research tooling the author points to a separate project, the LLM Investor Behavior Benchmark.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/luckyone7777-llm-trading-lab)Star history chart for your README
[](https://hysenlabs.com/projects/luckyone7777-llm-trading-lab)Was this useful?