MENU
Your agent is one prompt away from doing real multi-service work, not just talking about it. The Catalog lets it reach a whole shelf of independent AI services, use the ones a job needs, and pay for each call, without you wiring anything up or blowing past a budget you set.
AI is great at answering things. Where it gets stuck is doing things that take more than one service.
Picture a normal task: research something across a few sources, generate an image, transcribe some audio, and pull it all into a report. That’s four different services. Normally that means four signups, four API keys, four separate bills, and no clean way to know what the whole thing will cost until it already has. Your agent can happily call an API; it just can’t go and line up all those services for you, hand each one the right request, and keep an eye on the spend while it works.
That last part is the wall almost everyone hits. The model is smart enough. The problem is everything around the model: accounts, credentials, mismatched formats, and a bill you only understand after the fact. So a lot of genuinely useful ideas die at the integration step, not the AI step.
The Catalog is the piece that gets you past it.
It’s one place your agent can reach for independent AI services and actually use them. You connect your agent to it once. After that, a single prompt is enough: the agent works out which services the task needs, calls them in the right order, and pays for each one, all inside a budget you set beforehand.
Think of it less as a directory you browse and more as a layer your agent talks to. You describe a result; it figures out the path to that result and walks it. You don’t wire anything up, and you don’t babysit it while it runs.
There are two halves here, and it’s worth knowing which is which. The Catalog is discovery: it knows what’s out there, what each service is good at, and what it charges. The Router is payment: it takes the call your agent wants to make, reads the service’s payment challenge, pays it, and keeps the running total inside your budget.
The part that surprises people is that those services never integrated with Nevermined. The Router speaks the payment protocols they already use, so your agent can pay a service that has never heard of us. It never holds a private key, never learns a protocol, and never opens an account with the thing it just paid.
Here’s how the work splits, and it’s the interesting bit.
The Catalog side.
It finds the services. You say what you want as an outcome. The Catalog knows what’s out there and which services fit that kind of task, so you don’t have to spell out “use this one, then that one.” It works it out.
It picks good ones. Plenty of services can do a job; that doesn’t make them the right pick. The Catalog weighs what each one is good at, how well it does it, and what it costs, so your agent lands on something that fits the task and doesn’t overspend to get there.
It moves the work around. Requests go to the right service and come back, in the right order, and when one step’s output is the next step’s input, it carries that across for you. The messy bit between “I need this transcribed” and “here’s your transcript” is handled.
The Router side.
It watches the spend. You set a budget once. It’s enforced server side on every single payment, so an agent can’t go past it by looping, by retrying, or by being wrong. You know the ceiling before anything starts, and no bill surprises you later.
It pays as it goes. No checkout, no “approve this charge” popup mid-task. Each service gets paid automatically, so the job runs start to finish without you clicking through anything.
A lot of what usually eats an afternoon just isn’t your problem here:
The Catalog handles that layer, so you can think about the result instead of the wiring. No pile of vendor accounts to babysit; you say what you want, and the agent goes and gets it.
This is the part that feels different. You don’t start with a list of APIs and figure out how to bolt them together. You start with the thing you’re trying to get done, and the Catalog works back to the services that can do it. Those are the Catalog Outcomes: a task, already matched to what it takes to finish it.
Less “here are the parts, good luck.” More “here’s what you wanted.”
Easiest way to get it is to watch one. In the clip below, an agent takes a plain-language prompt all the way to a finished result: finding the services it needs, paying for each, and handing back the output, staying inside a budget the whole time, with no clicking after that first prompt.
It’s a few independent services being found, used, and stitched into one result, for well under a dollar. The task here happens to be turning a live news headline into a short song with cover art, mostly because it’s fun to watch, but it’d look the same for anything real: research, media, data, code. It’s the same machinery behind the Apple example below; one’s playful, one’s the kind of thing you’d actually put in front of a colleague. The song isn’t the point. The point is the agent did the whole thing from one prompt, on a fixed budget, with no signups and no checkout.
Here’s a real one. Say you want an earnings evidence pack on Apple, the kind of thing an analyst would otherwise assemble by hand from a few different data sources:
For Apple (CIK 320193, AAPL), create a sourced Markdown and JSON earnings evidence pack with the latest 10-K or 10-Q accession, recent XBRL facts, filing search hits, quarterly EPS and income figures. Pay through the Nevermined Catalog and Router, keep missing data explicit, and stay within a $1 budget.Read that back and notice how much is packed into a few lines, and how little of it is your problem to wire up.
What comes back is a tidy Markdown-and-JSON pack with its sources attached: the accession numbers, the facts, the figures, with any holes clearly marked. From one prompt. No dashboard, no integration work, no month-end surprise on the invoice.
Letting an agent spend money on its own sounds a little nerve-racking. It isn’t, because you’re the one who sets the limit and it can’t go past it.
You pick the budget before anything runs. When it’s used up, the agent stops, and that’s it. Every charge is tracked along the way, so you can look back and see exactly what got used and what each bit cost. Nothing hidden between “I gave it a dollar” and “here’s the result.” If a run comes in under budget, you see that too.
You don’t have to move anywhere new. It connects over MCP, so whatever local harness you work in (Claude Code, Codex, or any other MCP client), the Catalog fits right in. If you’d rather use a web AI like ChatGPT or Claude on the web, it works there too. Same Catalog either way; your agent just gains a set of services it can reach and pay for on its own.
It’s handy the moment a task needs more than one service and you’d otherwise be the one gluing them together.
If you build agents that have to produce something, a report, a media asset, a data pack, a working deliverable, this is what lets them reach for the tools a job needs without you pre-wiring every one. And if you keep running into “the AI could do this, if only it could use that other service,” that’s exactly the snag it clears. You stop thinking about which providers to sign up for and start thinking about what you actually want back.
Open the Catalog, pick an outcome, and point your agent at it. Set a budget and let it run.
One thing worth knowing before you start: the Catalog runs on live services, so there’s no sandbox to rehearse in. Begin with the cheapest sub-cent service and a low cap for that first run. You’ll open a link once to approve the spending cap, and after that your agent runs on its own.
Watching an agent finish a real, multi-service task from a single prompt, and show you what it spent, tends to land better than reading about it.
See Nevermined
in Action
Real-time payments, flexible pricing, and outcome-based monetization—all in one platform.
