One Key, Every Tool

Why does an AI agent cost more to equip than to run?

Because the tools it needs are priced for people, not for tasks. Semrush wants around a hundred and forty a month. Moz and Crunchbase around a hundred each. Apollo charges per seat. Your agent needs each of them for about nine seconds a week.

So you either buy six subscriptions you barely touch, do the work by hand, or spend days on OAuth setup for an API you will call twice.

Treg exists because a team hit this themselves. It carries the accounts, exposes the endpoints through one token, and bills per call. The catalog covers keyword and rank tracking, backlinks and authority, AI visibility, trending and discovery, social publishing, people and company enrichment, ads management, and measurement.

The comparison people use is OpenRouter. That routes between AI models. This routes between the specialist tools those models need to do anything useful.

1. The repository

Code: github.com/superdesigndev/treg

Hosted version and dashboard: treg.to

Licence: Apache 2.0 with additional terms. The readme states it plainly: use it freely including commercially inside your own organisation, and self-hosting your own registry is encouraged, but you may not offer it to third parties as a hosted or managed service, or embed it in a commercially distributed product, without written permission.

Read that last part carefully if you plan to build something on top of this and sell it. Using it to run your own business is explicitly fine. Reselling access to it is not.

2. What it actually is, in plain terms

Three ideas and the rest follows.

A catalog you search by job, not by vendor. You do not look for Hunter. You ask for "find a work email" and it shows every provider that can do it, with the price and the measured success rate side by side. Nineteen providers sell backlink data. Nine sell email lookup. You see them together.

One token instead of many accounts. Your agent holds a single credential. Every tool in the catalog answers to it, and revoking it revokes everything in one place.

Your secrets stay off your machine. The real credential is injected on the server side when a call goes out. The agent never sees it and neither does the person using it.

One thing worth being precise about, because it is a design decision rather than a limitation. Treg shows the options with prices and measured performance, and the choosing is yours or your agent's. It does not silently pick a provider or fail over to a different one. That means no surprise vendor swaps mid-workflow, and it also means your agent has to handle a provider being down itself.

3. Before you start

A terminal. The plain window where you type commands. Everything here is one line you paste.

An AI agent. Claude Code is the smoothest path because there is a plugin. Cursor, Codex and anything else supporting skills will work.

A GitHub account. Sign-in defaults to GitHub, with email codes available instead.

There is no provider account to create, no API key to generate, and nothing to configure before the first call.

4. Setup, four routes

Route one: the Claude Code plugin

Two lines inside Claude Code:

/plugin marketplace add superdesigndev/treg
/plugin install treg@treg

It installs with no token and no configuration. On first run it walks your agent through the rest, meaning the command line tool, signing in, and connecting the tools. You end up with everything wired without touching a settings file.

Route two: any other agent

npx skills add superdesigndev/treg -s treg

The -s treg matters. Without it you also install the project's own internal development skills, which you do not want cluttering your setup.

Route three: the command line directly

curl -fsSL https://treg.to/install.sh | sh
treg login

Then prove it works without registering anything:

treg catalog search "backlinks for a domain"
treg call tikhub.tiktok.user.profile --query uniqueId=tiktok
treg balance

That last command shows exactly what the call cost. Three commands from nothing to a real API response with a price attached. If you would rather be walked through it, treg onboard runs a guided version.

Route four: self-hosting

Only worth it if you want the credential store on infrastructure you control. Two things to know before you start.

The base package is the command line tool only. To run your own registry you need the server extra:

pip install "tools-registry[server]"

To run it locally for a look first, with its own database and no mail sender needed:

scripts/dev-local.sh up

That needs tmux and uv installed, and serves on port 18790. Or run the server directly:

uv sync
uv run python -m treg
uv run python -m treg keygen    # generates your encryption key

The warning that matters more than any other line in this document. Back up your encryption key and your database before moving or redeploying anything. Lose the encryption key and every stored secret becomes permanently unrecoverable. Not difficult to recover, unrecoverable. The team's own hosted instance runs on Render with Postgres, and that is a reasonable shape to copy.

5. How the billing actually works

This is the section worth reading twice, because the mechanism is more useful than "pay per call" suggests.

The credential ladder

Every call resolves in the same order:

1. If your team registered its own tool for that provider, that tool and that key are used.
2. If your team stored a secret for the provider, it gets injected through a virtual tool.
3. If neither exists, Treg's own key is used and the call is billed to your prepaid balance.

The consequence that matters. Your own key always wins. So if you already pay for Semrush, connecting that key means those calls run on your subscription and are never metered by Treg. You are not paying twice, and you can mix freely: subscriptions for daily tools, per-call for everything else.

What you actually pay

There is no markup. The per-call rate is the provider's own unit price without the monthly commitment sitting on top.

Every new team starts with a dollar of free credit, which covers real calls and lets you see prices before committing to anything.

How to check any specific price before calling. This is the command that answers every pricing question honestly, because it shows the price along with the parameters and an example response:

treg catalog get hunter.people.email.find

Run that on whatever endpoint matters to you rather than relying on any published estimate, including the table above.

The rule that prevents surprises

An endpoint with no published price is refused rather than served for free. You get told to connect your own key instead. That is deliberate, and it means you cannot accidentally trigger an unpriced call.

When the balance runs out, the response is a standard payment-required error carrying the current balance, the estimated cost, and a top-up link, formatted so an agent can act on it rather than needing a human to read an error message.

treg balance          # credit left, calls in flight, recent spend
treg topup            # add funds, or set automatic top-ups

6. Where this actually pays

Six cases, ordered by how clearly they beat the alternative.

One, finding contact details for a list of people. The strongest case. Email lookup and enrichment are priced per seat per month, and most businesses need them in bursts around a campaign rather than daily. Nine providers in the catalog do this and you see all nine prices before choosing.

Two, competitor SEO checks. Keyword volumes, backlink profiles, rank tracking. These tools run over a hundred a month each and a founder checks a competitor maybe twice a month. Per-call pricing turns an occasional need into a rounding error.

Three, AI visibility. Whether your business gets cited when someone asks an AI a question in your category. New enough that most people have no tooling for it, and it does not justify a subscription yet.

Four, publishing to social platforms. The real cost here is not money, it is that every platform demands its own OAuth application, review process and setup. Treg handles those connections once, and then anyone on the team can act through them.

Five, ads management. Same shape as social. Google and Meta ad accounts are painful to connect properly, and once connected in one place, every teammate's agent can read and act on them.

Six, company enrichment for sales research. Firmographic data priced at around a hundred a month for something your sales process touches only when a deal appears.

The pattern underneath all six. These are tools you need occasionally, priced for people who need them constantly. That gap is the entire business case, and it is also the test for whether any given tool belongs here. Daily use, buy the subscription and connect the key. Occasional use, pay per call.

7. Setting it up for a team

Everything is scoped to an organisation, and a token represents one person in one organisation. Roles run owner, admin, member and viewer.

treg org invite teammate@acme.com      # invite by email, pick role and tool access
treg org access <member> --tools a,b   # restrict a member to specific tools
treg org ls | use <slug> | members     # switch orgs, see the roster

Be precise about what this controls. Access is per member and per tool, so a contractor can be given the enrichment tools and nothing else. That part is genuinely granular and worth setting on day one.

Spend works differently and it is worth understanding before you invite anyone. The team shares one prepaid balance. There is no per-person budget, so the balance itself is your ceiling, and anyone with access to a tool can draw on it. The practical control is a deliberately modest balance with automatic top-ups rather than a large float, combined with tight per-member tool access.

There is also a scan-and-share path for keys your team already holds:

treg scan     # read-only preview of what would be registered
treg upload   # register them, encrypted on the server

Run treg scan first and read what it found. It reads your environment file and matches keys against known providers, and you want to see that list before anything is uploaded.

8. The three artifacts you need

One, a connected-key inventory. A written list of which providers you already pay for and have connected, so nobody buys per-call access to something the company already subscribes to. This is the most common waste in a setup like this.

Two, a balance ceiling you have actually decided on. Since there is no per-person budget, the balance is the control. Pick a number, set automatic top-ups to it, and check spend weekly for the first month. Per-call pricing feels free until an agent loops.

Three, a written tool policy, 200 to 400 words, and almost nobody has one. One page naming which tools each role can reach, what the monthly ceiling is, and which categories need approval before use. This matters more here than with a normal subscription because a subscription has a natural limit, meaning you bought one seat and that is what exists, while per-call access has no natural limit at all. The policy is the limit. Write it before you invite the second person, not after.

9. If something goes wrong

10. Honest limits

This project is very new. The repository was created in mid July 2026 and has a few hundred stars. That is not a criticism of the code, and it matters for a decision about where your business credentials live. Treat it as promising rather than proven, and start with the per-call catalog before uploading every key your company owns.

Centralising credentials concentrates risk. This is the honest version of the convenience. A comparable service in this category suffered a breach in May 2026 that exposed thousands of customer credentials including OAuth tokens, and customers had to rotate every key and ask their own users to reauthorise. Treg's design is better on this point, since credentials are injected server-side and you can self-host the whole thing, but the principle holds. Connect what you need, scope access per member, and think twice before uploading keys for systems that can spend money or delete things.

There are no per-person spending limits. Covered in section seven and worth repeating, because it is the gap most likely to bite a team. Tool access is granular. Spend is a shared pot.

It does not choose for you. No surprise vendor swaps, and also no automatic failover when a provider is down. Your agent handles that itself.

The catalog is not everything. Forty plus providers is a lot and it is not the whole software market. Check that the specific tools your work depends on are in the catalog before cancelling anything.

11. What this changes

Software has been sold by the seat for twenty years because software was used by people, and people work in months. An agent works in seconds and needs forty tools for nine seconds each, which the seat model cannot price sensibly.

What this points at is not a cheaper way to buy the same things. The unit of purchase moves from the tool to the task, and once that happens the question stops being which subscriptions to keep and becomes which capabilities you want available on demand. That is a different way to build a company, and it costs a dollar in credit to start testing.