Article Overview
In August 2026, a small open-source project called treg launched with a blunt pitch from its creator: "OpenRouter for tools." Old world, in their words: SaaS bundles priced for humans, $139 a month, and you don't even know what's in the box. New world: agents don't care which vendor supplies a capability, only which one does the job, and they'll pay for the result rather than the seat.
That's a specific, checkable claim about a specific product, not a trend piece, and it's worth taking seriously precisely because it's specific. treg catalogues around 2,600 API endpoints across roughly 40 providers, reachable through one token and one address, billed per call from about a cent. What it actually does, and what "OpenRouter for tools" really means, tells you something concrete about software built around how a business already works rather than around a subscription model built for a person.
Key takeaways
- 01treg is a real, working example of a pattern, not a hypothetical: roughly 2,600 catalogued API endpoints across about 40 providers, reachable through one token, billed per call from about a cent.
- 02"OpenRouter for tools" means the same thing OpenRouter does for language models: one address in front of many providers, so an agent doesn't need a separate account, contract and integration for each one.
- 03Your own credentials always take priority over treg's, and it never models the upstream service, only relays to it, which is why an integration built this way keeps working after the underlying API changes.
- 04Spend is capped by design. A request that would exceed the prepaid balance is refused outright, with the exact cost shown, rather than silently billed.
What does "OpenRouter for tools" actually mean?
OpenRouter is a service that sits in front of dozens of AI language models, so a developer can call one address instead of setting up a separate account with every model provider. treg applies the same idea to tools rather than models: one base URL, one token, and the request gets routed to whichever of the roughly 2,600 catalogued endpoints it names. That routing layer is the part that changes how AI agents use tools in practice.
The catalogue spans several practical categories rather than one narrow use:
- Keyword and rank tracking
- Backlinks and domain authority
- AI visibility monitoring
- Trending topics and discovery
- Social publishing
- People and company enrichment
- Ads management and creative
- Measurement and analytics
An agent working a sales lead can look up a company, check its backlink profile, and post a follow-up, all through the same connection, without three separate vendor relationships behind it.
A deliberately small catalogue is also better than it sounds. Anthropic's engineering team, writing about building tools for agents, notes that more tools don't always lead to better outcomes, and that a few thoughtful tools targeting specific high-impact workflows beat exposing everything a system can do. How AI agents use tools well is mostly a question of how few, well-described choices they're given.
Whether this particular project is still running in three years isn't really the point. It's a working demonstration of what "pay for the capability, not the seat" looks like once someone actually builds it, and that's worth understanding on its own terms.
How AI agents use tools through treg, step by step
Every request goes through a single call, and treg resolves what to do with it. It works out which tool the request is for, applies credentials, sends it to the real provider, and records what happened. Nothing about the underlying service is reproduced or guessed at: treg's documentation is explicit that it "relays, never models" the upstream provider, which means it forwards the request rather than trying to imitate the destination.
Credentials follow a clear order of priority. If your business has already registered its own key with a provider, that key is used first. If not, a team-stored secret is used. Only if neither exists does treg fall back to its own key and bill the call to your balance. Whichever path is used, the credential is added on the way through and the agent calling it never holds the key itself.
That detail matters more than it sounds like it should. An integration built to call a specific version of a specific API breaks the moment that API changes. One built to be handed a request and get a result back is far more durable, because the provider can change what's behind the door without the agent needing to know. Brittle integrations are a recurring theme in the problems we end up working on, and they are expensive precisely because they fail quietly.
What does the pricing actually control?
Money, deliberately and visibly. New teams get one dollar of free credit to start. After that, every call is metered against a prepaid balance, and a request that would exceed it doesn't quietly go through and land on next month's invoice. It's refused outright, with the exact cost of the call and a link to top up shown in the response, so the agent (or the person watching it) knows immediately what happened and why.
That is a genuinely different shape of control than a subscription. A subscription caps nothing; it just resets the meter every month regardless of what got used. A hard stop at the balance means the worst case for a misbehaving agent is the balance running out, not a surprise bill. For a business testing whether any of this is worth doing, that ceiling is most of the reason the experiment is safe to run at all.
What does this change for a business that isn't a software company?
It changes what testing an idea costs. Connecting a system to a new capability used to mean a vendor call, a contract, a subscription, and a developer's time before you knew whether it was worth having. Most of that cost happened before anyone learned anything.
With a model like this, checking whether an agent can usefully enrich a supplier list, or watch a competitor's social posts, or pull a company's basic details before a sales call, costs a few calls at a fraction of a cent each. Testing a large batch and abandoning it if it isn't useful costs less than the meeting where someone would otherwise have proposed a pilot. That shift, more than any specific feature, is what changes the build-or-buy decision for a business connecting systems it already runs rather than replacing them outright.
What has to be true before any of this works for you?
Three things, and none of them is about the technology.
Your systems need somewhere to be reached from.
A modern cloud tool almost always has one. Older, on-premise software often doesn't, and building that connection is the first real piece of work, not a reason to abandon the idea.
Someone has to decide what an agent may do.
Read access is a different decision from write access, and spending money is a different decision again. Most of the trouble reported with agents traces back to this being left undecided, not to the technology failing.
Someone owns it when it gets something wrong.
A wrong draft a person reviews before it goes out is cheap. A wrong payment isn't. Sorting the work into those two buckets before you start is most of the actual risk management.
What is still genuinely hard?
Plenty, and it's worth being straight about it rather than only describing what works.
Reliability is uneven. An agent that handles a task correctly forty-nine times will do something odd on the fiftieth, with complete confidence and no visible sign anything's different. That's manageable when a person reviews the output and unmanageable when nobody does.
The audit question isn't fully solved either. If an agent acted on your systems at 2am, you want a clear record of what it did and why. Some setups produce that record well. Many don't, and a business tends to find out during an audit rather than before one.
And the provider itself is new. Registries built this way are early businesses, treg included, and some won't be running in three years. That's a reason to keep whatever logic actually matters to your business in something you control, rather than assuming any single provider will still be there.
None of this makes the pattern a bad bet. It makes it a bet worth placing on small, well-chosen work first, the same way you'd trial any new supplier before handing them something that matters.
Conclusion
treg is one project, and it may not be the one still standing in a year. What it demonstrates isn't disposable: connecting a business's systems to outside capability no longer has to mean a vendor contract and a subscription before anyone learns whether the idea works. It can mean a token, a call, and a bill measured in cents.
The "$139 a month and you don't know what's in the box" line from its launch is the part worth remembering. Most businesses are carrying at least one subscription like that, kept because cancelling feels riskier than continuing, and priced for a human seat that software increasingly doesn't need. Per-call access doesn't replace all of it, but it makes the question askable for the first time: what is each capability actually worth to us, on its own, by the use?
The practical move is unglamorous. Pick one task that would benefit from reaching an outside capability, one where a mistake is visible and cheap to reverse. Check what it would actually cost to test, by the call rather than by the year. Try it for a real task before deciding anything bigger.
If you want a second opinion on which task in your business is worth testing this way, book a conversation with us and we'll work through it with you.
Frequently asked questions
What is treg?
treg is an open-source registry, launched in August 2026, that gives an AI agent access to roughly 2,600 API endpoints across about 40 providers through a single token and address, billed per call rather than by subscription. Its creator describes it as "OpenRouter for tools."
How AI agents use tools through a registry, in plain terms?
OpenRouter is a service that sits in front of many AI language models so a developer can call one address instead of many. treg applies the same idea to tools: one connection in front of dozens of providers, so an agent doesn't need a separate account and integration for each one.
Do I need to replace my existing software to use AI agents this way?
Usually not. This model connects to capabilities you don't already have rather than replacing systems you do. Your existing software stays as it is; what changes is how cheaply a business can test whether a new capability is worth adding.
How much does it cost to try this?
Very little. treg's per-call pricing starts at about a cent, with new teams given one dollar of free credit. The real cost of trying this is the time spent deciding what a task actually needs, not a software budget.
Is it safe to let an AI agent spend money on API calls automatically?
With the right limits, yes. A hard prepaid balance, like the one treg uses, means a request that would exceed it is refused rather than silently billed, so the worst case is the balance running out. Set that kind of ceiling before giving any agent the ability to spend.
Usually a reply within one working day.
