make money selling to ai agents (FULL GUIDE)

there's a lot of money in building for agents right now. software is changing. more and more, agents are the ones using it. they research, they buy, they run the tasks a person used to click through.

and an agent only chooses a product it can actually use, and the business running it pays every time.

this guide shows you how to build for that, end to end. what you're actually building, how to find the idea, how to build it, and how to get agents using it and paying for it.

by the end of this guide you'll have:

• a clear picture of what an agent-callable product actually is

• a research step that tells you what agents need in a niche

• an api endpoint built with claude and live on a url

• docs written so an agent can use it without you

• a key, a cap and a receipt so you get paid per call

• a listing where agents already look

what you're actually building

an api endpoint. that's really it.

an endpoint is a url. an agent sends a request to that url with some information, your code does something with it, and sends a result back.

so a product for agents is a url that does one useful thing. here's what that looks like for example:

a url that takes a city and a trade and sends back a clean list of every business that fits, with contact details. a url that takes a product name and sends back the last three months of what people said about it online. a url that takes a company name and sends back who runs it and how to reach them.

each one is a single job with a clear input and a clear output. an agent doing a bigger task hits that url when it gets to that step, uses the result.

that's basically the whole product. a url, the code behind it, and docs that tell an agent when to call it and what it gets back.

why an agent pays for it

an agent is a model with tools. when it gets a task, it looks at the tools it has and picks the one whose description matches.

the business running that agent wants the task done well. if your endpoint does one step of the task better than the model can alone, the agent uses it, and the business pays per call. they're paying for that step to be right.

what's worth building is two questions. does this make the business running the agent more money. and is it too narrow for a frontier lab to build into the next model.

summarising a document fails the second one, every model does it. finding every owner-led roofing company in a county with their owner's email passes both. a roofer's agent needs that list, no lab is really building it, and the roofer pays for the leads it produces.

the narrower the job, the safer it is, and the more the business that needs it pays per call.

the research step

scrape what's out there, ask claude what to build, pick one.

scrape what agents and businesses are already asking for

the demand is visible in two places.

the skill registries show what people are building for agents and what's missing. skills.sh, agentskills.io, clawhub. search a niche and see what's there. you should find one with almost none, where you know businesses pay for that job, that's the gap.

the communities show what businesses pay people to do. the subreddits and forums for a niche, the job boards, the freelance briefs.

apify has scrapers for all of those, and claude can run them through the apify mcp.

ask claude what to build

now you hand that file to claude and ask it what an endpoint should do.

pick one

take the top of claude's list and check it against these:

you can get the data. if the endpoint needs a source you can't reach, it's not the one.

you can explain it in one sentence. address in and list out. if it takes a paragraph, it's two endpoints.

a business would notice if it stopped working. if their agent would just skip the step, there's no money in it.

if you already do this, by hand or in a pipeline, that's kinda the one. you know the input, the output and what it's worth.

building it with claude

you don't write the code yourself. you describe the endpoint and claude builds it. it deploys on vercel or railway.

build the endpoint

the sandbox lets an agent try your endpoint before its owner pays.

write the docs for an agent

the docs are basically the product. an agent reads them to decide whether to call you and how. there's no person in the loop to work things out from context.

the "use when" sentence is important. it's what the agent reads when deciding between your endpoint and doing the job itself.

the key, the cap and the receipt

these are the three things that turn an endpoint into something you get paid for.

the key. every business gets one. it's in the header of every request. no key, no result. the key is per business, because the business pays and an agent might be spun up fresh every run.

the cap. a spend limit on the key, per day. when it's hit, the error says it's the cap, what the cap is, and who can raise it. an agent with a card and no cap might spend the whole card.

the receipt. one line per call. the time, the input, the result, the cost. that's what the business owner reads when they check what their agent spent.

marketing it

go where the agents already look.

agents find tools by searching the registries. skills.sh, agentskills.io, clawhub. you list your endpoint there as a skill, which is a short markdown file that tells an agent what your endpoint does and how to call it.

the listing needs a name, the description, a category, the inputs and an example output. the category matters because it's how an agent narrows a search. pick the one that matches how the task would be described.

everything happens without you being in the loop. an agent searches, reads the description, decides it matches, and starts calling you. so the number of installs measures how well the description matches real tasks.

if there's no registry for your niche yet, make one. a single page listing your endpoint and any others you know of, and agents searching for tools in that niche can land on you first.

the harnesses

hermes, claude code and the others each have a way to add tools. getting your endpoint into a harness as a default is the biggest win, because every agent on that harness reaches for you first.

find who maintains the harness, show them an agent calling your endpoint and getting a clean result with the receipt.

and tell the people who build agents. the discords and communities for hermes, claude code and the others are full of people looking for tools to plug in.

the page

when a model has no tool for a task, it searches online for one, the same way a person would. so your endpoint gets one page. the "use when" sentence at the top, in the words a task would use rather than the technical name. the example call and result under it. the link to the docs and the registry listing.

write the page for search. the title is just the task in simple words, the url has the task in it, and the first sentence says what comes back as the output. agents search the same way people do.

the page is also your landing page. a business owner who hears about the endpoint lands there, reads the "use when" line, gets a test key, and gives it to his agent.

that page is basically what the model reads when it searches.

getting paid

start with per call. the agent pays every time it calls. but once you have receipts, you can move to per result, where they only pay when the call produced something usable, or monthly per business for unlimited calls.

what stays manual

claude builds the endpoint, writes the docs, writes the listing, adds the billing. you do three things.

• the price. that's a decision about the business.

• the approval to publish. once it's listed, agents start calling it.

• the first three support conversations. the questions the first callers ask are the docs you might not have added yet.

where to start

pick one job you already do or you're familiar with. an input, an output, and a business that pays for the output.

describe it to claude and have it build the endpoint. get the url.

call it yourself, from your own agent, until the docs are right.

then add the key, the cap and the receipt. then list it where agents look.

then the second endpoint, built the same way.

hope you have fun setting this up.

join here for more value: https://t.me/+pbCBBtUEtu1lZDA1