Introducing the new NexusTrade, the world's first agentic trading marketplace

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.

Definitions

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 Incentive Problem

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.

nexustrade.io/marketplace. Browse it without an account. The passive income calculator below the fold does the math on your own numbers.

Buying

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:

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.

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

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."

"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.

The Rest of the Rebuild

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.

NexusTrade is a research and automation platform, not a financial adviser, and nothing here is investment advice. Historical and backtested performance does not guarantee future results. Bots listed on the marketplace are built by independent creators, are not vetted for profitability by NexusTrade, and may lose money. Live copy trading orders are staged for your approval and are never sent to your brokerage without it. Trading involves risk of loss, including total loss of capital.