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.