Guest article by Philip van den Berge, Founder & CEO of Intrinsiqq. Originally published on NexusTrade on October 6, 2026.

I put $10,000 of paper money into twenty US stocks selected with Intrinsiqq’s quality score and a price-to-free-cash-flow filter. At the October 6 check, my Intrinsiqq Quality at a Fair Price portfolio was worth $10,364.25, a gain of 3.64%.

I run Intrinsiqq, so the screen uses our own data. NexusTrade runs the paper portfolio, records the orders, and lets anyone inspect or fork the strategy. I created it on September 23, 2026. The first recorded purchases filled on September 24.

View the current Intrinsiqq Quality at a Fair Price paper portfolio. The article’s figures below were captured on October 6, 2026.

The current balance adds the latest position marks to the account’s $147.82 in cash. The daily performance chart below ends at its last saved observation on October 6: $10,339.19, or +3.39%. The holdings and daily chart refresh separately.

A few weeks of paper trading are a start. I want at least three years before judging the screen.

Follow the paper portfolio Inspect the holdings, recorded performance, and plain-language strategy, or fork it into your own account. nexustrade.io

The selection

Buy good businesses at a sensible price

The idea is familiar: find good businesses, then avoid paying too much for them. It suits how I invest.

Robert Novy-Marx found that gross profitability predicted average stock returns about as well as book-to-market, and that adding profitability improved value strategies. Asness, Frazzini and Pedersen later studied quality through profitability, growth and safety. Their strategy of buying quality and shorting lower-quality stocks earned risk-adjusted returns in the US and across 24 countries.

Those studies give me a reason to test the idea. My twenty-stock, long-only basket has its own universe and thresholds, and needs its own record.

Intrinsiqq’s quality score combines eight checks into a number out of 100. Its published method covers price-to-earnings, price-to-free-cash-flow, five-year growth in revenue and free cash flow, share dilution, three-year margin expansion, capital structure, and return on invested capital. The formulas, thresholds and weights are public.

I required a score of at least 80 and a positive price-to-free-cash-flow multiple of 25 or lower. For a business with positive free cash flow, a multiple of 25 corresponds to a 4% free cash flow yield.

I also required US companies filing with the SEC and a market value above $2 billion. Banks, insurers and real estate were excluded.

That last filter changed the list completely. Free cash flow is a poor comparison tool for financial businesses. My first screen was full of insurers ranked on a measure our own methodology does not use to assess them. Reinsurance companies were not what I wanted this screen to hand me.

When I ran the screen on September 16, it returned 104 companies. I took the twenty highest quality scores and gave each the same target weight: 5%. A score of 91 and a score of 88 do not give me enough reason to put three times as much money into one company.

The selected basket contains DECK, EXEL, BKNG, INTU, LULU, TTD, RMD, PCTY, LNTH, MNST, DXCM, AGX, INSW, PRDO, PGNY, ADSK, EXPE, PTC, LOGI and MEDP.

Booking Holdings was one of the clearest examples in my original screen: a quality score of 97, operating margins near 33%, return on capital of 37.6%, and a share count about 23% smaller over the period I examined. Those are the figures from that selection, and the current company scorecard can change with prices and new filings.

Several names had fallen sharply before I selected them, including The Trade Desk, Intuit and Lululemon. Low multiples often appear where investors have soured on a business. A quality screen can keep looking wrong for a long time, and a falling price can reflect a business getting worse.

Read the Intrinsiqq scoring method Check the eight inputs, their weights, and the assumptions behind the score. intrinsiqq.com

Inspect Booking Holdings Compare the example above with the company’s current quality scorecard. intrinsiqq.com

The implementation

Twenty names, with a rule for when to rebalance

The portfolio holds at most twenty positions, with equal target weights and a 5% allocation cap per name at rebalance. Prices can move the weights above or below 5% between rebalances.

It buys when the portfolio holds nothing. After that, it rebalances on a Tuesday in February, May, August or November, once at least 80 days have passed since the last filled buy.

I chose those months to follow the usual US earnings cycle. This version holds the original basket, so the calendar schedules a weight reset; it does not run a fresh quality screen.

The first version tied the initial purchase to those four months too. It would have left the account in cash until November 3 while looking healthy on the dashboard. I caught the problem by reading the rule on the portfolio page. Austin fixed it the next morning.

The recorded first fills are September 24. The current position records show purchase costs of roughly $489 to $494 per stock, with $147.82 left in cash.

The 80-day condition also skips November 2026 after that September purchase. Assuming no further buys, the next scheduled rebalance is Tuesday, February 2, 2027.

The evidence

Why I skipped a backtest

A backtest using today’s quality scores would give an old portfolio information it could not have had at the time.

Companies restate their financial reports. If I score a business for 2019 using figures corrected years later, the screen sees the cleaned-up version of events. The original errors may be exactly what would have fooled an investor in 2019.

There is also survivorship bias. My current company universe leaves out businesses that have disappeared through bankruptcy, acquisition or delisting. Testing an old strategy on that universe skips some of the companies it most needs to prove it would have handled.

Austin pointed out that these are limitations of the data used in this experiment. NexusTrade has filing-dated fundamentals and historical security records that can support a test using information available at the time. The query still has to use the correct filing dates and historical universe. That would be a separate experiment from backtesting my fixed basket with today’s scores.

For this portfolio, I chose a forward record. The creation date, holdings and recorded orders are public on NexusTrade. I can compare future changes against the rules written down at the start.

The test ahead

How I will judge it

My intended benchmark is the S&P 500 Equal Weight Index, because this basket starts with equal weights too. I want a minimum of three years. Two bad quarters would tell me very little.

The shared dashboard’s built-in comparison uses SPY, which tracks the conventional S&P 500. That is a different benchmark from the equal-weight index I plan to use for this experiment.

If the portfolio trails my benchmark over three years, I will need to question what this screen adds over a broad index approach. A short early gain cannot answer that.

The choice I am least sure about is keeping the companies fixed. If a business deteriorates, this rule keeps holding it. Re-running the screen every quarter would follow the scoring method more closely, but it would create a different strategy and require ongoing updates to the holdings.

I chose the fixed basket because it is easier to judge. The next three years will test that choice too.

What I would take from this experiment

Check what a filter does to the universe before trusting its output. Excluding financials rewrote my list. Without that step, I would have published a portfolio of insurers selected with the wrong measure.

Write down the holdings, benchmark, horizon and reasoning before the orders go through. A public record makes later changes easier to see.

When someone presents a screen through a backtest, ask which version of the financial reports it used and whether the universe includes businesses that failed or disappeared. Later restatements and missing failed companies can both make the curve measure hindsight.

Inspect or fork Intrinsiqq Quality at a Fair Price The portfolio page contains the holdings, the strategy, and its recorded paper performance. nexustrade.io

Booking scored 97

On September 16 this screen returned 104 companies. Booking Holdings scored 97, with operating margins near 33% and a return on capital of 37.6%. Pro is the plan that produces that scorecard. The code NEXUSTRADE20 takes 20% off Pro.

Check it out free

About the author

Philip van den Berge is the founder and CEO of Intrinsiqq, a stock analysis platform covering more than 10,000 global companies with quality scores, DCF valuations and ten years of financial history.

Sources

• Robert Novy-Marx, The Other Side of Value: The Gross Profitability Premium, Journal of Financial Economics 108(1), 2013. An author-hosted working paper is also available.
• Clifford Asness, Andrea Frazzini and Lasse Pedersen, Quality Minus Junk, Review of Accounting Studies 24(1), 2019.
• The Intrinsiqq methodology, Philip’s shared paper portfolio, and the S&P 500 Equal Weight Index description support the method and account details.

This article is for information and is not investment advice. The portfolio uses paper money. Paper results differ from real trading, and past performance does not guarantee future results.

Build the strategy this article describes

Create a free account to backtest ideas against market history, inspect the risk, and deploy to paper or live markets when you’re ready.

Create a free NexusTrade account. Free to browse. No credit card required.

Originally published at NexusTrade.

I screened US stocks for quality. Then I put the top 20 on NexusTrade. was originally published in InsiderFinance Wire on Medium, where people are continuing the conversation by highlighting and responding to this story.

I was right from Day 1 about the biggest opportunity in investing.

On September 29, 2026, Robinhood announced Robinhood Agents: research markets, create strategies, and trade through a dedicated account, right inside its app. More than 150,000 customers had already opened accounts through its earlier agentic trading offering. The new embedded Agents and Agent Apps are coming soon to eligible U.S. customers, with manual trade approval on by default.

I was building LLM trading tools in May 2023, more than three years before Robinhood’s announcement. My later o1 trading experiment reached 512K views and 227K reads on Medium.

Now here’s my next prediction: we have about five years of abundant opportunity in agentic trading. As agents become ubiquitous, the advantage will shift to the data they can access.

It started as a chatbot. Now it runs the research.

When I first wrote about AI trading in 2023, the LLM was mostly an interface. Instead of going into the UI and clicking a bunch of buttons, you described your idea. The chatbot configured the trading rules and spit out a backtest.

That was useful. But I still had to come up with the idea, decide what to test, interpret the results, and tell it what to try next.

Today’s workflow is much sharper. With the tools and permissions in place, I can start with a vague idea and have an agent research it, build a strategy, backtest it, optimize it, and deploy it. It can investigate financial questions before it even decides which trading rules to create.

I wrote about that research potential in December 2024, in “This technology will BREAK Wall Street.” I showed o1 answering a financial research question, using the answer to develop a trading idea, and turning that idea into a strategy. In April 2025, I tested GPT-4.1 on financial-data queries and argued that asking questions in plain English would change how people worked with data.

Today, the agent can come up with the next question and carry the research forward itself.

Robinhood is playing catch-up

Robinhood’s agents can retrieve financial statements, news, SEC filings, and technical indicators; screen stocks; read real-time quotes; and place stock, options, and crypto orders.

The gap is the research loop I’ve been building: create a strategy with deterministic rules, run those rules through historical markets, optimize them, then execute the same rules on live market data and track what happens.

Robinhood’s published native toolset doesn’t include a strategy backtesting or optimization engine. Its order-preview tools simulate an individual order. They don’t test years of a strategy’s behavior.

What Robinhood’s agents can do today. Read the company’s native tool list, including market data, screening, order previews, and execution.

In NexusTrade, the agent develops the strategy and the trading engine executes its rules. I can inspect exactly what makes it buy or sell, compare its backtest with a benchmark, and follow its performance after deployment.

I expect Robinhood to catch up. A company of that size isn’t going to leave such an important part of financial research to smaller builders forever.

But by the time it does, the easiest opportunities may already be crowded.

We’re in a golden age of agentic trading

Back then, it took me years of experimenting to find even a cherry-picked backtest that beat the S&P 500 across two or three different market regimes.

I’d sit there for hours driving the conversation, trying different parameters, and doing the research myself. I basically became a mini-quant because I wanted to show my audience what the platform could do and prove that it could work.

For me, that process now starts with a single prompt.

Give your coding agent a trading research question. Connect Claude Code or Codex to NexusTrade and use its research, strategy, and backtesting tools.

I’ve used Claude Fable 5 through Claude Code to create options-strategy candidates, run backtests, compare optimization approaches, and prepare deployment records.

Read the public Fable campaign log. Follow the research, historical tests, rejected candidates, and deployment decisions in the open-source runbook.

Years of doing this by hand taught me what the agent needed to know: which questions to ask, how to turn an idea into rules, what to compare, and when to go back and try something else. I’ve distilled that into Aurora, NexusTrade’s autonomous research agent.

You give her a question. She researches it, creates strategies, tests them, and works through the results. She can deploy trading bots when you authorize it. You can watch her work in real time, open the tool results, inspect the rules, and follow the bots after deployment. Here’s how Aurora works.

I’ve used this workflow to build algorithmic strategies running across two real-money public portfolio challenges. The accounts total $41,980.42 as of October 9, 2026.

The original challenge started with $25,000. I’ve used it to take AI-generated strategies from research into live trading, including the options work documented in the Fable campaign. Its account value is $28,158.98.

The Semis + Biotech challenge started with $13,500. Grok Bot supplied the stock ideas, and I used Codex to develop the executable options rules around them. Its account value is $13,821.44.

Those account values include cash and marked positions. You can open both public portfolios and follow their trades.

I have a high risk tolerance, access to the latest coding agents, and years of infrastructure for them to work with. For me, the cost and effort of trying an idea have fallen dramatically. I spend more time deciding what deserves testing while the agent does the work.

That’s why I think we’re in a golden age of agentic trading. Alpha is still bountiful, and I predict this window will last roughly another five years.

There are ideas people never tested because collecting the data, writing the software, and maintaining the system took too much work. Agents have made that backlog much easier to explore.

By around 2031, I expect these workflows to be commonplace. Brokerages will catch up. People will copy what works. Having an agent build and monitor a strategy could feel as ordinary as setting a price alert.

The opportunity is to use that capability before everybody else does, and build for what happens afterward.

The strategies that work now won’t stay special

In September 2026, I published an analysis of 222,010 backtests. That research gives me a better starting point for deciding which ideas to test. Agents can use those findings to build and compare strategies much faster than I could by hand.

But other people’s agents can investigate the same ideas using the same market data. I expect the advantage to shrink as more of them discover and trade the same opportunities.

Here’s an actual example. In February, I asked Aurora: “Create the best momentum-based strategy for fundamentally strong stocks.” After testing competing ideas, I published three of the resulting strategies.

That strategy became The “All-Weather” Winner. It selects 15 S&P 500 stocks with strong quality ratings and the highest 30-day momentum, then rebalances monthly.

Open the All-Weather Winner’s public paper portfolio. Follow the strategy’s forward paper performance after the February historical test.

Those inputs are public fundamentals and price history. Another agent can test the same idea. Once millions of agents are doing that, I expect the trades to get crowded.

Published strategies have already shown this kind of decay. McLean and Pontiff studied 97 stock-return predictors and estimated a 32% reduction in predictor-portfolio returns attributable to trading informed by their publication. Read the Journal of Finance study.

I expect agents to speed that process up. By 2031, I think many obvious fundamental and technical strategies that show an edge today will be noise. Earnings and cash flow will still matter to companies. Making money after costs from familiar rules around that public information will get much harder.

While Robinhood plays catch up getting their agents to execute backtests, the next revolution in finance is alternative data.

The next edge is the data

Once everybody can ask an agent to build, backtest, and deploy a strategy, the competition moves to what those agents know. If they’re all working from the same prices, earnings reports, and indicators, I expect them to keep discovering the same trades.

The advantage shifts to information other people’s agents don’t have, or haven’t thought to use. That could be satellite observations, weather, specialized industry records, or your own dataset that reveals customer demand before an earnings report. Even connecting public datasets in a way nobody else is testing could reveal an opportunity.

I also expect that competition for information to take uglier forms. Some participants will seek insider information. Others will try to manufacture the data that trading agents consume.

Imagine 100,000 AI agents on Reddit gradually manufacturing a narrative about a stock. Other trading agents gather those posts as social-media data, interpret the narrative as genuine investor sentiment, and trade on it. The operators have created the signal themselves, then used other agents’ reactions to it. That’s the market manipulation I expect to see more of as agents compete for an information advantage.

My bet is on collecting overlooked data and turning it into indicators agents can actually test.

I’m putting that data to work

I’ve been building custom indicators into NexusTrade so people can use their own datasets in a strategy.

You bring the data, turn it into a numeric indicator, and combine it with trading conditions. An agent can help find or transform the source, and you can test the resulting rules alongside price, fundamentals, and other inputs. Here’s how the custom-data workflow works.

I’ve also published historical datasets for three kinds of disclosures:

1. Congressional trades: House and Senate trading disclosures going back to 2012. Download the congressional dataset.
2. Corporate insider trades: SEC Form 4 disclosures from executives, directors, and other reporting insiders, going back to 2006.
3. Institutional holdings: SEC Form 13F disclosures going back to 2013. Download the insider and institutional datasets.

The dates matter. Someone can make a trade before you learn about it. A quarterly holdings report tells you about a past position. Your backtest has to use the information you could actually have known on that day.

My next big bet takes this further: a custom-built trading model on custom-built data.

Through NexusTrade, I’ve spent years collecting trading strategies and their backtest results. The corpus behind my September research contains 222,010 backtests. That research history is itself an alternative dataset.

Price history tells a model what the market did. My backtesting data records which strategies were tested against that market and how they performed: the rules, the parameters, and the variations people tried.

I intend to train my own large language model on the data I’ve collected building NexusTrade. It will learn from agent conversations, my backtesting data corpus, and, of course, reinforcement learning.

I want it to learn which research decisions led to useful strategies, which experiments failed, and what to test next. The goal is a trading agent trained on years of actual strategy-development work, with a research process that keeps learning from its next experiment.

That’s the alternative-data approach I’m pursuing. Other agents can download the same stock prices. They won’t have the years of conversations and experiments I’ve collected while building NexusTrade.

Try NexusTrade

Give Aurora a trading idea, have her build and backtest it, and try it in a paper portfolio. If you prefer working through Claude Code or Codex, connect your coding agent to NexusTrade.

For October, your first three calendar months are free with weekly or monthly billing. Annual plans are 25% off the first year. After the offer, your plan renews at its regular price unless you cancel. Claim it by October 31 at 11:59 p.m. Central.

Build your first strategy with Aurora

Start with a trading idea, compare its backtest with a benchmark, and try it in a paper portfolio. The October offer includes three free calendar months on weekly or monthly plans, or 25% off the first annual year.

Claim the October offer

Originally published on NexusTrade.

I saw agentic trading coming in 2023. Here’s what I’m predicting next. was originally published in DataDrivenInvestor on Medium, where people are continuing the conversation by highlighting and responding to this story.

Capitol Trades, Quiver Quantitative, Unusual Whales, and NexusTrade all let you look up Nancy Pelosi’s publicly reported stock and option trades. But which one is the best?

It depends on what you do after the lookup. If you just want to see what Pelosi bought, Capitol Trades is free and good enough. Quiver is the best paid political-data dashboard. Unusual Whales fits best if you already live in options flow.

NexusTrade fits best if you want to turn her filings into a portfolio you can backtest, or an agent that watches them for you. If you only want the raw records, the free open dataset is enough. I built NexusTrade and I maintain that open dataset, so keep that in mind when you read my verdicts on both.

Start with Pelosi’s latest filing

Pelosi’s most recent House filing was submitted on August 21, 2026 and became public the next day. It reports seven purchases made by her spouse in July: two Bloom Energy stock purchases, two Bloom Energy call purchases, one Intel stock purchase, one Intel call purchase, and one private investment.

You can read Pelosi’s original House filing yourself. Its seven disclosed ranges add up to $4.25 million at their lower bounds and $14.5 million at their upper bounds.

Query the filing yourself

Every row in that filing is in a free, open dataset of House and Senate disclosures. One command downloads it and builds a local SQLite database.

$ npx congressional-disclosures@latest download - sqlite
✓ 45 Parquet files · 8.88 MB
✓ congressional-disclosures.sqlite · 230 MB
✓ checksums and row counts verified

Here’s the SQL that finds Pelosi in that database, and all seven rows it returns.

Show the SQL query

sqlite3 -header -column \
congressional-stock-trades/congressional-disclosures.sqlite \
" WITH target_member AS ( SELECT member_id, display_name 
FROM political_filings WHERE member_id IS NOT NULL AND 
lower(COALESCE(display_name, '')) LIKE '%nancy%' AND 
lower(COALESCE(display_name, '')) LIKE '%pelosi%' 
GROUP BY member_id, display_name LIMIT 1 ),
latest_filing AS ( SELECT f.doc_id FROM political_filings f 
JOIN target_member m ON f.member_id = m.member_id 
ORDER BY f.filing_date DESC, f.available_at DESC LIMIT 1 ) 
SELECT substr(first_available_at, 1, 10) AS public_date,
transaction_date, COALESCE(ticker, '(none)') AS ticker, asset_type_code, 
action, printf('$%,d to $%,d', amount_low, amount_high) AS disclosed_range 
FROM political_trade_events e 
JOIN target_member m ON e.member_id = m.member_id 
JOIN latest_filing f ON e.source_doc_id = f.doc_id WHERE e.superseded_at IS NULL 
ORDER BY source_row_index ASC;"

The query answers one question at a time, and every new question means writing more SQL. NexusTrade has a dedicated congressional-disclosures workspace for browsing the same records. The difference is what you can do after the lookup: rank politicians, generate several portfolio rules, backtest them, and keep the version you like best.

What each option costs

Quiver’s free visitor tier includes live congressional-trading data. Its Premium plan adds politician portfolios, a leaderboard, alerts, a Congress backtester, and exportable samples. The API is a separate subscription.

Unusual Whales includes politician information in its $50 Retail Basic plan alongside real-time options flow, dark-pool data, screeners, and alerts. Its developer API starts much higher because congressional records are bundled with the larger market-data product.

NexusTrade’s free plan includes Aurora, the same AI research assistant paid users get. Its research runs on tokens. A free account starts with a balance that grows as you finish onboarding and earn in-app rewards.

For this article, one prompt pulled Pelosi’s latest disclosed trades, built four $100,000 portfolios, and backtested all four. The full run is linked below. Paid plans add recurring research capacity, broader market data, deeper validation and optimization, larger portfolio limits, and more automation.

Prices change often, so check the current Quiver website plans, Quiver API plans, Unusual Whales plans, and NexusTrade pricing before buying.

What each option gives you

Capitol Trades

Capitol Trades is the free answer to “what did Pelosi buy?” It is run by 2iQ Research, an insider-transaction data company, and anyone can use it. The trade feed filters by chamber, party, committee, and state.

Pelosi’s page shows her trade count, filings, volume, and issuers. Below that are an S&P 500 chart with her trade volume underneath, her most-traded stocks and sectors, and a “filed after” column showing how many days each trade took to become public. That last column matters if you copy these trades, because the gap between a trade and its disclosure is a delay no follower can avoid.

Check the dates before you rely on them. When I opened Pelosi’s page on September 23, every trade date showed one day earlier than her official filing. The filing lists the Bloom Energy purchases on July 24 and July 28 and the REOF XXV investment on July 27. Capitol Trades showed July 23, July 27, and July 26.

A one-day shift makes little difference when you’re reading the news. It does change anything measured from the trade date, like the “filed after” gap on every row or any study of how a stock moved after the trade. A backtest that enters when the filing became public is unaffected. I saw the mismatch on the page itself and didn’t test whether Capitol Trades’ underlying data has it too.

Capitol Trades is built for looking things up. It doesn’t advertise alerts, an API, a backtester, or portfolio tools.

capitoltrades.com · Politicians · Nancy Pelosi

Quiver Quantitative

Quiver has a focused Congress Trading dashboard, politician profiles, portfolio estimates, and a catalog of prebuilt strategies. Its Congress backtester is useful for guided political-trading analysis, and select Quiver strategies can be copytraded through Quantbase. Quiver is the cheaper paid option if its prebuilt political strategies and tools already cover what you need.

Unusual Whales

Unusual Whales tracks congressional disclosures, trade timing, sector preferences, and estimated performance. Its main product is broader: options flow, dark pools, volatility, market-maker positioning, alerts, and screeners surround the political data. That bundle is useful to an active options trader, but it is expensive if congressional records are the only thing you need.

NexusTrade

NexusTrade starts with a dedicated congressional-disclosures workspace. It puts House and Senate activity in one searchable feed. You can filter by politician, ticker, instrument, action, and date, sort by when a disclosure became public, and follow each row to its official filing.

Pelosi’s profile page leads with a public bot that trades her disclosures. It is a simulated $100,000 backtest from September 2021 that buys on the day each filing became public, charted against the S&P 500 over the same days. On September 24 the bot was up 103.8%, against 84.0% for SPY, with a worst drop of 46.2%. From there you can copy the bot, make your own version of its rules, or ask Aurora about her trades.

That’s the difference from a conventional tracker. You can define the return methodology and ask questions that NexusTrade answers with SQL over the full disclosure database. You can combine political activity with quality or momentum filters, backtest the rules, optimize them, run later out-of-sample tests, and deploy the portfolio you pick.

Alerts in NexusTrade come from scheduled agents. A scheduled agent runs Aurora daily, weekly, or whenever a condition you set becomes true, such as Pelosi disclosing a new purchase of a stock you name. Each run can research the news and act on the portfolio it’s attached to, then emails you what it found. You can reply to that email to keep the conversation going. None of this replaces Unusual Whales’ options-flow workstation or Quiver’s leaderboards.

Open-source data

The official filings and the SQLite download from the top of this article make up the open-source route. It gives you the records and the machinery. It doesn’t give you every chart, alert, or market-data feed that Quiver or Unusual Whales sell, and the maintenance becomes yours.

If you rely on the hosted dataset, watch snapshot.json and confirm the source check is still fresh. If you fork the pipeline, you own scheduling, credentials, provider costs, schema changes, failed filings, and the work of keeping the database current. That path needs technical experience.

A tracker is downstream of the filings

The data underneath the tracker

Congressional trades begin as records published by the Office of the Clerk of the U.S. House of Representatives and the U.S. Senate Electronic Financial Disclosure system. Those reports contain filing dates, transaction dates, dollar ranges, owners, asset descriptions, and sometimes enough option detail to identify a strike or expiration. Turning them into a clean table requires PDF handling, OCR, normalization, ticker resolution, amendment tracking, and visible failure reporting.

The download numbers above come from one snapshot of the dataset. Current row counts, file hashes, audit status, and freshness timestamps remain queryable in snapshot.json.

The most important research field is availableAt. A transaction may have happened weeks before it became public. A backtest that enters on the transaction date is answering a hindsight question. A reproducible tracker should preserve both dates and state which one drives its results.

Options need the same care, because Pelosi’s disclosures can identify call purchases, exercises, strikes, expirations, and disclosed value ranges. A system that collapses every option record into an ordinary stock purchase throws away information that materially changes portfolio construction.

I asked NexusTrade to build four Pelosi portfolios

I gave NexusTrade one instruction:

“Using only Nancy Pelosi’s publicly disclosed trades as they became public, show her recent trades, then create four $100,000 portfolio variants: direct copy, disclosure-magnitude weighted, quality-filtered, and quality plus momentum; backtest each from 2024 through the latest available date.”

The direct-copy portfolio equally weights stocks with a Pelosi purchase disclosed in the previous 90 days. The magnitude-weighted version sizes by the upper end of each reported value range. Both wait until the filing is public.

The engine checks each rule at the day’s open and close and fills orders at the price printed at that check, so a disclosure can only affect a trade at the first check after it became public. Because the filing reports only a range, sizing by its upper bound is an assumption, and I didn’t repeat the test with lower-bound or midpoint sizing.

Direct copy and quality filtered share the same 34.39% worst drop because they held exactly the same stocks from their January 23, 2025 peak through their April 4, 2025 low, the stretch where both fell furthest.

These were concentrated portfolios: each held only 8 to 11 stocks, the five largest names received 71% to 87% of the money allocated, and Nvidia alone received 18% to 24%. That matters in a 2024 to 2026 window dominated by a small group of large technology stocks. The results show what these four rules did in this period, and they cannot tell you whether the same return will repeat.

What the backtests assume:

• Trading costs. Every stock trade pays 0.1% of its value, which stands in for the spread and slippage on a commission-free broker. There is no separate slippage model for stocks.
• Disclosure timing. A filing becomes usable at 11:59:59 PM New York time on the date the House Clerk or the Senate recorded it, in every year of the data. The engine can act on it at the next open or close.
• Fundamentals. Profit and free cash flow become usable when the SEC accepted the filing that reported them, never at the end of the fiscal quarter they describe.
• Dividends. Every portfolio collects dividends. The Pelosi portfolios hold them as cash until the next rebalance, while the SPY baseline reinvests them immediately, which slightly favors SPY.
• Options. An option disclosure counts as a signal for the underlying stock. The contracts themselves are not reconstructed or priced.

This test stopped at backtesting. Optimization, out-of-sample testing, and deployment happen in the same workspace, and I left them out to keep the four results directly comparable.

Run this Pelosi prompt yourself

The button opens Aurora with the exact prompt above already typed, and nothing runs until you press Send. You can change the dates or swap in another member of Congress first.

Open the prompt in Aurora

Pick for the job

Which one should you use

• Choose Capitol Trades when you just want to look up what Pelosi or any other member disclosed, for free, and you can check dates against the filing yourself.
• Choose Quiver for a focused political dashboard, alerts, leaderboards, and guided Congress research at the lowest paid entry price here.
• Choose Unusual Whales when political disclosures need to sit beside options flow, dark pools, volatility, custom alerts, and mobile notifications.
• Choose NexusTrade when the job starts with a custom question and continues through portfolio generation, backtesting, optimization, deployment, and custom alerts from scheduled agents.
• Choose the open dataset when you want the records, SQLite, exports, and complete control, and you are prepared to build and maintain the surrounding product yourself.

There is no universal winner. Capitol Trades is the best free lookup, Quiver is the most focused paid political-data product, Unusual Whales has the strongest surrounding options context, NexusTrade carries a custom idea furthest without leaving the product, and the open route gives up convenience in exchange for control.

Start with the data, or start with the portfolio

Download the audited House and Senate records for your own stack, or use the same records inside NexusTrade.

Explore in NexusTrade
Download the data

austin-starks/congressional-stock-trades · Datasets at Hugging Face

Originally published at https://nexustrade.io.

Nancy Pelosi Stock Trades: Capitol Trades vs Quiver vs Unusual Whales vs NexusTrade was originally published in CodeX on Medium, where people are continuing the conversation by highlighting and responding to this story.

A simulated insider strategy turning $100,000 into $781,454 is hard to scroll past. That’s the result on Nuvectis’s company profile, and below I’ll show you the curve, the rules, and the filings behind it.

I made the underlying insider disclosures and institutional holdings available as free downloads so you can investigate these ideas yourself. One command turns the published files into a local SQLite database.

Download the complete dataset

Run this command to download the full published history of both insider disclosures and institutional holdings, including their filing tables, into one SQLite database:

npx sec-ownership-disclosures@latest download --sqlite

The database is saved at ./sec-ownership-data/sec-ownership.db. You need Node.js 22.5 or newer. The download requires no API key or SEC credentials.

If you prefer Parquet files for notebooks or a data warehouse, use:

npx sec-ownership-disclosures@latest download

Both commands fetch all published years and all four tables. The October 3, 2026 snapshot totals 2.68 GB of compressed Parquet files across 70 files. Institutional holdings account for 2.42 GB of that download. The SQLite command retains those files and creates an additional database, so its total disk usage will be larger than 2.68 GB.

austin-starks/sec-ownership-disclosures · Datasets at Hugging Face

You can use the rows yourself, or open NexusTrade to search the disclosures and compare strategies built from them. You can also combine disclosure signals with technical indicators, company fundamentals, and economic conditions in a custom strategy.

Research insider activity without writing SQL

Start with the insider research page. The Companies view combines each company’s officers and directors into one strategy. Switch to People to follow a reporting owner across the companies where they file. You can search by company or ticker, then narrow the people view by reporting owner and role.

Those views answer different questions. A company’s strategy asks what happened when its officers and directors reported acquisitions in that company. A person’s strategy follows that owner across their reporting history. The company model excludes 10% holders, which keeps a fund’s ownership activity from becoming an officer-and-director signal.

Open a profile to see the strategy rules, performance curve, comparison with SPY, and maximum drawdown. The filing section separates the transaction date from the public date and lets you inspect the evidence behind a signal.

Nuvectis’s company profile, captured October 3, 2026, shows the simulated return and the loss experienced along the way. Click the screenshot to inspect the strategy.

A 681.5% gain is an extraordinary result. The Nuvectis follower strategy turned $100,000 into $781,454 over roughly five years, while the same starting investment in SPY grew to about $188,100. That’s almost eight times the starting capital and more than four times SPY’s ending value. This is the simulated result shown on October 3, 2026, with fees included.

That is the kind of result that makes these disclosures worth investigating. You can open the strategy, inspect its rules, and test your own variation. Its 71.2% maximum drawdown also tells you how rough the ride was: the remarkable ending value came with a severe loss along the way.

The insider model treats public purchases and issuer awards as separate acquisition signals. An award is compensation, so it is kept distinct from a purchase; a purchase-only strategy like the Aurora example below excludes awards. The follower rules can select shares or modeled yearly at-the-money options, held for a 45-day window. A public sale blocks the corresponding stock, call, or put position. Those options are modeled substitutions, rather than a reconstruction of the insider’s actual account.

You can also switch the leaderboard to strategies that trailed SPY. That gives you a way to examine where the same rules failed, rather than choosing only the most impressive historical winner.

Insider Trading Strategies & Free SEC Dataset | NexusTrade

Inspect institutional holdings and test a follower strategy

The institutional research page ranks modeled strategies built from managers’ public 13F disclosures. Search a manager by name or CIK, open its profile, and inspect the disclosed positions alongside the strategy result. The leaderboard also lets you examine strategies that trailed SPY.

A manager profile shows the reporting period and the date the filing became public. Its holdings table includes issuer names, security identifiers, reported values, and share amounts, with a link to the official SEC filing.

BML Capital Management’s profile keeps the reporting period and public filing date above the disclosed positions. Click the screenshot to open the holdings and official source.

NexusTrade follows each quarterly book after publication and models disclosed stock positions with shares. Disclosed calls and puts become modeled yearly at-the-money options because a 13F does not provide the original strike or expiration. The reported underlying value determines their relative budgets; it does not tell you the option premium the manager paid.

The profile’s curve, SPY comparison, and risk statistics describe that follower simulation, with fees. They do not establish the manager’s actual fund performance. This matters especially when a leaderboard result looks extraordinary: inspect the holdings and model assumptions before deciding the approach belongs in your own portfolio.

Institutional Holdings & Free 13F Dataset | NexusTrade

Build a custom strategy with technical, fundamental, economic, and alternative data

NexusTrade lets you describe investing rules in plain English and use Aurora to turn them into a strategy you can backtest. Insider disclosures and institutional holdings add another set of inputs to the technical, fundamental, and economic data already available in the platform.

Each type of data can answer a different question:

• Technical indicators: You can use moving averages or RSI to define price trends, entry conditions, and exits.
• Company fundamentals: You can filter companies by valuation or revenue growth before deciding what to buy.
• Economic indicators: You can make a rule depend on conditions such as the unemployment rate or Treasury yields.
• Insider and institutional disclosures: You can use reported insider purchases, the number of distinct buyers, institutional holder counts, or changes in disclosed holdings as signals.

For example, insider purchases might identify a company worth investigating. A fundamental filter can narrow that list to companies meeting your valuation criteria. A moving average can control when you enter, and an economic condition can determine when the strategy is allowed to hold risk.

Here is a concrete research request you can give Aurora:

Build a stock strategy that requires at least two distinct officers or directors to report purchases in the past 90 days, a positive trailing P/E below 25, and a price above its 200-day moving average. Allow new entries only when the unemployment rate is below 5%. Hold at most 10 stocks with equal weights. Backtest it against SPY and show maximum drawdown.

AI Stock Trading Agent

The request opens in Aurora ready for you to review and send.

This request combines all four data types in one strategy. Its 90-day purchase window starts when the filings become public. Aurora can build and backtest those specific rules so you can inspect the result.

Fundamental and economic indicators require a paid subscription. The public dataset download is free.

You can take the same approach with institutions. Ask Aurora to start with disclosed institutional ownership, add your valuation and trend rules, and test the resulting portfolio. An increase between 13F snapshots tells you how reported holdings changed; it does not reveal the dates of trades between reports.

On the research pages, Build a strategy opens Aurora with the relevant disclosure context. Open a company or manager profile first if you want the request to start with that specific source. For a narrower variation, ask:

A useful first pass is to inspect a profile’s worst drawdown, read its rules, and follow the source filing. Then build or fork the version you want to test. Compare the changed strategy with both the original and SPY before deciding to run it.

What is included in the free download

• insider_transactions: A reported derivative or non-derivative transaction leg. The documented backfill covers 2006 Q1 through 2026 Q2.
• insider_filings: A filing and reporting-owner combination. The documented backfill covers 2006 Q1 through 2026 Q2.
• institutional_holdings: A reported 13F information-table holding leg. The documented backfill begins in 2013 Q2.
• institutional_filings: A 13F submission, including its reporting-period and amendment metadata. The documented backfill begins in 2013 Q2.

These coverage descriptions come from the project documentation checked October 3, 2026. Consult the public snapshot receipt for the files currently available.

Separate insider purchases from compensation

Insider disclosures include purchases, sales, grants, option exercises, and other changes in ownership. A research question about purchases needs to distinguish those activities.

The SEC defines transaction code P as an open-market or private purchase. Filtering for that code is a useful first step, but the code alone does not establish that a purchase occurred on an exchange or explain the insider's motivation.

If you have the SQLite command-line tool installed, open the insider database with sqlite3 ./sec-ownership-data/sec-ownership.db. Paste this query to count disclosed purchase legs by resolved ticker within the downloaded table:

SELECT resolvedTicker, COUNT(*) AS reported_purchase_legs 
FROM insider_transactions 
WHERE transactionCode = 'P' 
AND availableAt >= '2024-01-01' 
AND availableAt < '2025-01-01' 
AND resolvedTicker IS NOT NULL 
GROUP BY resolvedTicker 
ORDER BY reported_purchase_legs DESC, resolvedTicker
LIMIT 10;

The result counts rows. Amendments, multiple reporting owners, and multiple transaction legs require additional handling before interpreting those counts as unique economic purchases. The result also says nothing about subsequent investment returns.

Read the SEC’s guide to Forms 3, 4, and 5 for the reporting framework and transaction-code definitions.

Understand what institutional holdings reveal

13F disclosures let you inspect the reportable securities a manager held at a reporting date. Comparing successive reports can reveal changes in disclosed positions.

Those reports do not reveal every trade between quarters. A manager could buy and sell a position between reporting dates without that round trip appearing in either snapshot. Short positions are excluded, and the filing covers securities subject to the 13F reporting framework.

The same database includes institutional holdings. This query shows the latest holding rows available before January 1, 2025:

SELECT accession, availableAt, issuerName, cusip, sharesAmount 
FROM institutional_holdings 
WHERE availableAt < '2025-01-01' 
ORDER BY availableAt DESC, accession, cusip LIMIT 10;

The full download also includes institutional_filings for manager names and reporting periods. Join the holdings and filing tables on accession.

Read the SEC’s Form 13F FAQ for the reporting scope, deadlines, and treatment of short positions.

Research starts when the filing becomes available

A transaction date tells you when an insider acted. A reporting period tells you when a manager held a position. Neither establishes when you could have learned about it.

Each dataset row includes an availableAt timestamp. For the quarterly SEC datasets, the package assigns availability to the end of the filing date in America/New_York. That gives daily research a conservative filing-day convention; it does not provide an exact intraday publication timestamp.

Suppose a manager reports December holdings in February. A strategy using that filing can react after the disclosure becomes available in February. Giving the strategy those holdings in December would introduce future information into the test.

Availability filtering is one part of a credible backtest. You also need to handle amendments, historical security identifiers, price coverage, and execution timing. Keep unresolved symbols visible rather than silently substituting a current ticker.

Verify the download or rebuild from the SEC

The downloader verifies each file against the SHA-256 checksum recorded in snapshot.json. Files already present with the expected digest are reused.

Inspect the public snapshot receipt before describing a download as current or complete.

The open-source package also provides a separate path for downloading official SEC archives, parsing them, and auditing the result. Its audit re-parses archived source files and checks relationships and row identities. Researchers can inspect and extend that process themselves.

GitHub - austin-starks/sec-ownership-disclosures: Build a point-in-time SEC ownership lake from EDGAR - Form 3/4/5 insider filings and 13F institutional holdings - or download the published dataset as Parquet or SQLite.

Use the rows for your own research

The download gives you a starting point for questions about reported insider purchases and institutional ownership. You can query the rows locally, inspect disclosure timing, and join the records to your own market data.

Open the insider workspace or institutional workspace to inspect the evidence and test your own strategy. The free dataset remains available for research in your own tools.

Insider Trading Strategies & Free SEC Dataset | NexusTrade

Originally published at https://nexustrade.io.

Be the Signal on DataDrivenInvestor — Movement for the One-Person Era

https://datadriveninvestor.com/write-for-ddi

Visit us at https://DataDrivenInvestor.com

Join our Writer-Entrepreneur-Investor Ecosystem Here:

https://datadriveninvestor.com/apply

Free Historical Insider Trading and Institutional Holdings Data was originally published in DataDrivenInvestor on Medium, where people are continuing the conversation by highlighting and responding to this story.

austin-starks/congressional-stock-trades · Datasets at Hugging Face

Download the dataset

Nancy Pelosi’s trades are public. Every other member of Congress files disclosures too. The hard part is turning more than a decade of House and Senate filings into data you can actually search. This free download puts 183,675 reported transactions from 10,809 official filings in one place, covering 2012 through today.

# Download, verify, and build SQLite
npx congressional-disclosures@latest download --sqlite

When it finishes, you have a local SQLite database with the full House and Senate history, ready to open and query. Run the command again later to pull in any updates.

You do not need Docker, Python, DuckDB, an API key, OCR credentials, or a model provider. SQLite is the easiest starting point. If you already use notebooks, dataframes, or a warehouse, omit --sqlite to download the Parquet files instead.

npx congressional-disclosures@latest status \ 
--db ./congressional-stock-trades/congressional-disclosures.sqlite

What is included

Use political_trade_events for most analysis. Congressional records can repeat the same transaction in later reports or amendments. The event table consolidates repeated reports and preserves each amendment as a version, so a count does not silently turn one trade into two.

Each row retains the chamber, filer, owner, action, transaction date, public-availability time, asset description, instrument type, ticker resolution, disclosed lower and upper amount bounds, source document, official sourceUrl, and amendment lineage.

Check freshness automatically

The dataset publishes a snapshot.json file alongside the Parquet data. It records current row counts, audit results, latest timestamps, manifest identities, object ETags, file sizes, and SHA-256 checksums.

The disclosure refresh targets a 20-hour interval, or roughly daily. After the internal lake publishes and passes its integrity audit, the public mirror updates the snapshot and any changed yearly shards. A failed downstream upload leaves the previous verified snapshot intact and retries on the next pass.

# Shell · query the live receipt

curl -fsSL \ 
https://huggingface.co/datasets/austin-starks/congressional-stock-trades/raw/main/snapshot.json \ 
| jq '{checked: .lastSourceCheckAt, freshness: .freshness, totals: .totals, audit: .audit.passed}'

As of this draft, the latest public-availability timestamp is 2026-09-18T03:59:59.999Z. The lake was most recently processed at 2026-09-20T01:42:40.295Z, and the public source check completed at 2026-09-20T17:04:01.191Z.

The figures in this article are timestamped so the prose remains auditable. Query the public JSON for the current values. It updates automatically after each successful disclosure refresh and verified dataset publication.

Query it locally

Hugging Face can load the reconciled event table directly:

from datasets import load_dataset

events = load_dataset(
    "austin-starks/congressional-stock-trades",
    "political_trade_events",
    split="train",
)

pelosi = events.filter(
    lambda row: row["filerLast"].lower() == "pelosi"
)

The npm package has two paths. Use download --sqlite when you want the ready-made audited snapshot as a local database without API keys or extraction infrastructure. Use sync when you want to build and maintain SQLite from the official filings yourself:

npx congressional-disclosures@latest download --sqlite 
npx congressional-disclosures@latest doctor 
npx congressional-disclosures@latest sync \ 
--db ./congress.db \ 
--since 2024 \ 
--accept-senate-terms 
npx congressional-disclosures@latest audit --db ./congress.db

The first command creates ./congressional-stock-trades/congressional-disclosures.sqlite. This query finds the five tickers that appear most often in Pelosi's currently active disclosed events:

# SQLite · top disclosed tickers 
SELECT ticker, COUNT(*) AS disclosed_events FROM political_trade_events 
WHERE lower(filer_last) = 'pelosi' 
AND superseded_at IS NULL 
AND ticker IS NOT NULL 
GROUP BY ticker 
ORDER BY disclosed_events DESC, ticker LIMIT 5;

These counts describe disclosure events in the current snapshot. They are not share counts, dollar totals, or investment returns.

The package’s model and OCR providers can cost money when you build from the source filings. Downloading the already-published Hugging Face dataset is free.

NexusTrade uses the same data as a research and portfolio system

The download is for people who want the rows. The NexusTrade congressional-disclosures workspace uses the same audited political lake to browse House and Senate activity, open the official filings, research politicians, generate portfolio variants, backtest the rules, optimize them, and deploy the version you choose.

That means you can move from “which politicians were consistently strong?” to several Pelosi-inspired portfolios without writing the ingestion, market-price joins, or portfolio engine yourself.

The free dataset stays free.

NexusTrade is the layer for turning it into repeatable research and a portfolio you can test.

Inspect the machinery

Rebuild it from official sources

The public congressional-disclosures repository owns House and Senate discovery, document downloads, PDF decryption, scan detection, OCR, independent extraction reads, disagreement reconciliation, ticker resolution, amendments, resumable receipts, and integrity checks.

The CLI gives an individual researcher working defaults. The TypeScript library exposes the same pieces as replaceable boundaries for an application that already has its own model transport, OCR provider, cache, scheduler, or object store.

The public dataset is a mirror of the manifest-selected production lake, not a second extraction. Each successful refresh publishes internally, runs the integrity audit, and then updates Hugging Face. That keeps the free download and the data used by NexusTrade on the same audited rows.

GitHub - austin-starks/congressional-disclosures: Congressional trading disclosures: a resumable, sharded extraction pipeline for House and Senate periodic transaction reports, with pluggable storage, model and OCR backends.

Use restriction

Congressional financial disclosures are public records, but 5 U.S.C. 13107(c) restricts some uses. Read the dataset’s data-use notice before redistributing or commercializing the records. The extraction software is separately MIT-licensed.

Originally published at https://nexustrade.io.

Free Historical Congressional Stock Trading Data (2012 to Today) was originally published in DataDrivenInvestor on Medium, where people are continuing the conversation by highlighting and responding to this story.

Find the explanation inside a video, then follow the links to the lesson, data, or portfolio behind it.

I’m launching NexusTrade Videos, a searchable video library for NexusTrade, the AI backtesting platform I run. It brings together the trading experiments, tutorials, and AI systems I’ve been building, with search that reaches inside every transcript.

Remember a phrase about paper trading or agent memory? You can find the explanation without remembering the video title.

If you watch a video about a trading strategy, the obvious next questions are pretty specific. What were the rules? Which dates did you test? What happened during the drawdown? Where can I see the portfolio?

The links beside each video lead to its next step: a lesson, the public portfolio, or the data behind an experiment.

Free to watch. No account required.

Explore the video library

Algorithmic trading and AI: what to watch first

You can browse AI trading videos, algorithmic trading tutorials, and backtesting experiments separately. You can also switch to the longer lessons without digging through the shorts.

These are four places I’d start. They cover AI evaluation, a trading experiment, preparation for deployment, and a public portfolio.

1. How do you know if your AI agent works?

Go beyond a convincing demo. Learn how to evaluate an agent’s results and find what needs to improve.

Watch the AI agent evaluation

2. Does RSI Work? I Analyzed 222,010 Trading Backtests

See where RSI ranked, with the limits of the comparison included.

Watch the RSI analysis

3. 20 things to do before you deploy an AI trading bot

Review data bias, overfitting, validation, and paper trading before deployment.

Watch the deployment checklist

4. I Put $25,000 Into an AI Trading Strategy

Follow the Public Portfolio Challenge and inspect the work behind the trading decisions.

Watch the portfolio video or inspect the public portfolio.

Backtesting RSI: what the results actually show

Take the RSI experiment. I analyzed 222,010 backtests. Of the 34 indicator types that appeared in at least 500 results, RSI ranked 23rd by median Sharpe ratio, a measure of return relative to volatility.

For the comparison below, I narrowed the archive to daily equity strategies starting in 2020 or later:

Without RSI: 83,618 strategies, median Sharpe 0.87
With RSI: 4,017 strategies, median Sharpe 0.51

Users chose different tickers and rules, so the groups are not matched. These historical backtests do not show that RSI caused worse results or predict future returns.

At 0:31 in the video, I put the limitation directly into the explanation:

“That is correlation, not proof that RSI caused worse results, because users chose different tickers and rules.”

Watch the published RSI analysis

Short experiments. Focused lessons.

Some walkthroughs take only a few minutes. The deeper lessons spend more time on one problem, such as evaluating an AI agent or deciding when it needs permission to act. You can also follow a whole series in order.

Read the results beyond the return

Compare a strategy with its benchmark, then look at Sharpe ratio, Sortino ratio, and maximum drawdown. The evaluation lesson explains what each measure helps you see.

Watch the strategy evaluation

See how an AI agent fits together

Tools, the ReAct loop, memory, permissions, and evaluation all have a job. This overview connects them, with individual videos in the library when you want to explore one part further.

Watch the AI agent overview

Want exercises and a structured sequence too? Preview Algorithmic Trading Fundamentals or AI Agents from Scratch through the opening lesson. Each video series also has an optional interactive course.

Already testing a strategy? Watch the lesson on optimization and overfitting before you keep adjusting the rules. QuantConnect’s research guide is a useful companion on overfitting and look-ahead bias.

How the videos get made

I explain the production approach in why I engineer videos instead of recording every take. A reusable voice clone, an avatar, and graphics built in code let me turn a script into a video without starting the filming and editing process from scratch each time. The avatar walkthrough shows the tools.

I still develop the ideas, do the research, and decide what is ready to publish. Some videos use my AI avatar and cloned voice. Others are tutorials. A polished presentation still needs a result you can inspect, especially when money is involved.

Before you pick a video

What is NexusTrade Videos?

It’s a place to follow what I’m building and testing, from trading rules to the software behind the platform. Browse a short experiment or work through a longer lesson.

Where should a beginner start learning algorithmic trading?

Start with the first Algorithmic Trading Fundamentals lesson. Continue with the videos on indicators, trading rules, backtesting, and deployment as those questions come up. The strategy-building short gives you a quick overview if you want to see the process first.

Are AI trading and algorithmic trading the same thing?

They overlap, but describe different things. Algorithmic trading follows a defined computational process. AI trading uses AI somewhere in the research or trading workflow. An AI assistant can help develop a strategy whose trading rules run without AI, and a trading algorithm can operate without machine learning.

Can I search for something said inside a video?

Yes. Try a term such as “paper trading” or “overfitting” in the library search. You don’t need to remember which video it came from.

Do the AI trading videos prove a strategy will make money?

No. A historical backtest and a public portfolio record answer different questions, and neither guarantees future returns. AI-generated information can also be wrong. The SEC, NASAA, and FINRA’s investor alert on AI explains why claims of guaranteed returns and reliance on unchecked AI output deserve scrutiny.

Your next backtest starts here

Start with the backtesting walkthrough, then choose the lesson that answers your next question.

Explore NexusTrade Videos or go straight to the lessons.

AI Trading Shorts & AI Agent Courses

Educational content, not individualized investment advice. Trading involves the risk of loss. Historical backtests and past live results do not guarantee future performance.

Originally published on NexusTrade on September 7, 2026.

Learn Algorithmic Trading From Short Form Videos was originally published in InsiderFinance Wire on Medium, where people are continuing the conversation by highlighting and responding to this story.

Public Portfolio Challenge · Episode 11

LinkedIn is drowning in AI trading apps.

This one audits your habits. Others launch backtests or generate signals. Some are useful. None of those demos answer the question I care about.

Would you give the AI real money and publish every fill?

I did.

Funded in February, first trade May 5, and up 26.58% in the 108 days since against SPY’s 6.64%. A nineteen-name rotation of long-dated calls, built by describing it to an AI in plain English. I was writing about the same idea three years ago, using GPT-3. Every fill is public at that link: the Public Portfolio Challenge.

People call it dumb luck. So I am going to do it again, this time around the first positive Phase 3 result for a personalized mRNA cancer therapy.

The same platform Covid-19 accelerated. A new target: recurrence after melanoma surgery.

This time I am not going to hold the AI’s hand. xAI shipped Grok Bot, an autonomous agent that gets its own cloud computer, signs into your services, and works for days without you. This is the test to see how good Grok Bot really is at developing trading strategies.

Grok Bot working on its own cloud computer: it spins up an agent, checks what is connected, and signs itself into Salesforce. Now point that at a brokerage.

I pointed it at the Public Portfolio Challenge runbook, the same discipline that built the account above. Then I gave it the thesis.

The edge is simple. Moderna’s innovation proves AI is not a fad. Which means two things: biotech is about to have its most explosive rally ever, and AI is not going to stop.

That was the whole brief. A few hours later it came back.

Before I show you what it built, you need to understand what Moderna actually did.

What actually happened, and why it is an AI result

On August 19, Moderna and Merck announced that their personalized cancer vaccine passed a Phase 3 trial. Every patient had melanoma a surgeon had already removed and was at high risk of it returning. Both arms got Keytruda; one arm also got a vaccine built from their own tumor. Did the cancer come back less often, and did it spread to distant organs less often? Yes to both. Nobody has released survival data, so we do not know yet whether people live longer. It is still the first Phase 3 win ever recorded for a personalized mRNA cancer therapy.

It is built one patient at a time. Sequence the tumor, compare it to healthy tissue, and you get hundreds of mutations unique to that person. Then the step that made me want to trade this: an AI model reads every one of them and keeps the 34 most likely to provoke an immune response. Everything on either side of that prediction is chemistry Moderna already knew how to do.

Moderna has said this on their own site since December 2023. Their program materials label the step plainly: “Up to 34 neoantigens. Automated algorithm integrated with workflow.” And in the Phase 1 data, every immune response they measured came from a target the algorithm had predicted would work.

The hard part was never synthesizing the mRNA. It was choosing what to put in it, and an AI model did that. Biology just became a compute problem.

Which is exactly why I am still long AI

I know the prevailing wisdom on social media and in the mainstream media is that AI has run its course.

That is backwards, and Moderna is the proof.

An individualized neoantigen vaccine creates a fresh compute workload for every patient. Each dose requires tumor and healthy-tissue sequencing, variant calling, neoantigen ranking, and the scheduling of a bespoke manufacturing batch. Melanoma alone is roughly 100,000 new US cases a year, and intismeran trials are already running in lung, kidney and bladder.

That is the bridge to silicon: more personalized programs mean more recurring sequencing, model inference, storage and networking. It does not prove the revenue impact will be material to any chip company. That uncertainty is why semiconductors are a separate forward thesis and a separate book, rather than a result I smuggled into the Moderna readout.

Two theses, so I created two agents in Grok Bot.

I run one account per sector. If they were a single book I could not tell which thesis was working. Moderna Trading Bot trades the neoantigen chain, and SemiConductor Trading trades compute.

The second Grok Bot taking its runbook. I paste a spec, it works through it and only stops at deploy sign-off.

How I used Grok Bot to create my AI and biotech strategies

Grok Bot is only as good as the tools you hand it. Left alone with a browser it will read Reddit and guess. I gave mine three surfaces into one engine: MCP for the entire toolbox, the Python SDK for anything that has to run a hundred times, and a browser it barely touched.

The Moderna Trading Bot on its first task. It found the MCP server already connected and listed 157 portfolios before I finished typing.

MCP is where all of the work happens. NexusTrade exposes 122 tools over it, and they are not only execution. Backtesting, walk-forward certification, options chains and deploys on one side. News search, SEC filings and web research on the other. Grok Bot never had to leave the connection to build either book. Connecting is one config block and an API key.

Live orders only ever stage. Nothing Grok Bot decides reaches the market without me clicking approve.

That includes the filings. Ten-Ks, 10-Qs, 8-Ks and the news wire, queried the same way as a backtest. It is why Personalis, which runs the tumor sequencing behind the Moderna program, is one of the twenty names the book trades. Tempus AI agreed to buy it on August 21 at a 28% premium, two days after the readout and three days after my measured window closed.

The Python SDK handles volume (pip install nexustrade). Studies enqueue and poll, so the Bot fires off a hundred backtests and collects them later.

The browser is pure redundancy. It can open NexusTrade and read the UI. Mine never needed to.

I set the experiment: the theses, funded accounts, calendars, four-fold structure, lockbox rules and pass/fail gates. For biotech, I also wrote the universe criteria and supplied a long-dated-call skeleton to test. For semis, I left the universe and every trading mechanic open.

Grok Bot did the strategy work: it researched and froze the names, designed and swept the candidate mechanisms, killed the ones that missed a gate, chose the cross-fold robust settings, assembled the final books and staged them for my approval. I remained the only person allowed to approve a live order.

The rules it came back with

Here are both books, rule for rule. Not summaries, the literal conditions each account trades on. Once deployed, the only human step is order approval.

BUY and SIZE are the pair that matters in both. A few hundred dollars of premium carries the exposure of several thousand dollars of stock, so each book runs a median of 15.44% deployed for biotech and 14.70% for compute and still moves like it is fully invested. That cuts both ways, and it is where the drawdowns come from.

I made Grok Bot prove it on data it was never allowed to see

Anyone can produce a backtest that looks incredible. Turn enough knobs against enough history and you will always find a setting that would have made a fortune, and then it dies the month you fund it. That is the whole problem with the genre.

So I made the tuning and the grading happen on different years. Grok Bot was allowed to adjust the rules on one stretch of market history, then graded on the year immediately after it, which it had never been shown. Then everything slid forward and repeated. Four times. Those four graded years are the four bars below, and no rule was ever tuned on the year it was graded on.

If you are quant-minded, you recognize this as walk-forward optimization.

Two rules on top of that. It had to deploy the settings that held up across all four graded years, not the settings that won the best one, because shipping your single best year is how you overfit while feeling rigorous. And the data stopped at April 14. No rule was tuned on a single day after that date, and I did not look at what happened next until the design was frozen.

The other place options backtests die is fills. Every fill is priced against real OPRA bid and ask, roughly 400 million quote rows per trading day. The engine does not fill at the midpoint. It fills at the midpoint plus half the spread against you, going in and coming out, and rejects contracts wider than the strategy’s spread limit before the order is built. Minutes with no quote fall back to a measured spread table bucketed by moneyness and expiry, so a far out-of-the-money LEAP is charged about twice what an at-the-money one is.

Eight graded years across the two books, every one positive, and seven of the eight beat their own benchmark. ARKG actually lost money in three of the four biotech years while the book made 26%, 25%, 56% and 21%. The semis book beat SMH in all four. No single lucky stretch dragging up an average, which is the failure mode that kills most strategies the day they go live.

Then I opened the lockbox

April 14 through August 18, 2026. Four months of real market history that neither agent had ever been allowed to see, replayed against the frozen rules with nothing left to tune.

The Moderna book returned 62.97%. Over those same four months the S&P returned 11.29%, and ARKG, the biotech ETF, returned 50.10%.

It did that with a median of 15.44% of the account actually spent, against benchmarks that are 96% invested every day by construction.

What that window does not contain is the news. The readout landed August 19, the day after the lockbox closed. So 62.97% does not measure the Moderna trade, it measures whether the rules survive four months they were never shown. I also froze the twenty names in August knowing how that stretch had gone, and that hindsight is in the name list. The rules got tested. The thesis is the forward bet, and it starts now.

The names were right, and that is most of the story. Those same twenty tickers held as ordinary stock, equal weight, no options and no ranking, returned 39.43% over the lockbox against the S&P’s 11.29%. The sector carried it. That is the gold dashed line above.

ARKG caught the same wave, which is the honest part: a dedicated biotech ETF did 50.10% on those four months, so the sector was the tide, not my stock picking. The distance from there to 62.97% is step 5. It owned the move in long-dated calls instead of shares, and it did that on a sixth of the capital.

The semis book did the same thing on the silicon side, over its own window. Each campaign froze its holdout before it started, so the semis lockbox runs April 17 to August 23 rather than April 14 to August 18. +44.43% against SMH’s +21.09%, and the same seven names held as ordinary stock returned 20.35%. So the book more than doubled both of them, and it did that at 14.70% deployed against their 96%. Twice the return on a seventh of the capital at risk.

What the biotech book did well:

• Beat ARKG by 12.9 points and SPY by 51.7
• Did it with 15.44% of the account spent, against 96% for both
• All four graded years positive, worst +20.75%
• Better return per unit of downside risk than SPY (Sortino 4.25 against 3.50)
• 17 of 20 names traded, so no single-name lottery

What it did not:

• ARKG earned its return more smoothly (Sortino 5.16 against 4.25)
• Worst peak-to-trough fall was 24.88%, against ARKG’s 13.48%
• Universe was picked in August 2026, so hindsight is in it
• Replayed on historical chains, not live fills

I did not trust the first live design, so I rebuilt it

August 26 update: on August 24 I funded one $13,500 Public account with two long-call sleeves. Biotech waited on XBI. Semiconductors waited on SMH. The account bought one QGEN call, then the sector gates kept the rest of the book quiet.

I hated the explanation because it did not match the thesis. ANET is not SMH. MRNA is not XBI. Diagnostics, sequencing infrastructure, life-science tools, compute, networking and semiconductor equipment do not share one demand mechanism just because an ETF provider puts them in adjacent boxes.

So I reopened the entire design. Entry rules, exits, option structure, sizing, deployment and portfolio construction were all allowed to change. I did not give MRNA or ANET a special allocation. I did not require five profitable folds out of five. I required a candidate that was executable at the account’s actual $13,500, interpretable at the order level and robust across genuinely separate market windows.

The first combined portfolio was still two independent sector queues. Lowering their exposure caps made drawdown worse because whichever queue evaluated first could crowd out the others. The final research candidate uses one central allocator. The thesis buckets explain why a company belongs. They do not own separate cash queues.

The final universe contains 26 companies across eight business mechanisms:

• Therapy platforms: MRNA, MRK, BNTX, BMY
• Computational discovery: RXRX, SDGR
• Precision diagnostics: ADPT, GH, NTRA, VCYT
• Measurement infrastructure: ILMN, TWST, QGEN, TXG, PACB
• Life-science tools: TMO, DHR, A, TECH
• AI compute: NVDA, AVGO, MRVL
• Manufacturing and equipment: TSM, AMAT, LRCX
• Networking: ANET

Every company has to pass its own 100-day trend and 63-day momentum checks. One allocator ranks the eligible names by 126-day return and weights them by 63-day return divided by 63-day volatility. There is no XBI gate. There is no SMH gate. Every holding is a single long call, so the cash account never depends on spread approval or a short option leg.

The five out-of-sample returns were +42.87%, +25.00%, -2.22%, +9.95% and +65.40%. The pass condition was never five profitable folds. The result was four of five, a +25.00% median OOS return, 1.99 median OOS Sortino and 22.47% worst OOS drawdown. The losing fold stayed in the table because deleting the inconvenient year would make this exercise pointless.

The full $13,500 event replay ran from March 2022 through April 2026 and finished at $47,570.44, a +252.37% return. Sortino was 2.02, maximum drawdown was 29.79%, median capital deployed was 30.53%, 20 of 26 names traded and the event tape contained 496 option fills after default fees.

Marked option exposure reached 62.78% even though the entry gate was lower. That is not a contradiction: the gate blocks another buying cycle; it does not force-sell calls that appreciate. The strategy can still spend 573 days underwater. That is the risk profile.

The separate-bucket version produced four profitable folds out of five and a 2.54 median Sortino. It lost the construction decision because worst OOS drawdown reached 33.43%. Cutting its aggregate gate from 48% to 40% or 32% made the worst drawdown worse, not better. The central allocator reduced it to 22.47%.

ANET was the best gross cash-flow contributor in the weak separate-bucket fold, at about +$1,867. It still was not affordable in the current executable snapshot: one audited long-dated contract cost about $2,225 against an $810 per-company budget. The strategy rejected it instead of silently making ANET a 16% bet.

The validated replacement is now live. On August 26 I preserved the rejected six-strategy, sector-gated implementation in a separate paper portfolio, then replaced the live Public account’s strategy set with an exact copy of the validated 29-strategy object: one 26-company allocator, two global option exits and 26 company-specific exits. The brokerage account, its history and the existing QGEN December 2027 $45 call were preserved. Automatic approval remains off at both the portfolio and strategy level.

A current-book reconciliation resolved the account at $13,335.02. Its target was the same single QGEN contract already held. It produced zero orders, $0 estimated cost and no wash-sale flags. QGEN remains in the thesis universe, and none of its exit conditions fired, so the redesign did not force a sale or create a duplicate order.

The two original Grok Bot books remain public paper reproductions of the results earlier in this article:

• Moderna Trading Bot: Original Grok Paper
• SemiConductor Trading: Original Grok Paper

They are historical controls. They are not the final $13,500 design.

Watch the funded account: Public Portfolio Challenge: Semis + Biotech

Read the exact research record: Episode 11 final options portfolio redesign

Concluding thoughts

I expected to write the post where the agent produces a beautiful backtest that falls apart the second you hold out a window. That is what the LinkedIn posts never show you, because they never hold one out.

Instead, Grok Bot produced two useful starting books and a pair of sealed historical results. Then the funded implementation exposed a design problem the headline results could not answer: how should one small cash account allocate across companies whose theses are related but not interchangeable?

The answer was not a biotech switch, a semiconductor switch or a privileged MRNA and ANET core. It was one allocator that lets each company qualify on its own evidence, then makes every candidate compete for the same scarce options budget.

The measurement still has limits. I selected the 26-company universe with August 2026 knowledge. The replay uses historical option chains rather than future live fills. The worst full-period drawdown was 29.79%, and the longest underwater stretch was 573 days. Four profitable folds out of five is evidence, not certainty.

Every campaign log, fold table and failed parameterization is in the Public Portfolio Challenge repo. The rejected sector-gated design stays in the history next to the selected one. A track record containing only winners is a marketing document.

The redesign is now the live strategy set. QGEN remains the only position, the deployment reconciliation required no orders and all future orders still require manual approval. Episode 12 is the forward test: whether this company-level allocator can turn a strong thesis into disciplined exposure without letting sector ETFs veto the names I actually chose.

Moderna’s algorithm ranks 34 neoantigens out of hundreds and puts them in a syringe. I audited eight thesis buckets, 26 companies and 496 simulated option fills before deciding what the account should do next.

Same math. Considerably lower stakes.

Originally published at NexusTrade.

Moderna basically cured cancer, so I used Grok Bot to create a trading strategy on it. was originally published in DataDrivenInvestor on Medium, where people are continuing the conversation by highlighting and responding to this story.

Originally published at nexustrade.io. Every clip below is playable in the original post. This version keeps the findings, the method, and the numbers.

I write about markets and AI for a living. Most of what I publish never becomes a video, because making one means setting up a camera and reading my own writing out loud, and I would rather spend those hours on the research. I wanted to feed in the text and get narration in my voice. A paid clone was the obvious first try and it was not good enough, so I trained my own.

The short answer

Fine-tuned Dots.TTS won the final rounds. The model that sounds best is one I cannot use.

I ranked one question: does it sound like me. Every verdict clip reads the identical 67-word script. The zero-shot arms use the same clean 20-second reference, the files were loudness matched and duration padded, and the model mapping stayed sealed until after I committed to a ranking.

The top two were separated over three sealed rounds, including one on a script neither had seen with three takes per model. In that round I flagged a “hiccup” artifact on two clips and asked whether they were the same model. They were, and it was MOSS. Dots.TTS took the round.

The useful answers

• Best overall, and what I ship: Dots.TTS soar, fine-tuned
• Runner-up, close enough to swap in: MOSS-TTS v1.5, fine-tuned
• Sounds the most like me, cannot ship: OmniVoice + LoRA, checkpoint 800
• Best with no training: Dots.TTS soar, zero-shot
• Best paid option: ElevenLabs Professional

This table merges blind rounds run over four days. The top three met each other directly. Rows further down never met, and are ordered from my notes rather than from a head-to-head, so read adjacent rows as ties. Every clip is one take, chosen the way anyone publishing a demo chooses one, which is exactly the problem the second half of this article is about.

The full ranking

Play every clip in the original post.

• Control — Me, actually reading it (human): “perfect”, identified every time. The control. Recorded on a phone, reading the same 67-word script. Audio
• #1 — Dots.TTS soar, fine-tuned (Apache 2.0, 2.2B): “strong”, “great, no crazy defects”. The keeper. Won the final round on a script it had never seen, and holds the tightest take-to-take spread of anything I trained: 1.3 seconds across five renders. Audio
• #2 — MOSS-TTS v1.5, fine-tuned (Apache 2.0, 8.5B): “great”, “extremely good… it doesn’t collapse”. Lost by a hair. Four times the parameters of the winner, and carries a faint hiccup I picked out blind across two separate takes. Audio
• #3 — OmniVoice + LoRA, checkpoint 800 (open code, CC-BY-NC weights): “probably the best… but end of sentences still collapse hard”. The closest thing to my actual voice in this entire test, and I cannot use it. It garbles phrase endings on long text and silently drops words on short text. Listen to the end of this clip. Audio
• #4 — CosyVoice 3 0.5B, fine-tuned (Apache 2.0): “really good, no issues”. My first keeper, shipped for weeks, and it still holds up with no issues on either script. Two models eventually edged it out. It is 0.5B, the smallest thing here that I would genuinely ship. Audio
• #5 — Dots.TTS soar, zero-shot (Apache 2.0): “pretty good”. 98.6% word coverage, zero added words, 23.84s. Audio
• #6 — OmniVoice, zero-shot (open code, CC-BY-NC weights): “really good”, “decent”. 100% word coverage after trimming 2.0s of hallucinated speech before the script. Audio
• #7 — Audio8 0.6b, zero-shot (Apache 2.0): “okay”, “good-ish”. 100% word coverage, 27.31s. Audio
• #8 — Chatterbox, zero-shot (MIT): “ok”. The fair rerun using the same clean session1 reference as every other zero-shot arm. This replaces the old scavenged-reference clip. Audio
• #9 — Qwen3-TTS, zero-shot (Apache 2.0): “okay”. The clean session1 reference, identical script. Audio
• #10 — IndexTTS-2, zero-shot (custom model licence): “okay, robotic, too fast”. The clean session1 reference, identical script. Audio
• #11 — CosyVoice 3, zero-shot (Apache 2.0): “okay”. The same architecture as the old fine-tuned keeper, with no adapter. Audio
• #12 — Audio8 0.1b, zero-shot (Audio8 Community License v1.0): “okay, robotic”. 100% word coverage, 27.26s. Audio
• #13 — MOSS-TTS v1.5, zero-shot (8.5B) (Apache 2.0): “decent, worse than Audio8 0.6b”. 21.76s. The largest model in the test, and near the bottom without training. Fine-tuned, the same model finished second overall. Audio
• #14 — ElevenLabs Professional Voice Clone ($22/mo): close, not close enough. The better of the two paid clones I made, trained from cleaner source audio. Audio
• #15 — Qwen3-TTS 1.7B, fine-tuned (Apache 2.0): great audio, not my voice. Clean, natural synthesis. The generated speaker is somebody else. Audio
• #16 — XTTS-v2, fine-tuned (non-commercial): “hilariously bad”. Two separate takes landed at the bottom of a blind set. Audio

The result that changed the article

Dots.TTS is the best zero-shot model I tested. It beat OmniVoice zero-shot in the round that ranked them together, and OmniVoice zero-shot in turn beat Chatterbox, Audio8 and MOSS-TTS in an earlier round. The previous Chatterbox claim came from an older clip rendered with a scavenged reference. When I reran Chatterbox against the same clean session1 reference as the field, I called it “ok” and ranked four zero-shot systems above it.

Fine-tuned Dots.TTS beat everything I trained. It won a head-to-head against fine-tuned MOSS on a 94-word article paragraph neither model had seen, three takes each, and it won the 124-word round before that. Both are Apache 2.0, so the licence does not decide it.

OmniVoice sounds the most like me and I still cannot ship it. Its code is Apache 2.0 but its pretrained weights are CC-BY-NC, and that is the smaller problem. The real one is that it garbles the ends of phrases on long text and silently drops words on short text, in every take I have ever rendered.

The fine-tunes had 45 minutes and the zero-shot models had 20 seconds. That measures my exact setup, not every possible zero-shot reference length. ElevenLabs also used cleaner source audio than my corpus.

Every one of these can sound like me. None of them can do it on demand.

Somewhere around the fortieth blind test I stopped learning anything from the question I had started with. Five different architectures now produce audio I call “great” on the first listen. Timbre is solved, and it is solved by more than one model.

What is not solved is doing it twice.

The same checkpoint, the same script, the same reference clip, run again, gives you a different result. Some of those results are unusable. Here is my own verbatim reaction to nine takes from the model I eventually shipped, all from one checkpoint, all reading the same 124 words:

23s   too short to hold the script
44s   "really good"
22s   too short
50s   "great, more stable"      <-- shipped
48s   "damn-near perfect"
46s   "perfect jk maybe slightly robotic"
30s   too short
47s   "cutoff bad"
 8s   too short

Four of the nine were too short to physically contain 124 words. Of the five that were long enough, four were good and one cut off sentence endings. A demo is one take, chosen by the person publishing it. That is true of every voice-cloning demo you have ever heard, including the ones in this article.

So the workflow that actually ships is not “generate narration”. It is generate three to five takes, throw away anything materially shorter than the others, and listen to what survives. The machine discards the obvious failures. A human still has to approve the rest.

The screening rule is cruder than it sounds and it took me a while to get right. Sort the takes by duration and drop the short ones, but compare each model against its own takes rather than a fixed words-per-minute number. Dots reads at roughly 175 words per minute and MOSS at roughly 150, so a single threshold either throws away good Dots takes or waves through bad MOSS ones. On one 67-word script, five Dots takes came in at 22.56, 22.88, 22.88, 24.00 and 24.32 seconds. The 22.56 one had quietly dropped the closing sentence, “So I sold all of my Google calls.” It sounded completely fine. A gap of one and a half seconds against its own siblings was the only evidence.

And duration only catches missing speech. It cannot catch a model mangling a word inside a full-length take, and it is useless for OmniVoice, which pads every render to the same length whether it succeeded or not: 25 renders, all between 45.85 and 46.18 seconds, some of them fine and some of them dropping words. There is no automatic check for that. There is only listening.

If you are choosing a model for real work, this is the axis to choose on. Not which one wins a single blind test, but which one loses the fewest takes.

The model I ranked near-last, zero-shot, finished second once I trained it

MOSS-TTS v1.5 was the largest model in the test at 8.5B. Two Reddit commenters recommended it in strong terms. Blind and untrained, I called it “decent, worse than Audio8 0.6b” and ranked it below every fine-tune and below a 0.6b model.

Then I fine-tuned it on the same 45 minutes. It finished second overall, and at one checkpoint I described it as “extremely good… honestly, it’s amazing”.

That is the most useful thing I learned about picking a model. A zero-shot ranking tells you almost nothing about how a model behaves once it has your voice. If I had trusted the zero-shot table, I would have thrown away the runner-up before training it. The winner, Dots.TTS, made the same jump: sixth zero-shot, first fine-tuned.

Parameter count bought nothing on its own. The 2.2B winner beat the 8.5B runner-up, and both beat models in between. What mattered was whether the architecture could absorb 45 minutes of one voice.

Take the test: one of these five is a real human

This is a reader exercise, not one of my ranking sessions. I assembled it from the same clips under the same conditions so you can try the thing I did: identical script, every file normalised to the same loudness, padded to the same length and the same byte size, and served from opaque filenames so the page source does not give it away.

Play A through E in the original post, commit to an answer, then come back. Direct clips: A · B · C · D · E

The answers: A Dots.TTS, fine-tuned. The overall winner. · B ElevenLabs, paid clone · C VibeVoice, fine-tuned · D me, the real recording · E CosyVoice 3, fine-tuned.

D is me. If you picked wrong, that is the finding: forty five minutes of phone audio was enough to make a synthetic version hard to separate from the real one.

How to clone your voice, in one pass

1. Record 30 to 45 minutes in one session. One room, one mic, one sitting. Mine was an iPhone with no interface and no treated room. Do not pool old clips from different days: that was the single biggest quality jump in my testing.
2. Convert to 24 kHz mono and skip enhancement. ffmpeg -i src.mov -ar 24000 -ac 1 -c:a pcm_s16le audio.wav. I tested an enhanced version of the same recording and it scored worse.
3. Cut into 4 to 12 second clips on sentence boundaries, then check the clip manifest against your recording length. My first chunker dropped over-long segments instead of splitting them and silently lost 27 of 52 minutes.
4. Transcribe with openai-whisper, model large-v3, running on the same GPU. Each training row is a (text, audio) pair.
5. Rent one 24 GB GPU and prove it is real before installing anything: python -c "import torch; assert torch.cuda.is_available()". A silent fall back to CPU will hide a dead machine for a whole run.
6. Read the project’s Dockerfile. It is the only authoritative record of the environment. For CosyVoice the load-bearing details are Python 3.10 and pynini from conda-forge.
7. Train, saving a checkpoint per epoch. About 22 seconds per epoch for 45 minutes of audio. Do not assume the last checkpoint is the best one: mine peaked at epoch 4 of 31.
8. Render three takes per checkpoint, then screen them. Generation is stochastic and most of these models take no seed. Render 3 to 5. Pass 1, mechanical: sort by duration and drop any that are materially shorter than the median of that model’s own takes. Do not use an absolute words-per-minute threshold. Pass 2, human: listen to what survives and pick by ear. Do not rank takes by Whisper word coverage. I did this for weeks and it is worse than useless.
9. Rank blind. Normalise loudness, pad to one duration, hide the labels until after you commit.

The full copy-paste plan for an AI coding agent, including the dots.tts install and the take-selection rules, is in the original post.

Two levers moved the result. The rest were a wash or worse.

• Fine-tuning instead of zero-shot — decisive
• Recording one clean session — large effect
• Scraping more clips from old videos — a wash
• More training steps — a wash
• Correcting the transcripts — a wash
• Enhancing the audio before training — scored worse

One clean recording beat everything I scraped

I started by scraping audio out of videos I had already published, because it was free and it was there. My first clone came from 2 minutes 33 seconds of it and was good enough to be my keeper for weeks. Audio — VibeVoice-1.5B, 22 clips, peaked at 200 steps.

Scraping more of it stopped helping quickly. I built a second corpus of 14 minutes 28 seconds from the same videos and it tied with the 2.5 minute version in a blind ranking.

Then I sat down and recorded 45 minutes in one session, one room, one microphone, one sitting. That corpus produced the CosyVoice and VibeVoice keepers, then trained the OmniVoice adapter that beat them.

Record properly instead of scraping. Clips pulled from videos shot across different rooms and days carry all those rooms into the model. Forty five minutes recorded on purpose is a couple of hours of your time and it is the single biggest quality jump I found.

The peak arrives early

With one model I extended a run from 3200 to 6400 steps because the curve looked like it was still climbing. The first 3200 were the whole gain. My CosyVoice keeper peaked even earlier, at epoch 4 of 31, so plan on auditioning early checkpoints rather than training longer.

The ranking that picked the first keepers

This earlier five-file session contained both ElevenLabs voices, the CosyVoice and VibeVoice fine-tunes, and the real recording. It selected the two keepers I shipped before OmniVoice finished training. The newer sealed tests at the top of the article supersede its overall order.

What I said before the reveal:

• A — ElevenLabs, scavenged source: “bad”
• B — ElevenLabs, cleaner source: “good”
• C — VibeVoice, fine-tuned: “good, maybe slightly better. honestly best”
• D — me, the real recording: “so good that I think it’s probably legit me”
• E — CosyVoice, fine-tuned: “good, maybe slightly better than B”

Read C and D together. I called the fine-tuned model “honestly best” and, separately, flagged the real recording as “probably legit me.” I did identify the human. I also rated a synthetic clone at the top of the set while doing it. Both paid clones landed below both fine-tunes.

That established the first practical bar for narration, and it stood for weeks. Every model in this session has since been beaten by a fine-tune that did not exist when I ran it. The order at the top of the article is the current one.

What each option actually costs

• ElevenLabs Creator — $22/mo forever, 100k credits (~100 min), you do not own it
• ElevenLabs Pro — $99/mo forever, 500k credits, you do not own it
• Fine-tune your own — under $1 per run, about $5 to a first clone plus GPU time to render, no cap, and you own the adapter, subject to the base-model licence

The whole project, including every failed experiment and dozens of training runs, came to about $17 of GPU time. That is less than one month of the cheapest tier that supports professional voice cloning.

I did not provision or run any of this infrastructure by hand. I described what I wanted to an AI coding agent, it stood up the environment, rented the GPU, ran the training, and shut the machine down when it was done. The plan in the original post is the instruction set, and everything it needs to get right is already in it.

The cost is a few dollars of rented GPU and the time it takes you to record.

One honest asterisk on that comparison: the $22 a month buys inference too, and self-hosting does not. Training is a one-off, but every minute of narration afterwards needs a GPU. At my volume that is pennies of pod time per batch. If you are generating a hundred minutes a month you should price it against the tier that covers it, not against the training run.

The 124-word script exposed silent drops

OmniVoice checkpoint 500 read the 67-word verdict script with 100% coverage and zero dropped words. On 124 unseen words, the same checkpoint fell to 86% to 91% coverage. Every take silently dropped 11 to 21 words.

A caveat I owe you about that number. “Coverage” here means the share of scripted words that Whisper heard in the render. I used it to pick takes for weeks, and it is worse than useless as a quality score. It measures Whisper’s transcription, not the model’s speech, so a robotic render that Whisper parses cleanly outscores a natural one it stumbles on. It ranked a take I described as sounding like Steve Urkel at the top of a ladder. It told me 24 words were missing from a take where the full script was plainly there. It scored 100% on OmniVoice clips where I could hear words being dropped. I keep the numbers below because the direction is real and the drop is large, but I no longer choose anything by them.

• OmniVoice ck500, 67 words — 100% coverage, 0 dropped
• OmniVoice ck500, 124 words — 86–91% coverage, 11–21 dropped every take
• CosyVoice keeper, 124 words — 95–97% coverage, 3–6 dropped
• Dots.TTS fine-tuned, 124 words — no drops heard, judged by ear

Dots.TTS fine-tuned, the keeper, 124 unseen words: Audio. Chosen by ear from five takes. On the same 124 words I called it “actually good… because of the lack of collapsing, it’s probably better”.

OmniVoice + LoRA, checkpoint 800, same 124 words: Audio. The best OmniVoice I ever trained. “Probably the best… but end of sentences still collapse hard.”

Length is its own test, and it reorders the table. OmniVoice wins on speaker similarity and then loses continuity as the script grows. CosyVoice held long-form better and was my keeper for exactly that reason, until fine-tuned Dots.TTS beat it on both. A 23-second demo and a ten-minute narration are different tests, and most published demos are the former.

Licence, consent, and the things that decide this in practice

Check the licence before you pick a winner

“You own the weights” in the cost table is doing more work than it looks. You own the adapter you trained, on top of a base model whose terms you did not write. Checked on Hugging Face, 24 August 2026:

• FunAudioLLM/Fun-CosyVoice3–0.5B-2512 — Apache 2.0
• vibevoice/VibeVoice-1.5B — MIT
• IndexTeam/IndexTTS-2 — custom: “bilibili Model Use License Agreement”
• Qwen/Qwen3-TTS-12Hz-1.7B-Base — Apache 2.0
• ResembleAI/chatterbox — MIT
• coqui/XTTS-v2 — Coqui Public Model License 1.0.0, non-commercial
• Audio8/Audio8-TTS-Preview-0.6b — Apache 2.0
• Audio8/Audio8-TTS-Preview-0.1b — custom: Audio8 Community License v1.0
• OpenMOSS-Team/MOSS-TTS-v1.5 — Apache 2.0
• k2-fsa/OmniVoice — CC-BY-NC on the pretrained weights
• dots-studio/dots.tts-soar — Apache 2.0

Four of the eleven systems understate their restriction on the surface. IndexTTS-2 uses the bilibili Model Use License. XTTS-v2 is non-commercial, including its outputs. Audio8’s 0.1b model uses a revenue-limited community licence even though its larger 0.6b sibling is Apache 2.0. OmniVoice is the easiest trap: the GitHub code is Apache 2.0 and the Hugging Face card has no licence tag, but the README licenses the pretrained weights under CC-BY-NC because the training data includes Emilia.

That code-versus-weights split also applies to F5-TTS: MIT code, CC-BY-NC weights, again because of Emilia. It remains an interesting research fine-tune, but its public weights are not the commercial next step a licence badge can make them look like.

One provenance note: I trained on vibevoice/VibeVoice-1.5B, a community copy, and Microsoft's first-party microsoft/VibeVoice-1.5B is also live and also MIT. Prefer the first-party repo, and read the licence on the specific checkpoint you pull, since a mirror can carry different terms than its source and terms change between releases.

Clone your own voice, and say that it is synthetic

Everything here is my voice, my recording, my consent. Cloning someone else’s without permission is a legal problem in a growing number of places: Tennessee’s ELVIS Act covers voice explicitly, right-of-publicity law applies in many US states, and the EU AI Act carries transparency obligations for synthetic media. None of that is legal advice, and all of it is worth ten minutes before you point this at a voice that is not yours. Label synthetic narration as synthetic.

Where this test stops

Eleven systems is what I ran, and the field is bigger. F5-TTS, Fish Speech, Higgs Audio, and Sesame CSM went untried. F5-TTS can be fine-tuned, but its public weights are CC-BY-NC. Higgs Audio v3 ships without training code and is research-only/non-commercial. Sesame CSM also ships without training code, and its public repository has been stale since 27 May 2025.

The long-form question now has a measured answer. OmniVoice was perfect on 67 words and dropped 11 to 21 words from every 124-word take. Fine-tuned Dots.TTS, the keeper, reads the same 124 words without dropping anything I can hear, and CosyVoice held 95% to 97% before it. Ten-minute narration still needs a stitching pass and per-chunk take selection, and I have not run one end to end yet.

Versions

Text to speech moves monthly, so these results are pinned to what I ran in August 2026: dots-studio/dots.tts-soar, OpenMOSS-Team/MOSS-TTS-v1.5, FunAudioLLM/Fun-CosyVoice3-0.5B-2512, vibevoice/VibeVoice-1.5B, IndexTeam/IndexTTS-2, Qwen/Qwen3-TTS-12Hz-1.7B-Base, coqui/XTTS-v2, Audio8/Audio8-TTS-Preview-0.6b, Audio8/Audio8-TTS-Preview-0.1b, k2-fsa/OmniVoice, and chatterbox-tts from PyPI. Assume a model released after this article behaves differently, and re-run the test rather than trusting the table.

What I would tell someone starting today

Fine-tune Dots.TTS soar. It is Apache 2.0, it is 2.2B so it trains and renders cheaply, and it won my final rounds. If it disappoints you, fine-tuned MOSS-TTS v1.5 is close enough to swap in without changing anything else.

Budget for three to five takes per clip, not one. This is the part I underestimated for weeks. Every model here is stochastic, and the same checkpoint gives you a usable take and an unusable one on the same script. Screen them by duration against each other, then listen to what survives.

For zero-shot, start with Dots.TTS. It is Apache 2.0, it needs no training, and it beat OmniVoice zero-shot head to head. It is also the model that won once fine-tuned, so it is a reasonable starting point either way.

Record one clean session before you touch a model. Forty five minutes from a phone in a quiet room beat everything I scavenged.

Then rank blind, and rank more than one take per model. Every time I evaluated with the labels visible, I confirmed what I already believed. Every time I ranked a single take, I got a result that did not reproduce.

Why I built this

I run NexusTrade, an AI-powered trading research platform, and I publish what it finds. The writing is the work; recording it was the tax. Now the articles narrate themselves and I spend the time on the analysis.

The platform is built the same way this test was: run the experiment, rank it blind, publish the number even when it says you were wrong.

Originally published at nexustrade.io, where every clip in this article is playable.

Best AI Voice Cloning in 2026: I ranked eleven systems blind. Dots.TTS won. was originally published in Artificial Intelligence in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

14 months as a Google fanboy. 185,172 production requests. $2,129 of my inference spend. Here’s what changed.

The proof is here. In May 2025 I laid out exactly why I liked them. The self-driving cars and the fundamentals were a start, but what I really loved was that Google dominated one category alone: the best, most cost-efficient language models for production deployments.

On August 7, I realized that’s no longer true.

So I sold all of my Google calls.

That was the last piece of a two-year position.

Green is my book. The two flatter lines are the same $5,199 put into GOOGL shares and into SPY on the same first day and left alone. Trading it returned 322%. Owning shares returned 112%. SPY returned 42%.

Looking at what drew me to Google, I no longer see another 100% return on the horizon. The company may keep compounding, but the specific model-cost advantage I bought has narrowed.

That does not erase the rest of the Google thesis. But one of its most important asymmetries, frontier model quality at bargain production pricing, is no longer unique to Google. Here’s what has changed in the past year.

Why I was obsessed with Google

When I published that article last year, I liked Google for a few very specific reasons.

Their technology was unbeatable throughout the stack. AlphaFold solved one of the world’s hardest biological problems. Their AI models were cheaper than OpenAI’s and Anthropic’s while performing better. And the little things, like their “other bets”, were going strong.

As a concrete example, you can’t step outside in Austin, TX without seeing their fleet of Waymos. They were crushing the self-driving narrative while their nearest competitor, Tesla traded at a 169 P/E.

Google’s was 18.

It wrote the SQL itself, walked back to the last session on or before that date, and summed four trailing quarters of SEC-filed net income for the EPS.

A company priced like a dying consumer staple, expected to grow like a Y Combinator startup, and that controlled the best AI models the average person could afford. That was the whole thesis.

So I bought the calls. And I powered my entire platform with Google’s models for a year.

It worked… for a while.

Then Google’s models got old.

Specialized models picked up individual jobs along the way.

DeepSeek V4 Flash, at $0.14 per million input tokens and $0.28 per million output tokens, powered the orchestration layer that used to cost me hundreds of dollars per month. Grok 4.5 powered my search… not only across X, but ALL of the web.

But the core of my platform had been running on the same assumptions for twelve months: “Google was the best, so use it everywhere.”

I hadn’t re-evaluated this assumption in a year. As I prepare for a major launch into the institutional space, I knew I needed to.

So here’s what I did.

Across the past 30 days I rebuilt the evaluation layer of my platform. I built the orchestration loops that turn Nancy Pelosi’s public filings into a testable trading signal. I launched scheduled agents that watch the market around the clock. And I benchmarked every half-decent large language model on OpenRouter, on my own jobs, against my own data.

The canonical window for this article is the trailing 30 days ending August 7: 185,172 production requests and $2,129.42 of total inference spend. That includes the benchmark runs and every other production call in the window.

I expected to find unique winners for each individual task. DeepSeek could power my orchestration loop, Gemini could control querying, and OpenAI could handle planning. That has been the status quo for a long time now.

That has changed. Most of the high-volume agent loop now routes to one provider.

On planning and execution, the two high-volume jobs, GPT 5.6 Luna scored at the top while costing a fraction as much. It was the only executor that beat the old default on score, cost, latency, and schema validity at the same time.

So I already acted on it. On August 6th I removed model selection from my AI platform entirely. Every ReAct decision and sandbox code-generation call now routes through the model I choose. The smallest jobs, like stock screening, keep their own benchmark winner.

The numbers made the choice, and I stopped charging users for a worse option.

Here is why Luna won the deployment decision: quality rose to the top of my benchmarks at a fraction of the incumbent’s price.

Methodology

How to properly evaluate an AI trading bot

When evaluating these models, I had to answer a deceptively difficult question. How do I “grade” my AI model’s performance?

It really depended on the task at hand.

My AI trading bots fetch live data, write strategies, run backtests against a 10.3 billion rows market data lake, read their own results, rent virtual machines, write Python, read the traceback, fix the bug, and deploy trading strategies. A single run spans 30 to 50 model calls and can take 40 minutes or longer.

So “which model is best” isn’t one question for me. It’s a dozen. A model that writes a beautiful plan can be useless at picking the next tool call. A model that nails document extraction can stall out in an agentic loop.

I built a separate harness for each job that matters.

Two years ago I open-sourced EvaluateGPT, a framework that asks a model to write SQL against a real financial database, executes it, and has a panel of LLM judges score the answer. I expanded that framework to every layer of my platform, from generating trading strategies to controlling a computational engine.

This was much harder than it sounds.

The judges had to pass their own exam first

A trading agent’s answer isn’t multiple choice. It’s a plan, a tool call, a 40-page PDF extraction. So every judge here had to clear a gate before it was allowed to grade anything.

1. Calibrate against hand labels. The next-action judge agrees with human labels on 39 of 40 cases, 97.5%, against an 80% gate.
2. Take the median of N draws. At temperature zero, 4 cases by 3 repeats moved 2 of 4 by a full scoring band. Median-of-3 lifted agreement from 85.7% to 92.9% with no rubric change.
3. Re-grade across model families. 827 already-replayed rows re-scored by a judge from a different vendor, purely to measure how much of the result was my judge’s taste.
4. Separate judge noise from the decision. Top planner scores sat within roughly one standard error. Those scores do not choose the model. Billing, latency, and hard schema checks do.

The planning bakeoff made the choice clear. The best models scored almost the same. Luna cost much less. That was enough to migrate. Opus costs 263 times more and does not score better.

Then I had to grade the grader

The hardest thing to grade on this platform is a Run Compute task, where the agent rents a machine, writes its own Python, and hands back a dataset. So before I trusted a single letter grade, I built a corpus to test the grader itself.

Here’s what that job actually is.

A human opens the House Clerk’s disclosure search, picks a year, downloads that year’sFD.zip index, finds Pelosi's filings in it, opens each PDF, reads the transaction table, and types the rows into a spreadsheet. Ticker, buy or sell, amount, date. Sixty-five documents, and plenty of them are scans rather than text.

Now write those steps down and hand them to an intern. That’s the easy version. I had to teach a computer to do it.

So the agent rents a machine, writes Python, pulls the archive, resolves every document URL, downloads all 65 PDFs, runs OCR on the scanned ones, parses the tables, and emits rows.

It can go wrong at every one of those steps.

A date regex anchored on MM/DD/YYYY silently drops six rows, because some filings print 02/2/2018. A model reads "extract ticker, type, amount" as a filter and throws away every holding whose ticker the filing doesn't spell out, losing AllianceBernstein Holding L.P. even though it trades as AB. A sliding-window regex matches fragments across line breaks and reports 19 transactions in a filing that contains 10. Skip the transaction-type filter and a Disney sale comes back as a purchase.

Every one of those produces a JSONL file full of plausible rows. That’s the whole problem. The output always looks fine.

So the question isn’t whether the code ran. It’s whether the agent controlled the computer well, and you can’t answer that by reading the answer. You have to already know what the answer was.

For Pelosi I do. 135 transactions, read by eye off the rendered PDFs, independent of any extractor.

But Pelosi is one task, and the grader doesn’t get to specialize. These are all real jobs Run Compute has been pointed at:

1. Train a PPO reinforcement-learning policy on NVDA daily bars, hold out 2024, and emit a long/flat signal for every out-of-sample session. No lookahead, features standardized on train-only statistics.
2. Pull every customer representing 10% or more of revenue out of the latest 10-K for eight mega-caps, and record an explicit statement where a company discloses none.
3. Test whether an unusually delayed quarterly filing predicts forward returns across US non-financials, 2019 through 2025, using filing-aware fundamentals so the delay is measured against the fiscal period rather than the publish date.
4. Reconcile disclosed share-repurchase authorizations against what twelve companies actually bought back, straight out of their 10-Ks.
5. Measure whether Reddit sentiment predicts returns at t+7, and whether the effect survives once you lag it properly.

Every one of those produces a different artifact, fails in a different way, and has a different definition of correct. I can’t hand-read ground truth for a task somebody invents tomorrow.

So the grader has to be a generalist, and it had to be tested like one.

Naively, the grader is simple. Use an LLM with a 1 million token context window, attach all of the code snippets, run logs, and documents, and ask the model to grade how well it did.

Reality doesn’t work that way.

Take Pelosi as the example. An off-by-one in a reported sample count. A holding that went stale three quarters ago. A membership date that resolves to the wrong quarter. Now go find those inside a generated Python program, the rows it produced, and a validation log. On the Pelosi run, 65 PDFs on top of that.

A single monolithic grading call failed badly in my tests. It could not reliably find small defects across the code, rows, logs, and 65 PDFs at once.

For the first time in months, vibe coding a solution didn’t work. I thought to engage my brain and think of a better solution.

I came across “map reduce”. I decided to give it a try.

Luna tied Hy3 on finding defects, then won on consistency. Re-running the same test, its grade stuck 19 times out of 23. MiniMax flipped more often and raised more false alarms. Luna also cost a fraction as much. MiniMax remains the fallback.

One asymmetry forces that shape. A defect no mapper names can never be recovered downstream, because the reducer only adjudicates what it was handed. A miss at the map step is permanent.

Because there are so many API calls, the mappers have to be dirt cheap. By making each model look at a small subset of the solution space, and then combining the results, we can get a scarily good assessment of the overall quality of the solution, for a cost that’s less than a single Fable 5 API call.

Now that you see the effort it was to grade a model for a single task, I had to grade several models for distinct tasks. While it used to be the case that I’d use DeepSeek for this and Google for that, almost all of my LLM tasks are now routed to one API.

The verdict

Luna won the deployment decision, not every benchmark.

Public benchmarks make Luna look mediocre. The July 9 launch table puts Luna at 84.7% on Terminal-Bench 2.1, 62.7% on SWE-Bench Pro, and 50.3% on Agents’ Last Exam, at $1 per million input tokens and $6 per million out, (cut to $0.20 and $1.20 three weeks later).

Luna leads nothing on that table. It trails OpenAI’s own flagship everywhere, Claude beats it on SWE-Bench Pro by 17.6 points, and on Terminal-Bench it scores below the model it replaced. The only column it wins is price.

And it gets worse when you look at the rows closest to what I actually do.

That test measures monolithic retrieval from a massive prompt; my production stack handles long inputs through bounded agent decisions and map-reduce.

Public benchmarks did not predict my production results. Taken at face value, those tables would have told me Luna was not worth testing. They would have screened out the model that won my production bakeoff before the bakeoff started.

Published benchmarks measure a model against a test somebody else wrote. Here are three I wrote, on my data, with judges I calibrated and prices from provider billing.

The five that decided it

Four went to OpenAI. One went to Google.

Five harnesses ran. Every one of them is on the board. Open a row if you want the table it came from.

Planning: 16 models, 29 frozen production conversations

Router V5 reads a request and decides what to do: write a plan, dispatch to a catalog tool, ask a clarifying question, or continue an existing agent. I froze 29 real conversations, hand-labelled them, and replayed every model through the identical corpus.

Muse Spark posted the highest raw score in the field at 0.759, above Luna and above anything Anthropic or Google shipped. It’s Meta’s, where my twin brother Justin Starks is a senior software engineer.

Good news, Justin. That six-figure stock vest might be worth something one day.

It still isn’t my default. 0.028 of score is not worth paying nineteen times more per decision, and I’d have told him the same thing.

Opus 5 costs 263 times what Luna costs and doesn’t score better. They tie on 17 of the 29 fixtures and split 7 to 5 on the rest. A paired t-test puts that difference at t = +0.85, which is nothing.

Against Sonnet 5, Luna wins by +0.152 at t = +2.11. That one is real.

Ten of the sixteen models are dominated outright: something else beat them on cost and latency and score at the same time. Both Anthropic models are on that list.

Execution · 23 models · Luna is the only one that beat the old default on every axis

Execution: 23 models, 69 frozen decisions, 3 samples each

The planner writes the plan. The executor lives inside the ReAct loop and picks the next action, over and over, until the job is done. This is where an agent actually spends your money.

Luna is the only model of 23 that beat the previous default on every axis at once. It also outscores Muse Spark 1.2, the priciest model I tested, at one twenty-sixth of the cost.

Nemotron 3 Ultra is a 550-billion parameter model that charges $35.28 per thousand decisions and could only hold my output contract 77.5% of the time. Parameter count bought nothing.

That’s the migration I ran the same day.

Artifact grading · 23 fixtures · Luna wins the final judgment call on consistency

Artifact grading: same mapper findings, swap only the judge

Four cheap mappers propose defects. One reducer decides which ones are real and emits the letter grade. For this bake-off every model saw the exact same mapper findings, so the score measures judgment, not discovery.

Luna tied Hy3 on finding defects, then won on consistency. Re-running the same test, its grade stuck more often, and it raised fewer false alarms than MiniMax. MiniMax stays the fallback.

Sandbox codegen: end to end on real Modal VMs

The sandbox operator writes code, runs it, reads its own artifacts, and keeps iterating through a remediation loop until the work clears review. Same prompt, same planner, same grader, real machines. Every model below ran the identical task: correlate Strait of Hormuz ship traffic against the next USO trading session.

Luna is the only model that is best, fastest and cheapest at the same time. It reached the top grade in the field three separate times; GLM managed it once, and neither Qwen nor DeepSeek got there at all. DeepSeek is the mirror image of Luna: slowest, most expensive, never left the bottom band.

What the oscillation told me

This ran on an early build of the remediation loop, and the sawtooth in Luna’s trajectory is the interesting part. Grades climb and fall back instead of ratcheting.

So I labelled every blocking finding in the corpus by hand, 221 of them. Sixteen percent were arithmetic contradictions in the delivered numbers. Sixty percent were defects in code the agent wrote to check its own work — an audit script that assigned the same variable into both delivered_stats and recomputed and then hard-coded a match, acceptance fields written as a literal True, a reconciliation reporting"dedup_rows_removed": 2 against 18 rows in and 17 out.

Each pass fixed the finding it was handed and wrote a fresh self-check with a new hole in it, which is exactly what a sawtooth looks like. The fix isn’t a better prompt or a bigger model. It’s to compute those identities host-side, so the agent has no field to assert them in and nothing to get wrong. That work is underway; the table above is the before.

One cell per model on one task, so read the ordering as directional. Wall clock is soft: my own web tier was CPU-throttled for part of this run, which inflated latency unevenly across arms. Grade trajectories and costs come from the durable grade audit and provider billing.

Stock screening · 22 questions · Gemini 3.6 Flash wins, by 29 points

Stock screening: Google wins this one outright

This is the direct descendant of EvaluateGPT. Twenty-two natural language questions, each turned into DuckDB SQL, executed against my real lake, and scored on whether the answer was actually correct.

Gemini 3.6 Flash beat Luna by 29 points of average score and 27 points of success rate, on the exact task I built EvaluateGPT to measure. It’s not close and I’m not going to soften it. Production runs the model that won.

The judges were biased too

Then I did the thing most benchmark posts skip. I took 827 rows that were already replayed and re-graded them with a judge from a completely different vendor, to find out how much of my result was my judge’s taste.

Both judges prefer their own family. The Luna over DeepSeek gap collapses from +13.9 to +1.5 depending on who’s grading.

Luna is the one model both judges agree about: 3.2 points of cross-judge disagreement against DeepSeek’s 15.6. Output that’s actually good scores the same no matter who grades it. Output that suits one grader’s taste doesn’t.

The deployment decision never rested on that score alone. Cost is provider billing. Latency is provider timestamps. Schema validity is a deterministic key check. On those three Luna beats the old default by 3.7x, 3.2x, and +0.9 points, and no judge touches any of them.

None of those tables proves that one model is universally smarter. Luna won four of the five harnesses, then separated itself on cost, latency, and schema discipline. Gemini won screening, where a user sits and waits and quality is visible in real time. Read together, the tables say the same thing: once several models clear the bar, engineering properties decide. That is a very different market from the one I bought Google calls for.

What I actually run

Luna runs almost everything now

Seven of the eleven jobs listed are Luna, including every one that runs inside the agent loop. Google keeps screening, where it beat Luna by 29 points, plus relevance ranking and the top rung of the authoring-retry ladder, the model a failed generation escalates to rather than retrying itself. Meta’s Muse Spark took web search and news synthesis, on a factual search bakeoff in July, and is running experimentally on 1.2. Grok holds the one job that needs several simultaneous live searches, finding a person’s social posts about a ticker.

Anthropic and DeepSeek run nothing. Not a batch job, not a fallback. Neither is a default anywhere. Agent models are fixed by the platform now, so users cannot select either one.

What this actually bought me

A year ago, turning 65 congressional filings into a tradeable signal meant paying frontier prices for every attempt, and the attempts fail a lot.

A full research report, written by an agent that rented a virtual machine, pulled data from my lake, ran statistics on it, and had its own output graded, for ninety-three cents.

The sandbox compute is 0.2% of that. The machine is never the cost. And grading is roughly fixed per cell while codegen swings sixteen-fold, so there’s a floor around $0.35 on any call, two thirds of which is the grader on a trivial one.

The conclusion

My LLM bill grew more than 5×. Google’s projected share fell to 4%.

It used to be that Google was the only company that cared about people like me. Hobbyists and small businesses were being left out of the AI race because they couldn’t afford to use the SOTA models for their tasks.

Google did not lose my dollars. Its billed revenue from me rose from about $342 to $841 as my workload grew more than fivefold. The signal is at the margin: of the $1,738 in new spend, Google captured about $500. The other 71% went elsewhere.

In the chart’s prior-year comparison window, I spent $408 on inference and Google took 83.7% of it. They weren’t a vendor, they were the supplier. Gemini 2.5 Flash and then 3 Flash were genuinely outstanding, and I built on them because nothing else was close on price per unit of intelligence. That was about$342 billed to Google.

In the August 8 vendor window, I spent $2,146. Google’s share fell to 39.2%, but that was still about$841 billed to Google. Google more than doubled its dollars from me. It captured only 29 cents of each new dollar.

That’s the whole story. Google kept the old work. It did not win most of the new work, on a platform where a year ago it was the only answer.

NexusTrade for Institutions | Multi-Asset Execution and AI Trading Agents

This is just the beginning

Most of the routing changes landed after the thirty-day window closed. In the last full day before the cutover, Google took 23.7% of my bill. In the first full day after it, Google’s projected share fell to 4.0%. The 5% Anthropic slice in the chart is Claude traffic from before the Aug 6 cutover. At the new mix it is zero.

The part where I might be wrong

I sold my Google calls. Alphabet is still a strong company. If someone asked me for safe, long-term investments that will be around for decades, I’d still answer Google. The growth case I was underwriting with leveraged calls is no longer the one I want to press.

The stock doubled and got cheaper on earnings. Growth accelerated on both lines. My original thesis was “priced like a dying consumer staple, expected to grow like a Y Combinator startup,” and by these numbers that thesis is more true today than the day I wrote it.

I’m not claiming Alphabet is in trouble. Search, Cloud, TPUs and YouTube do not care which model wins my ReAct loop, and the fundamentals say whatever they’re doing is working.

I sold leveraged calls after a 112% run, with a 322% return on committed capital. When I bought them, Google had a unique opportunity with Gemini. Google executed, and the stock more than doubled. But the model-cost moat I could observe directly was no longer unique: Google captured only 29 cents of each new inference dollar while other providers took the high-volume loop. I banked the gain. I did not give up on the company.

Running NexusTrade gives me a firsthand view of technology shifts before they become obvious in an earnings report. That founder’s view has shaped positions across my long-term investing account, including the wins and misses below.

Google’s $2,146 of inference spend is immaterial to Alphabet, but the change inside my stack is a real signal: a product advantage I could measure every day had weakened. I combine signals like that with valuation and fundamentals, and over time that process has produced real trading gains.

Google can keep growing. Just not monstrously. It is safe and sound in my long-term investing account.

What that actually buys me

I can now run state-of-the-art for less than last year’s cheapest model cost me.

A year ago this platform screened stocks, ran backtests and deployed trading strategies. That was the entire product. Today the same agent rents a virtual machine, writes its own Python on it, reads the traceback when it breaks, grades its own work before handing it back, and runs walk-forward optimization on options chains.

That’s a categorically harder job, and it costs less than screening and backtesting did twelve months ago.

Which is why the model stopped being the hard part. Luna reasoned better where it mattered: it raised the executor score from 75.3 to 89.2, and it won the artifact-grading slot too. But reasoning alone did not make it the production winner. It also emitted valid schema 99% of the time, returned in 5.6 seconds, and cost $1.67 per thousand decisions. Compared to Gemini 3 Flash, the difference is night and day.

Expensive, heavy models just don’t have a place in my business on these jobs. Other workloads will keep their own winners, the same way screening kept Gemini.

Build a strategy with the deployment winner

Same agent, same data lake, same GPT 5.6 Luna measured in these five harnesses. Free to start, no card, no code.

NexusTrade | Find & Build AI Trading Bots

Originally published at https://nexustrade.io.

I turned $5,199 into $21,935 betting on Google. Here's why I sold it all. was originally published in DataDrivenInvestor on Medium, where people are continuing the conversation by highlighting and responding to this story.

Me and the Robinhood CEO are actually kinda the same.

On July 2nd, Vlad Tenev went on CNBC and described the endgame:

“The end state of agentic trading at Robinhood is to give the everyday person access to the same tools, the same computation, the same power that institutional investors in high-frequency trading firms have been enjoying for several decades.” Vlad Tenev, CEO of Robinhood · “AI agents will soon be able to match human traders, Robinhood CEO tells CNBC” · July 2, 2026

In the same interview, he said that “every capability a human can do will be available to an AI agent,” and that it is happening soon. Soon, as in within the career of everybody reading this.

I agree with every single word of that.

I have agreed with it since October of 2020. It is, almost verbatim, the sentence I would use to explain why I have spent five years teaching an AI to find a trading idea worth testing, turn it into a strategy, backtest it across a decade of market history, prove it out of sample, put it live at a real brokerage with real money, and then keep researching on its own every time a schedule or a market condition wakes it up.

I built this out of a two-bedroom apartment. Instead of sleeping.

Vlad and I want the exact same thing.

The difference is that my version is fully launched.

Robinhood shipped theirs in May. I connected to it in July and found no crypto, no multi-leg options, and an OAuth flow that only completes on localhost. I wrote that up at the time. They have great ideas. They haven’t yet executed.

I have. Here’s how you can REALLY buy, sell, and deploy your own quant-grade AI trading bot.

NexusTrade | Find & Build AI Trading Bots

What I mean when I say “AI trading bot”

If you are in the quant space, you just rolled your eyes.

Good. You SHOULD be skeptical.

“AI quant trading” has been hijacked by low-effort gurus wrapping ChatGPT onto the Alpaca API and selling it for way beyond what it is actually worth. So let me define the term against two tools you already respect.

Composer is the simple end

Composer is genuinely good, and I want to give them full credit before I say anything else. You can drag blocks together (or just ask their AI) to build a strategy: if SPY closes above its 200-day moving average hold TQQQ, otherwise rotate into bonds. It rebalances on a schedule and trades your real money, and it works.

So if the pitch is “no code, just tell it what you want,” Composer already got there. The real question is what their AI is allowed to build.

Because a Composer strategy is an allocation rule. Hold this, or rotate into that, when a condition flips. Rebalance on a schedule. That is the shape of the box, and their AI writes inside it exactly like you do.

You do not have to take my word for how small the box is. Their public API spec lists every indicator a symphony is allowed to use, and there are fifteen. Moving averages, RSI, MACD, Bollinger bands, standard deviation, max drawdown, cumulative return. Every one of them is derived from price. The only company fundamental in the entire schema is market cap.

So a Composer strategy cannot know that a company just missed earnings. It cannot know the P/E ratio, or that revenue grew 40% last quarter, or that insiders have been selling. It can know the chart. That is the whole vocabulary.

You would think their saving grace is that they support options. Unfortunately, it is not what it sounds like.

Here is their own schema. Read the comments I added.

// Creating an automated strategy. This is the field that decides
// what a symphony is allowed to trade:

POST /api/v0.1/symphonies
  "asset_class": { "enum": ["EQUITIES", "CRYPTO"] }   // that is the whole list

// So where do options live? A different endpoint, which their own
// docs describe as: "Place manual buy/sell orders OUTSIDE of
// Symphony automation."

POST /api/v0.1/trading/accounts/{id}/order-requests
  "symbol":           { "type": "string" },   // one contract. not an array.
  "position_intent":  { "enum": ["BUY_TO_OPEN", "SELL_TO_OPEN",
                                 "BUY_TO_CLOSE", "SELL_TO_CLOSE"] },

  "required":             ["type", "symbol", "time_in_force"],
  "additionalProperties": false          // no room for a second leg

That last line is the one that matters. additionalProperties: false means the schema rejects any field it does not already list, and it does not list a second leg. The spread you want to build cannot be sent to their API at all.

You can buy an option on Composer. You cannot build a strategy that trades one. There is no delta-selected put credit spread that rolls itself at 75% of max profit, because there is no spread, and there is no automation to roll it with.

Rotation strategies are a real thing and Composer does them well. They are also the shallow end of the pool.

QuantConnect is the serious one

QuantConnect has no such ceiling. LEAN is a real institutional-grade engine. You write your strategy in Python or C#, or you hand the job to Mia, their agentic AI, who will ideate it, write the code, run the backtest, and debug her own mistakes. Either way you get multi-leg options, custom datasets, decades of history, and live deployment to a real brokerage. There is essentially no strategy you cannot express, because what you are ultimately producing is a program.

Which means you are still a programmer. Not because you have to write the code, Mia does that. Because you have to read it.

Here is the test I use. Your bot did nothing on Tuesday. You expected it to buy. Why didn’t it?

Nothing happened, so nothing was recorded. There is no row in the order log for the trade you did not make. QuantConnect’s own documented answer is to go add logging statements inside your if-blocks, re-run the backtest, and read the output. Or set a breakpoint and step through the program line by line, inspecting variables as they change.

That is a completely reasonable answer if you can code. It is the end of the road if you cannot.

NexusTrade is for everybody else

So here is the gap I have spent five years in. Composer gives you an AI and a small box. QuantConnect gives you the whole world and a compiler.

I built NexusTrade for the college student who just downloaded Robinhood, has $400 in the account, and has never heard the words “Sharpe ratio.”

I built it for the teacher who is tired of watching an unfairly small salary refuse to compound.

I built it for the finance major who can read a 10-K and cannot write a for-loop. And for the engineer who can do both, and does not want to spend another Saturday night staring at a terminal, debugging why their options bot refused to fire.

And then I refused to hand any of them a toy.

NexusTrade gives you the whole world, and you never open a file. You can trade multi-leg option spreads where the agent picks the strikes by delta and rolls them before expiration. You can walk a strategy forward through out-of-sample folds to find out whether it survives data it has never seen. And when the indicator your thesis needs does not exist anywhere, the agent goes and builds it from raw source as a reusable custom indicator. All of it runs on a Rust engine, and none of it asks you to write a line of code.

Now ask my engine the Tuesday question.

When a condition comes back false, that is not silence. It is an event. The engine writes down every rule it checked, what your threshold was, and what the market actually printed at that moment. You click it and you read it: RSI was 45.2. Your rule wanted it above 70. That is why nothing happened.

And when the signal did fire but the order still never went out, that gets its own event with its own reason. Buying power was short. The market was closed. The strategy was in cooldown. A guard tripped.

Or you can skip all of that and just ask.

“Aurora, why didn’t my NVDA strategy buy anything on Tuesday?”

She goes and reads the events herself. She finds the condition that came back false, tells you which rule blocked the trade, shows you the numbers it was comparing, and then tells you what to change if you want it to fire next time. It takes about 45 seconds.

No print statements. No breakpoints. No re-running the backtest and squinting at a log you wrote.

You should never have to be a programmer to find out why your money did nothing.

And since I just read their API, here is mine

It would be cheap of me to pull apart Composer’s public spec and never show you my own. So go look. Everything in this article is exposed over an API, and over MCP, which means you can drive the entire platform from Claude or any other agent you like. 125 tools. Build a strategy, backtest it, sweep the parameters, run a walk-forward study, deploy it to your broker, list it on the marketplace. All of it, programmatically, with OAuth 2.1 and dynamic client registration.

Nobody has to take my word for any of this. That is the point of publishing the spec.

If you already have the idea, that is the whole job: turn it into a bot that executes cleanly, try to kill it before the market does, and keep improving what survives. You can bring the idea. You do not have to.

So when I say AI trading bot, I mean a system that does all six of these:

• Find the idea. Search current events, filings, prior backtests, and public datasets. Generate several different hypotheses, then decide which ones deserve to be tested instead of polishing the first clever answer.
• Build the missing signal. When the data does not exist in the standard library, Aurora finds the source, ingests the raw material, turns it into a dated, lookahead-safe time series, and saves it as a reusable custom indicator. SEC filings, congressional disclosures, Reddit threads, internal PDFs, earnings transcripts, and public APIs can all become strategy inputs.
• Author the strategy. Combine hundreds of built-in technical and fundamental indicators with the custom indicators Aurora created. RSI, moving averages, MACD. P/E ratio, revenue growth, earnings surprises. Multi-leg option spreads with actual strike and expiration selection.
• Backtest it. Against a decade of market history for supported datasets, on an engine that models slippage, spreads, and assignment instead of pretending they do not exist.
• Try to kill it. Walk-forward validation on out-of-sample folds. Concentration audits. Parameter sweeps that tell you whether you found a real effect or one lucky corner of a surface.
• Deploy it. To a real brokerage, with real money, and keep managing the position after you close the laptop.

That closes the technical loop: bring the idea or let Aurora find one, build it, try to kill it, deploy what survives, and keep improving it after it is live.

But deployment does not solve the capital problem. A great strategy in a small account is still a small economic outcome. That is where the marketplace begins.

The best strategy might belong to the person with $1,000

Imagine a serious hobbyist who spends nights testing ideas after work. They finally build a strategy that survives out-of-sample validation and returns 40% in a year.

On a $1,000 account, that exceptional year earns $400. The same edge on $100,000 earns $40,000. The research was equally good. Capital decided whether it mattered.

They can deploy it. They cannot make it matter.

Ideas and capital rarely land in the same hands. Some people have money but no time to spend six months testing entry rules. Other people have the curiosity and the discipline to find an edge, but nowhere near enough money for that edge to change their life.

Most trading communities ask the second person to publish the exact rules for free. The creator gets likes. Everybody else gets the strategy. The person who did the work gives away the only scarce thing they produced and goes back to compounding the same $1,000.

That is a terrible incentive system.

If you want serious people to share serious work, sharing needs an upside. Give the creator a public identity, attach the idea to a real track record, keep the rules private until a subscriber pays, and turn their research into recurring income.

Now the hobbyist can earn from an idea without raising a fund or managing somebody else’s money. The person with capital can inspect the evidence and decide whether to follow it. Both sides get something they could not create alone.

A leaderboard creates spectators. An economy creates contributors. I wanted a community where good ideas have a reason to leave private spreadsheets, enter the public record, and reward the person willing to share them.

So I built the incentive layer.

You set a monthly price between $0 and $999.99. Subscribers are billed through Stripe, and the money lands in your own Stripe account without me ever touching it. What you keep depends on your plan, and it is the same rate for everybody on that plan. Nobody gets a special deal for emailing me.

Two hundred subscribers on a $29.99 bot is $5,998 a month gross. On the top plan you keep $5,698 of it. That is a hobbyist’s nights-and-weekends research turning into more money than the $1,000 account was ever going to make them, and it happens whether or not they have capital of their own.

NexusTrade is now a community with an economy. Creators contribute real, deployed portfolios with public track records. Other people can study the evidence, follow the creator, fork accessible strategies, or pay to copy a bot. When a creator contributes something valuable, the creator gets paid. You can go look at all of it right now at nexustrade.io/marketplace without signing up for anything.

What you see before you pay me a cent

Here is the problem at the center of every bot marketplace ever attempted. Show the buyer too little and they are gambling on a stranger’s ego. Show them too much and the creator has nothing left to sell, because the strategy is the product.

Most platforms solve this by showing you a leaderboard and a follow button. A number, a username, and a vibe. You have no idea if the guy in first place is a genius or just the last one standing out of ten thousand coin flips.

Here is exactly where I drew the line instead. On a paid listing, before you subscribe:

What you get Before paying All-time, 1Y, 1M, 1W returns Visible Max drawdown and Sortino Visible Whether it is real money or paper Visible Who built it, their bio, their thesis Visible How many people already copy it Visible How many strategies run under the hood Visible The positions it actually holds Hidden The rules, the filters, the entry logic Hidden

Here is my own book, embedded live. It is real money in a real brokerage account, and whatever number you see below is what it is worth right now, at the moment you are reading this sentence. It updates itself.

The Public Portfolio Challenge. Every position, every fill, in public. Any bot on the marketplace can be dropped into a page like this.

Click View full portfolio and you will see exactly what I mean. That is the buyer’s view, and it is the whole argument in one screen.

You get the return. You get the drawdown, which is the number that actually tells you whether you could have held it. You get to see whether it is real money or paper, because the badge says so and I do not let anyone hide that. You get the creator, their bio, and how many strategies are running inside.

What you get where the holdings should be is a locked panel telling you to subscribe.

What you do not get for free is the alpha, because the alpha is the only thing the creator has to sell. That is the trade, and I made it on purpose.

Execution

Two ways to use somebody else’s bot

So you read the evidence and you want in. Here is where most platforms get vague, so I am going to tell you exactly what lands in your account.

You have two options, and they are different in a way that matters. Copy trading follows the creator, so when their bot trades, yours does too. Forking hands you the strategy itself, to keep and change however you like.

Copy trading Forking Connection Continuous One-time editable copy Can you change the rules? No Yes Creator’s later strategy changes Flow to you Do not overwrite yours Best for Following a creator Learning, modifying, and building your own version

Copy trading

For stocks and crypto, the creator’s filled order is sized to the percentage of your portfolio you set. Paper portfolios fill immediately. Live orders wait in your account for approval before anything reaches your broker.

Copied options bots send real-time alerts with the contract, side, quantity, and the creator’s fill price. Multi-leg positions do not scale cleanly between accounts, so you choose whether and how to place the trade. Your own options strategies can still run fully automated.

Forking

A fork copies the strategies into a new or existing portfolio in your account. You can inspect the rules, change the entry logic, combine them with strategies you already own, backtest the result, and deploy your version. Later changes to the original do not overwrite your fork.

Paid strategies become available to fork after you subscribe. Creator-built custom data stays current while the subscription is active. If it ends, the fork keeps its last version, but new creator data stops flowing.

Without a Single Line of Code

You bring as much of the idea as you want. Aurora brings the rest.

A marketplace of AI trading bots is worthless if only quants can supply it. That is just a hedge fund with a checkout page, and we already have those. So the supply side had to work for the person with nothing, and for the person who already knows exactly what they want.

If you already have the edge

You do not want an AI to invent your thesis. You have one. You want it expressed precisely, and you want to be able to read what you built.

So nothing here is a black box. A NexusTrade strategy is a structured object, not a Python file and not a prompt. Every rule reads in English: buy 5% when the 14-day RSI drops below 30 and the P/E is under 20. Build it by hand. Or describe it and audit what the agent wrote. Or skip the screen entirely and drive the whole thing over the API and MCP from your own script. All three produce the same object, which is the part people get backwards: Composer will not let you program against your strategies, QuantConnect makes you, and I do neither. Not writing code is the default here, not the ceiling.

No language model decides your trades. Aurora authors the rules. A Rust engine executes them, deterministically, the same way every time. Your bot does not improvise. It evaluates the conditions you approved and writes down what every one of them returned, which is why it can tell you that RSI was 45.2 when your rule wanted 70. If you want an agent thinking inside the loop, you attach one on purpose, and even then it cannot put a live order through without your thumb on it.

Bring your own data, too. Drop a spreadsheet straight into the chat, or point the agent at a source nobody sells and let it go get the thing itself. Either way it comes back as a lookahead-safe custom indicator that drops into a rule exactly like an RSI does.

Or you can show up with nothing

The other end of the spectrum is a single sentence, and it is the kind of thing anybody would type.

You:  Make me a trading strategy based on Nancy Pelosi's stock trades.

// That is the whole prompt. Aurora shows you a plan and waits
// for approval. Then, without being asked, it does all of this:

→ Goes and finds the congressional disclosure filings
→ Dates every trade by when it was disclosed, rather than when it
  happened, so the backtest cannot peek at information you would
  not have actually had on the day
→ Turns that into a reusable, lookahead-safe custom indicator
→ Authors the strategy as structured rules
→ Backtests it across a decade
→ Walks it forward through out-of-sample folds
→ Comes back and tells you whether the thesis actually survived
→ Deploys a paper bot only if it did

// And if you want it watched after that, you just say so:

You:  Keep an eye on it.

→ Attaches an agent to the portfolio that monitors performance and
  wakes up on a schedule, or the moment a market condition fires

You did not know to ask about disclosure dates. You did not know what lookahead bias was, or that it is the single easiest way to build a backtest that lies to you. That is the entire job. The agent is supposed to know the things you do not.

Go further and you can hand her the whole job. Tell her you want good risk-adjusted returns and that you have no idea where to start, and she goes hunting for the thesis herself. She does not hand you her first clever answer, either. She generates several structurally different hypotheses, builds every one of them into a real portfolio, and makes them fight. Weak ideas get dropped. Only the survivors earn the expensive treatment, the parameter sweeps and the out-of-sample folds. SPY sits in the bracket the whole time, because an idea that cannot beat just buying the index is not an idea.

Sometimes she comes back and tells you nothing survived. That is a feature. Brainstorming is cheap, and an agent that always finds you a winner is an agent that is lying to you.

And she does not leave when the bot goes live

LaunchAgent is a portfolio action, sitting alongside buying, selling, and sending an alert. Attach it to a paper or live portfolio, give it a task, and pick the schedule or the market condition that wakes it up.

Portfolio:  Core Portfolio
When:       Every Monday at 9:35 ET
Action:     Launch Aurora
Task:       Review this portfolio. Find new ideas that diversify its
            current risks. Research several mechanisms, backtest the
            strongest candidates, and report what survives.

The point is bigger than scheduling. The agent becomes part of the portfolio’s logic. The condition decides when Aurora wakes up. The task decides what problem she owns. She can hunt for new mechanisms, investigate a drawdown, or audit the risk you are carrying, on Monday morning or the instant the market does something you told her to watch for.

You never see JSON and you never write code. From one prompt, you get a portfolio you can inspect, backtest, edit, deploy to a real brokerage, and put up for sale.

And she can shop the marketplace for you

Sometimes the research is original. Sometimes somebody else already built it. Aurora has nine tools pointed at the marketplace, so she can search creators, pull up a profile, read a bot’s numbers, fork the strategy into your account, and set up copy trading, all from chat.

You can hand her either job in one sentence:

“Find the best performing bot from a verified creator, show me its drawdown, and set up a paper copy at 25% of my capital.”

Or

“Find the strongest congressional trading bot, fork it into my account, and backtest the version you would actually deploy.”

On the copy path, she comes back with the numbers and a paper portfolio already following the creator. On the fork path, she comes back with an editable portfolio and a backtest of the version you now control.

I redesigned the whole app around it

Sign up and you get one question: copy, or create? Copy drops you into the marketplace to pick a real bot with a real track record. From there, you can follow the creator or fork the strategy into an editable portfolio of your own. Create hands you to Aurora. Both roads end with a working paper bot in your account, and you only connect a brokerage when you actually want real money on the line.

Two doors, and the top-performing real bot on the marketplace showing its live numbers next to them.

And the landing page counts instead of claiming. Three numbers, pulled live from the database: registered users, backtests run, agents created. As I write this, that is 34,228 people, 337,989 backtests, and 11,450 agents.

If those numbers ever go down, they go down in public.

Go look at it

Browsing is free and does not need an account. Copying a free bot into a paper portfolio or forking its strategies into your account costs nothing. Neither action puts real money at risk unless you later deploy it live.

Go copy something into paper and watch it for a month before you trust anybody. Including me.

Because Vlad Tenev is going to be right eventually. Every capability a human has is going to be available to an agent, and everyday people are going to end up with the tools that used to live inside high-frequency trading firms. He said it on CNBC, and he will probably get most of the credit for it.

Fine. I would just like the record to show who let you sell.

The app store of AI trading bots is open.

NexusTrade Community Portfolios

See the original article at nexustrade.io

Introducing the new NexusTrade, the world’s first agentic trading marketplace was originally published in Artificial Intelligence in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.