
u/NextgenAITrading

I deposted $25,000 into Public, connected it via MCP to Claude, and let it trade. I'm up over $3,000
I created the Public Portfolio Challenge, an open challenge where I watch AI agents build algorithmic trading strategies to manage over $25,000.
So far, I'm destroying the market.
The book trades options on high-momentum stocks in my personal watchlist. I trained it using walk forward optimization, and deployed it to Public via OAuth.with my platform.
You can see the exact rules, the trading strategies, and my updates for free. I even have an open-source GitHub repo where you can download skills to follow along in Claude Code or Codex.
Happy to answer any questions below!
I created a free website to browse, download, and copy Warren Buffet stock trades!
If you like digging through Berkshire’s quarterly holdings, I published a free dataset that lets you compare institutional portfolios across years without downloading each SEC filing individually.
It contains 124 million reported institutional holding records going back to 2013, plus filing metadata identifying the manager, reporting period, and filing date. You can use it to follow positions across quarters, compare managers, or investigate when a holding first appeared in their disclosures.
The same download includes 10 million insider transaction records going back to 2006, with purchases, sales, grants, and option exercises identified separately.
The institutional records come from Form 13F filings. They show disclosed holdings at quarter end, so they won’t tell you the exact date or price Berkshire bought a stock, or whether Buffett personally made the decision.
I published the data as Parquet and added a command to download it into SQLite:
npx sec-ownership-disclosures@latest download --sqlite
No API key or SEC credentials required.
Download instructions, example queries, and an explanation of the data
Free dataset of institutional holdings, insider trading, and congressional trades
nexustrade.ioRouter Rumble: an open-source Python demo of gradient descent vs NSGA-II
I built Router Rumble, a small Python experiment that compares gradient descent and NSGA-II by placing a Wi-Fi router in a simulated home.
The GIF replays recorded search states. The objective counts locations where the signal reaches −57 dBm. Gradient descent tests four nearby positions, gets the same count each time, and estimates a zero slope. It stays at 100 covered locations. NSGA-II explores a population of 32 positions and reaches 209 of the 560 sampled locations.
Both methods get 1,200 objective evaluations, including initialization and local probes. Their starts differ: gradient descent starts at one position, while NSGA-II starts with a population spread across the room. This example uses NSGA-II with a single objective.
The repo includes smooth-objective comparisons, results across 20 seeds, and an interactive replay you can scrub through. You can change the walls, signal target, seed, or evaluation budget and rerun the experiment locally:
git clone https://github.com/austin-starks/router-rumble.git
cd router-rumble
uv run run_demo.py
It uses NumPy and pymoo and runs without a GPU or API key.
How to create trading strategies via MCP
Here's a step-by-step guide on how to use Cursor to deploy an autonomous trading strategy.
- Go to alpaca.markets and create a free account
- Add the NexusTrade tool to the MCP config. This link adds it for you. Or you can copy/paste the following { "mcpServers": { "nexustrade": { "url": "https://nexustrade.io/api/mcp" } } }
That's really it. From here, you can type in your strategy like:
>Create me an options trading strategy based on stocks with a 20% CAGR or more that the top politicians hold
I'm collecting feedback so would love to hear what y'all think. If you hit a paywall, use this link to bypass it; I want Reddit users to really stress-test the platform.
How to use Alpaca and Cursor to deploy a fully autonomous no-code options trading bot
Here's a step-by-step guide on how to use Cursor to deploy an autonomous trading strategy.
Go to alpaca.markets and create a free account
Add the NexusTrade tool to the MCP config. This link adds it for you. Or you can copy/paste the following
{ "mcpServers": { "nexustrade": { "url": "https://nexustrade.io/api/mcp" } } }
That's really it. From here, you can type in your strategy like:
>Create me an options trading strategy based on stocks with a 20% CAGR or more that the top politicians hold
I'm collecting feedback so would love to hear what y'all think. If you hit a paywall, use this link to bypass it; I want Reddit users to really stress-test the platform.
[OC] I modeled a $100K copy-bot for each of 75 members of Congress from their public filings. 13 beat SPY, and the average member trailed by 29 points.
Source: House Clerk Financial Disclosure Reports and Senate eFD filings, via the open congressional-stock-trades snapshot (181k trade events, 10.8k filings, 2012 to today).
Tool: Python with matplotlib.
Method: each of the 75 members gets a simulated $100K copy-bot. Top 20 names by disclosed buy size, sized at the midpoint of the reported dollar range, rebalanced as new filings arrive. Entry is the first tradable session after a filing went public (not the trade date). I chose this because if someone wants to act on this, they can only act when the disclosure is published.
Prices are split and dividend adjusted. SPY is bought with the same dollars on the same days, over the same window. The ranking needs min 10 buys and a minimum of 3 years of history. The chart shows the top 10 and bottom 10 by excess over SPY, with all 75 plotted as dots in the middle row.
Note: these are modeled books, not anyone's real portfolio.
Remix it:
- Open dataset (Parquet on Hugging Face): https://huggingface.co/datasets/austin-starks/congressional-stock-trades
- Extraction pipeline repo: https://github.com/austin-starks/congressional-disclosures
- House Clerk disclosures: https://disclosures-clerk.house.gov
- Senate eFD search: https://efdsearch.senate.gov/search/
One command downloads the snapshot and builds a queryable SQLite copy, no keys needed:
npx congressional-disclosures@latest download --sqlite
The copy-bot backtest itself ran on my own engine, but every disclosure input it used sits in that open snapshot, so the strategy side is fully rerunnable.
Fact Check: 0DTE Iron Condor Strategy With Zero Losses (Reposted with self-promotion removed)
Reposting but removing all links and perceived self-promotion to abide by the sub's rules.
TL;DR: A viral TikTok trading setup claimed a near-flawless win rate trading 0DTE SPX Iron Condors in the first hour of the market. I backtested the exact rules to fact-check the claim, showing why "zero losers" is marketing fiction and how the mechanics can actually be tuned for positive expectancy.
The Viral Claim
The setup was popularized by a creator claiming that opening an Iron Condor shortly after the opening bell and taking quick 25% profits resulted in virtually zero losses.
The Strategy Rules (Verbatim)
- Underlying: SPX (tested on SPY scaled 1:10)
- Expiration: 0DTE (same-day expiration)
- Entry Timing: Exactly 9:45 AM ET (15 minutes after open)
- Strike Selection:
- Short Legs: ~0.15 Delta Put & Call (placed just outside the expected daily move)
- Long Wings: Scaled wide (~100 points on SPX, or ~2.5% OTM on SPY) to define risk
- Exit Rules:
- Profit Target: Take profit at 25% of maximum potential credit.
- Time Stop: Hard exit by 10:20 AM ET (close position if 50 minutes after open, regardless of PnL).
What the Fact-Check Found
- The "Zero Loser" Myth (Tail Risk): Like most 0DTE premium-selling strategies, aiming for a fast 25% profit target gives a high win rate during calm morning chop. However, claiming "zero losers" ignores tail risk. On days when the market trends aggressively at open, picking up small 25% gains leaves you vulnerable to massive max-loss blowups that wipe out weeks of profits in minutes.
- The Flaw in the 25% Profit Target: Across dozens of parameter sweeps (testing wing widths, delta distances, entry windows, and hold times), NexusTrade found that the 0.15 delta strike selection was actually optimal. However, taking profit at 25% dramatically skewed risk-reward against the trader.
- The Optimized Variant:
- Increasing the profit target from 25% to 70% proved to be the single biggest improvement across 35 backtests.
- Capturing 70% of the decay gives the trade enough meat to justify the asymmetric tail risk when a side does get breached.
Fact checking that viral 0DTE iron condor with "zero losses" in August
A creator on TikTok went viral recently for claiming he made thirty thousand dollars in August with zero losing days trading 0DTE SPX iron condors.
His stated strategy entered at 9:45 AM, sold 0.15 delta legs, took profit at twenty-five percent, and forced an exit by 10:20 AM.
I codified those exact rules and tested them against minute-level options data to verify the claim.
The run produced sixteen green sessions and four red sessions, and it required eight hundred forty thousand dollars in collateral to generate that thirty thousand dollars in profit.
I posted the exact trading strategy here. If I configured something wrong, please correct me.
How many of you trade same-day condors on SPX, and how do you prevent morning trend days from wiping out your month?
I created a short-form video feed of 100% AI-Generated Content. Would love to get your feedback!
Hi r/heygen!
I'm a software engineer and soloprenuer and I quite literally don't have enough hours in the day to make as much content as I want. I decided to sit down for 1 week and learn everything about HeyGen, video models, voice cloning, and AI content creation.
This is the final result.
A 100% AI-Generated short-form video feed.
I wanted my first experiment to be with finance content to promote my small business. But I can imagine making other types of influencers for my other interests like tech or artificial intelligence.
Already got 20 followers on tiktok in 1 day. That must mean something, right?
What do you guys think? I'd appreciate any and all feedback. If it comes across as AI slop, I would really like to know.
How to Design an Algorithmic Trading System
nexustrade.ioI open-sourced a library to help create, backtest, optimize, and deploy trading strategies
The title says it all.
For context, I built a no-code AI trading platform that allows users to create trading strategies using language models. People are naturally skeptical of LLMs, especially when real money is on the line.
So I thought to introduce some code.
I built a Python and TypeScript SDK that allows you to create, test, and deploy trading strategies. This SDK is fairly unique, as it contains some trading functions that aren't available in everyday trading libraries including:
- Genetic Optimization
- Parameter sweeps and walk forward analysis
- Paper-trading and live-deployment
Even though the SDK is built in Python and TypeScript, the underlying engine is built on Rust. That makes it lightning fast; complex rebalancing strategies across the entire stock universe takes a couple of seconds to execute.
I hope this is helpful! If there's another language you'd like me to support, let me know in the comments!
Introducing NexusTrade: The World's First Agentic Trading Marketplace
You've all seen the grift: someone wraps GPT around the Alpaca API, calls it an "AI quant fund," and charges $99/month for a bot that YOLOs market orders. I've been openly annoyed about this for years, so here's what I built instead.
NexusTrade is an agentic trading platform plus a marketplace. The short version:
- An AI agent (Aurora) that ideates strategies, builds custom indicators from raw sources (SEC filings, congressional disclosures, your own CSVs), authors the rules, backtests across a decade, and runs walk-forward validation on out-of-sample folds
- No LLM in the execution loop. Aurora writes the rules, a deterministic Rust engine executes them. Every condition evaluation is logged, so "why didn't my bot buy on Tuesday" is a click, not a debugging session
- Automated multi-leg options with delta-based strike selection and rolling
- A marketplace where you can sell your strategy as a subscription ($0 to $999.99/month, paid via Stripe Connect). Buyers see returns, drawdown, Sortino, and whether it's real money or paper before paying. Your rules stay hidden until they subscribe
For the devs here: the whole platform is exposed over an API and MCP. 125 tools, OAuth 2.1 with dynamic client registration. You can build, backtest, sweep parameters, deploy, and list a bot entirely from your own scripts or from Claude.
I'm also running a live public portfolio (real money, every fill visible) so nobody has to take my word on anything.
Browsing the marketplace is free, no account needed: nexustrade.io/marketplace. You can also read the full launch article here.
Happy to answer anything about the architecture, the backtest engine, or why I think most "AI trading" products are toys. And yes, roast away, that's what this sub is for.
Standard disclaimer: not financial advice, backtests lie if you let them, trade paper first.