MENU
So I wanted to see how far an H Company agent could get on a job that costs money to do properly. I gave it one task, check whether a product has been recalled, and I let it pay for the data itself through the Nevermined catalog. H Company builds agents that act, they drive a browser, a desktop, write code, so the agent part was never the question. What I wanted to see was the part an agent normally cannot do on its own, which is pay for an outside service it needs.
Here is the whole thing as a short demo: the outcome I asked for, the agent I built on H Company, and a run where it pays for its own data and writes the answer.
I built an agent on H Company's Agents API and gave it the Nevermined catalog as its tools. Then I handed it a product, a Peloton Tread+ treadmill, and asked it for a recall check. On its own it searched the catalog for a recalls service, paid for one lookup, and got back the real recall the United States consumer regulator issued for that treadmill in 2021, the one that followed a child's death and more than seventy reported incidents. Then it paid for a model to turn that record into a short risk brief, with the hazard, the remedy and the source. I never signed up to a recalls provider, and I never pasted a model key. I described the result I wanted, and the agent bought the pieces to produce it.
An H Company agent is good at doing things. The thing it cannot do by itself is pay for an outside service, because that is not something its runtime has a way to do. Today you work around it, you give the agent your own account and key for every provider it might touch, one at a time. For a recall check that means a recalls data provider and a model, each with its own signup, its own key and its own invoice, before the agent does anything useful. The catalog is the part that was missing. It gives the agent one way to find a service, pay for one call, and move on, so the agent can finish a job that costs money without me wiring up a vendor for it.
The Nevermined catalog is a single place that already lists the services an agent might want to buy. When I counted on 2026-10-27 it held around 160 of them across categories like web search, company and funding data, scraping, recalls and models. Every one is already set up to be paid per call, so I do not open an account with any of them. I hold one key, I set one budget, and the agent asks the catalog when it needs something. The catalog takes care of finding the service, pricing the call, and paying for it. Discovery is free, so the agent checks what is live on every run instead of trusting a list I hard coded.
On H Company you do not draw a workflow on a canvas, you save an agent and run it. So the whole build was three steps, and none of them was code.
First I created the agent through H Company's Agents API, one call that saves it by name. It is the recall-checker you see here, a name, a one-line description, and a set of instructions that tell it how to do the job.
The instructions are the part that matters. They give the agent two tools from the catalog and nothing else, one to discover a service and one to pay for a single call. Then they describe the job in plain terms, look the product up in a recalls service, pay a model to write the brief, and report what it paid. The agent never holds a key and never settles a payment itself, the catalog tools do that, and a call that fails is refunded.
Second I pointed those tools at the Nevermined catalog. That is one address and one key, the same Catalog MCP that every other integration uses, so there was nothing H Company specific to wire. From that point the whole catalog is available to the agent as tools it can call, search for a service, get a quote, pay, and check what is left of the budget.
Third I ran it. On H Company's platform you start a session against the saved agent and give it the product, and it takes it from there.
On this job the agent called the catalog twice, not once. First it searched for a recalls service and paid for the lookup that found the Peloton record. Then it searched for a model and paid for the one call that wrote the brief.
You can watch it happen in the session. The agent writes a short plan, calls the paid tool, and the catalog returns a settled result, one call at a time, all against the budget.
The run finished with a sourced brief that rated the treadmill a high risk, named the active recall, and linked the regulator's notice. Two paid calls, one deliverable, and no provider I had to onboard first.
An agent that spends money needs a limit that it cannot argue with. I set the budget on my Nevermined account, not inside H Company, so the agent has no way to raise it. When the budget is spent the calls stop, and I can revoke it in one action. Discovery keeps working either way, so the agent can still look, it just cannot buy past the cap. For something that acts on its own, that cap is the part I actually watch.
The agent was the easy part, because the hard parts, finding a service, paying per call, keeping a tally against a budget, already live in the catalog. One product, one budget, one saved agent, and I get a sourced recall check that paid for itself. I built two more outcomes the same way, a lead qualifier and an agent that buys its own research, and the shape does not change. If you want to see the services an agent can reach before you build anything, the catalog is public.
If you want an agent that can pay for the services it needs, start with the Nevermined catalog.
See Nevermined
in Action
Real-time payments, flexible pricing, and outcome-based monetization—all in one platform.
