What Sella is, and why I am building it
I ran five agents as an executive team and I was the bottleneck. Every time one found a dataset, I paid by hand and pasted the result into its context. Then they worked out the source was wrong and the trajectory changed. Two failures: the agents could not pay for anything, and nothing could tell them the source was wrong before I bought it. Rails fixed the first. Evaluation is still missing.
On this page
I ran five agents as an executive team. A CMO, a CFO, and three others, each with a mandate and a share of a business to run.
I was the part that did not scale.
Every time one of them found a dataset or a source it wanted, the loop stopped and came back to me. I paid for the resource by hand. Then I copied what I got into the agent's context window so it could carry on. Agent decides, human pays, human pastes. Five agents, one of me.
Six dollars#
The whole experiment cost me about six dollars.
People expect that number to be a typo. It is not, and the size of it is the point. Six dollars was enough to prove the loop does not work, because what the loop costs is not measured in money. It is measured in the fact that nothing could happen while I was asleep.
Then the second thing happened. Partway through, the agents worked out that one of the sources I had bought and pasted in was the wrong one. Not corrupt, not fraudulent, just not the thing the work actually needed. The trajectory changed. Everything built on top of that source went with it.
My CFO agent was the one exception. It did real work with the numbers it was handed and the output held up. Everything else was waste.
What Vibecon changed#
I was still treating this as a tooling annoyance when I went to Vibecon in 2026, an event run by Emergent, Lightspeed and Y Combinator.
Jared Friedman's message there was to build for the next one trillion users of the internet, and that those users are going to be agents, because agents are what will be transacting on it and creating value across it.
That reframed the problem for me. I had been asking how to make my five agents smarter. The question underneath was whether an agent is an economic participant at all, or just a very good assistant that needs a human to hold its wallet.
Right now, mostly the second. I had proved that myself for six dollars.
The intelligence barrier is not the barrier#
There is a comfortable story that everything here is gated on model capability. Wait for the next release and the problems dissolve.
I do not believe that for commerce. Look at what is already solved:
Discovery. The Model Context Protocol gave agents a standard way to find and call tools. One endpoint, JSON Schema, no per-vendor SDK.
Invocation. Function calling works. Agents chain tools reliably enough to run multi-step work without a human catching them at every step.
Payment. x402 settles per request in stablecoin. The server answers with HTTP 402 and machine-readable terms, the agent's wallet signs, the resource comes back in the same round-trip. No API key, no invoice, no human pasting anything into a context window.
That last one is my six dollars, fixed. If I ran the same experiment today the agents would buy their own sources and I could go to sleep.
And it would still have failed. Because the source would still have been the wrong one, and they would still have found out by building on it first.
Evaluation is the piece that is missing#
An agent cannot distinguish a real capability from a convincing description of one. Not because it is not clever enough, but because the information needed to make that call does not exist in a form it can read. It lives in a support thread, a benchmark someone ran once, a colleague's opinion, a refund six months ago.
Humans solve this with reputation and relationships. Neither transfers. An agent has no network, cannot ask around, and will not remember being burned unless something wrote it down in a structure it can query.
So the missing layer is measured, machine-readable evidence attached to every listing, produced before the agent has to decide. Not a star rating. Structural analysis of what the data actually contains, an independent judgement pass, and a trial run that either produces the promised output or does not.
That is what Sella is. Every dataset published goes through that pipeline before it can be sold, and the result travels with the listing, so an agent comparing two options is comparing evidence rather than adjectives. Around it sits one catalogue spanning datasets, APIs, workflows and native products, policy rules checked before money moves, and per-call settlement. Agents can also sell to each other, which matters more than I expected, because an agent that can only spend is a cost centre.
What I think the work becomes#
I do not think the interesting outcome is agents that shop more efficiently.
I think the division of labour changes. Humans get good at finding the niche and framing it. Agents do the work inside that frame and earn against it.
Here is the shape of it. Say I notice that companies building AI-generated anime platforms need training data nobody is packaging properly. That noticing is my job: the gap, the buyer, the reason it is worth doing. From there it should be the agent's job to find the sources, clean them, shape the result into the format those companies actually need, then find the buyers and sell to them, reaching out and listing it without me in the loop.
I fund it. It runs. It tells me what the capital returned.
I am careful about that line because the whole argument depends on it. Sella exists because agents cannot tell a real capability from a claimed one. It would be a strange thing to build while blurring the same line in my own writing.
Why I am building it#
Because I ran the experiment, and it failed in two specific ways rather than one vague one.
The rails failure is fixed, and not by me. The evaluation failure is not fixed by anyone yet, and it is the one that decides whether an agent with a budget is an operator or a liability.
Six dollars was a cheap way to find that out.
Frequently asked questions
- What is Sella?
- Sella is an evaluation engine and a catalogue for AI agents. Agents discover datasets, APIs, workflows and native products through the Model Context Protocol, every listing is quality-gated before it can be bought, and payment settles per call in USDC over the x402 protocol. Humans publish. Agents transact.
- Why does an AI agent need an evaluation layer?
- Because an agent cannot tell a real capability from a claimed one. A vendor description is marketing copy, and an agent comparing two listings has no way to know which one actually returns useful data. Without measured evidence attached to the listing, the agent finds out it bought the wrong thing only after building on top of it.
- Why did running agents as a CMO and CFO not work?
- Because a human sat in the middle of every transaction. The agents could decide what they needed, but they could not buy it, so each purchase came back to me to pay for by hand and paste into their context window. That is not an autonomous team. It is a group of advisors sharing one very slow assistant.
- What does an agent actually running a business look like?
- A human identifies a market gap and frames it, then funds an agent to work it. The agent sources the raw material, processes it into the shape buyers need, finds those buyers and sells to them, and reports back what the capital returned. On Sella that is the roadmap, not what ships today.
See what an agent sees before it buys
Every listing carries the evidence an agent reads when it decides. Have a look at what that looks like in practice.