treg

First, check which treg you have

This plugin ships MCP tools alongside the skill. Look at your tools before you do anything else.

If you can see catalog_search, catalog_get, call, balance and my_tools — treg is connected. Use those; there is nothing to install. The rest of this page is written around the treg command line, so read treg catalog search as catalog_search, treg call as call, and so on.

If the tools error or you cannot see them, the plugin needs a token. The human sets TREG_TOKEN:

1. Sign in at https://treg.to (GitHub / Google / email code)
2. Copy the token from Settings → API Token
3. Set TREG_TOKEN in the environment Cursor reads (or add it in Cursor's plugin configuration)
4. Restart the agent — the tools will appear

A new team starts with $1.00 of free balance, so there is nothing to pay before the first call. If sign-in is needed, say so plainly and stop — never ask the human for a provider's API key, which is the thing treg exists to avoid.

---

When the tools ARE there

tool	use it for
catalog_search	find an endpoint by WHAT YOU WANT TO DO — "work email", "backlinks", "tiktok comments"
catalog_get	one endpoint's parameters and its exact price, before you spend
call	make the call; treg injects the credential and relays the answer
balance	the team's prepaid balance
my_tools	what this team registered and you can call without holding the key

Either way, the rest of this page is the part that matters — when treg is the right move, and how to choose between providers.

---

treg — the tool catalog for your agent

Ask for the task, not the tool. When a job needs external or live data — backlinks, keyword volume, a TikTok profile, a work email, competitor ad creative — search the catalog, read the price, call it.

Two kinds of tool answer to the same token, through the same proxy, which injects the credential server-side so you never hold it:

• The catalog — curated external endpoints treg can call for you.
• Your own tools — what a teammate registered and shared with this org: API accounts, OAuth connections, skills. Note: an X (Twitter) connection made through treg's app is metered per call (X bills the app owner per use); the response reports the price. A team's own X developer app is not metered.

The mechanics:

• Endpoint: https://treg.to · CLI: treg · the CLI is a thin client over the API.
• Auth: every call sends X-Treg-Token: <your token>.
• A tool = an upstream base URL + credential bindings. A skill/bundle = a recipe (SKILL.md) + its secrets + its tool(s). The proxy relays, never models the upstream.

New verified accounts receive $1.00 of signup credit once, when creating an eligible team. Additional teams start with no signup credit, and aliases of one inbox (+tag, Gmail dots) share a single credit. Legacy POST /users registration does not verify an email or grant credit; use email OTP or Google/GitHub sign-in. Existing balances remain usable.

First: install + sign in

curl -fsSL https://treg.to/install.sh | sh     # installs the CLI + points it here
treg login                            # browser sign-in (GitHub / Google / email code) — first login registers you
treg login --email [email protected]    # emailed 6-digit code (falls back to the browser if the server requires a browser check)
treg login --token <per-org-token>    # non-interactive (agents/CI)

Everything runs in your active org (after first login, create or join a team). Team invites arrive by email — see them with treg invites, accept with treg accept (or treg org join <code>). Switch teams: treg org switch <slug>.

Already connected over MCP? Then you have the tools, not the CLI

If you reached treg through https://treg.to/mcp/ — ChatGPT, Claude Code, Cursor — the CLI steps above do not apply to you. You have catalog_search, catalog_get, call, call_media, resources_list, balance, my_tools, catalog_request, feedback, and review. Everything in this document maps onto them:

• "search the catalog" → catalog_search, then catalog_get for the exact price and parameters. Its verdict says what you got: strong (these do the job, every provider of it by measured success), closest (nearest, check catalog_get), none (not in the catalog: file catalog_request, do not rephrase), keyword (ranked by words alone)
• "what's new" → catalog_search with added_within_days (30 is a good default) or sort: "newest"; query may be empty.
• "call it" → call with the endpoint id, or <tool-name>/<path> for one of the team's own tools
• "check the balance" → balance
• "share feedback" → feedback

The rules below are the same either way. The one that matters most — say the price before you spend it — matters more here, because call returns cost_usd and you can report what a call actually cost rather than estimating.

A call on a catalog endpoint spends the team's balance. A call on one of the team's own tools spends nothing: that key belongs to them.

Task — the catalog: what treg can do for you (start here)

3,900+ catalogued endpoints across 111 providers, grouped by what they DO: keyword & rank tracking, backlinks & authority, AI visibility, trending & discovery, publishing to the team's own social accounts, people & company enrichment, ads management & creative, measurement, video & image generation.

treg catalog search "subreddit posts"            # find endpoints by what they do
treg catalog search --new                        # tools added in the last 30 days, newest first
treg catalog get scrapecreators.reddit.subreddit.posts   # params, PRICE, how you'd be served
treg call scrapecreators.reddit.subreddit.posts --query subreddit=news
treg balance                                     # the prepaid balance + recent charges
treg catalog request "<what you need>"           # searched, not there? file it — steers what's added next

Notes:

• Every endpoint's price is in treg catalog get, before you call it.
• Search for the job AND any output you need: treg catalog search "email verification catch-all" finds different tools from a broad email-verification search. Check each candidate with treg catalog get for its fields, parameters and price before choosing. If you need a provider's catch-all, disposable, role-address or SMTP field, call that provider's endpoint: the routed treg.people.email.verify contract defines only valid, status and score.
• To find AND check an email in one call, send --header "X-Treg-Route-Verify: true" on treg.people.email.find. The check is its own small charge. Read _treg.verification.verdict (valid, invalid, catch_all, risky, unknown); checked: false means no check ran. The same header on treg.people.phone.find checks the line live: live, dead or unknown. Never call a phone "verified": a live line is not proof it is this person's number.
• A catalog endpoint can use a verified public route with no provider key. Such a call is free when the caller does not send a provider credential. The team tool or stored provider key still wins.
• Discovery jobs usually have TWO shapes in the catalog — a structured one (filters: title, location, followers, funding) and a semantic one (describe what you want; exa.*). When a brief mixes hard limits with a fuzzy niche, run both and merge: e.g. creators = influencersclub.creators.search (filters) ∪ exa.creators.search (description, pinned to the platform domain); people = a people.search provider ∪ exa.people.search; who-holds-a-role questions = exa.web.answer.
• HTTP 402 = out of balance, with a machine-actionable body (balance_micro, estimated_cost_micro, topup_url). Recovery: treg balance → top up in the dashboard (Team → Billing) → or store the org's own key for that provider (own keys are never billed to the balance — they take priority automatically). A 402 with error: route_max_cost is different: YOUR X-Treg-Route-Max-Cost header refused the call before anything was charged — ask for fewer rows/targets or raise the ceiling.
• Scripting many calls: use treg --json call …. Stdout is one line, {"result": <provider body>, "_treg": {"http_status", "call_id", "charged_micro"}}, and nothing goes to stderr, so a script that merges the streams still parses every answer (--await output is unchanged). Run a handful and check the parsed results before looping over the whole list: a parse bug throws away answers that were already billed.
• The real charge is the response header X-Treg-Cost-Micro (micro-USD), with X-Treg-Call-Id as the id to quote. An idempotent replay reports 0 there and the first call's charge in X-Treg-Original-Cost-Micro. Lost an answer you paid for? GET /calls/<call id>/result returns the stored response of a successful catalog call. On an asynchronous submission that header is the reserved ceiling; the CLI labels it as a reservation, and the terminal task settles the real charge. The catalog ~$/call figure for a per_result route assumes a 20-row page when the price is per row; when the catalog cost.unit is target/domain/keyword you pay per thing asked about, one unit per target. Failed calls (4xx/5xx relayed from the provider) are free; empty results mean whatever the provider means by them — treg relays, it does not normalise.
• A call may be answered from treg's archive of the exact same question while that answer is fresh: verbatim provider bytes, X-Treg-Cache: hit, X-Treg-Fetched-At, X-Treg-Age. Your team's first call on a question costs full price either way; from your second call on, a hit costs 10%, and a hit on your own key is free. Cache-Control: no-cache forces a live call; X-Treg-Max-Age: <seconds> accepts only a younger answer. A team admin can opt the team out of the archive (treg org archive off): new calls are then neither answered from nor stored in it, so metered calls lose the repeat price.
• HTTP 503 provider_capacity_unavailable = treg's own account for that provider is out (not your balance; nothing charged). Body has resets_at and alternatives (same capability, other providers) — choose one, or use your own key. treg never switches providers for you. treg re-checks the provider about once a minute, so a retry after a minute can succeed.
• HTTP 503 provider_paused = this deployment paused that provider (nothing charged, nothing sent). Read message. The existing connection is kept; do not reconnect, it works again when resumed.
• An org tool or secret for the provider always wins over an anonymous route or treg's key, automatically — the catalog is the fallback, not a replacement for keys the team already has.
• Choosing between providers of one capability — the procedure. treg catalog get <id> lists every provider serving the same job with COST, WORKS (success rate treg has observed, with the sample size), SPEED (median) and LAST OK. Work down this order:
  1. Match the inputs you actually HAVE. An endpoint wanting a profile_url is not a substitute when you hold a name and a domain, whatever it costs. This rule outranks price every time.
  2. Then reliability: a high WORKS with a real sample beats a rounder number with a tiny one — 99% (121) is stronger evidence than 100% (8).
  3. Then price. Spreads inside one capability reach 200×, so this is usually where the money is.
  4. LAST OK breaks ties. A bare age means a real call came back; a ✓ age is the catalog's own verification stamp, not live traffic; — means nobody has verified it and nobody has called it — prefer almost anything else.
  • If a call fails with 429 / 5xx / a timeout, try the next provider. You know its parameters, so you can build its request. Say which one you switched to.
  • Never retry a 4xx elsewhere. A 4xx is usually your parameters; fixing them is the fix, and retrying burns the team's money on N providers for one mistake.
  • treg does not choose or fail over between providers for you. That is deliberate: only you know which inputs you hold, and treg relays rather than rewrites your request. If treg's own account for a provider is out it may serve the same endpoint through a treg-owned relay (X-Treg-Served-Via: overflow:<name>, or served_via + a hint on the MCP call result; real price, same shape). catalog_get shows that price up front as overflow_price_usd when the deployment can relay the endpoint - a "free" endpoint with one may bill exactly that, so quote it. A team opts out with treg org overflow off.
  • For a common job, call the routed tool, not a provider you remember. Scraping a page (treg.web.extract), web search (treg.web.search), Google results (treg.google.serp.organic, treg.google.serp.maps), finding or verifying an email (treg.people.email.find, treg.people.email.verify) and most social profiles have a treg.<capability> tool. treg picks the provider (your own key first), falls back when one fails or misses, and charges only the answer it returns. A provider you used last week may not be the best choice today: prices and reliability change. Name a provider only when you need fields or options that only it has.
  • Routed endpoints (treg.<capability>, e.g. treg.people.email.find) are where you can ask treg to choose: POST the identity ({full_name, domain} | {first_name, last_name, domain} | {linkedin_url}); treg runs the best child (own keys first, then cheapest per hit), falls back on errors AND misses (cheapest first, within X-Treg-Route-Max-Cost, default $1; a miss can be billed, so a routed row quotes usd_per_call: null, not $0 — set the header for bulk runs), and returns {output, raw, _treg.served_by, _treg.tried} + X-Treg-Served-By. X-Treg-Route-Waterfall: 0 stops at the first miss. A filter a provider cannot apply (country on a name-only search) is still sent to the others, and the answer names it in X-Treg-Ignored-Filters / _treg.ignored_filters — post-filter, or send X-Treg-Route-Strict-Filters: 1 to get a 422 (unbilled) instead of a looser answer. catalog_get treg.people.email.find shows the plan and prices. An async child is submitted and polled internally for up to 60 seconds. If it is still running, treg returns HTTP 202 with _treg.outcome: pending, its call reference and poll descriptor, reserved_micro, and charged_micro: null; do not retry or start another provider, because the existing task may still complete and charge.
  • A found contact is not a confirmed one. An email or phone find returns the provider's best match; only output.verified: true means it checked the mailbox. When it is not, the answer carries _treg.advice naming the verify step (treg.people.email.verify, a fraction of a cent) — run it before outreach, and never re-send the same find: every hit bills, repeats included.
  • Verify before you send. Every address, every time. This includes rows from a company or domain search (treg.people.search, hunter.companies.emails, …): those are directory listings, and a row's email is unconfirmed unless that row's own verification field says otherwise. Treat invalid as dead and accept_all as risky. And never send to an address the provider did not return — if a domain search came back empty, info@ is a guess, not a result. Live 2026-09-08: 73 of one team's 79 bounces were unverified rows and guesses that one $0.006 verify call each would have caught.
• An endpoint with no published price is refused rather than served free; connect your own key.

Task - generate video, images, voice, or music

Generation models live in the catalog under the video-gen, image-gen, voice-gen, and music-gen platforms, one row per model per route, so the same model on two routes sits next to itself with both prices. Models are not interchangeable - you pick one; treg does not choose.

treg catalog search "text to video"                  # every model, with prices
treg catalog get minimax.video-gen.h3.generate       # native params, model enum, price table, async descriptor
treg call minimax.video-gen.h3.generate --await --timeout 900 --data '{"model":"MiniMax-H3-Max",
  "content":[{"type":"text","text":"A paper boat drifts across a quiet pond at sunrise."}],
  "resolution":"480P","duration":5,"ratio":"16:9"}'
treg call minimax.voice-gen.voices.list --data '{"voice_type":"system"}'
treg catalog get minimax.voice-gen.speech-2-8-turbo
treg call minimax.voice-gen.speech-2-8-turbo --data '{"model":"speech-2.8-turbo",
  "text":"A calm voice can make a complex idea feel simple.","stream":false,"output_format":"url",
  "voice_setting":{"voice_id":"English_expressive_narrator","speed":1,"vol":1,"pitch":0}}'

How it works:

• Voice generation is synchronous. MiniMax returns JSON containing a 24-hour audio URL. The catalog route fixes stream:false and output_format:"url"; use the voice-list action to discover valid system voice IDs, then choose HD or Turbo by endpoint id.
• Fish Audio is binary and team-scoped on the platform key. Use fishaudio.tts.s2-1-pro with header model: s2.1-pro; redirect CLI stdout to an audio file or use MCP call_media. To use a Fish-supplied voice, call fishaudio.voices.discover with self=false and licensed=true|false, then pass a returned _id as reference_id; true selects Fish's rights-secured subset and false includes public/community voices. treg rechecks that non-team id as public before platform-key synthesis. Create reusable private voices with fishaudio.voices.create, then list their ids with treg resources list --provider fishaudio --kind voice or MCP resources_list. Those list the connected Fish account under BYOK and otherwise list only the current team's platform voices; curl uses GET /orgs/{org_id}/provider-resources?provider=fishaudio&kind=voice. BYOK remains an unrestricted unmetered relay. treg resources list requires CLI ≥ 0.21.0; run treg update if the resources command is unrecognised.
• A video or image generation call is an async task. The submission returns a task id at once; --await polls the provider until it finishes and prints the final response only on stdout. stderr carries the task id, a resumable treg call … command (Ctrl-C loses the wait, never the task or the money), progress, and the result URL. Exit 0 = done, 2 = the provider failed the task, 3 = timed out (resume with the printed command).
• Some async tools usually answer at once (an email verification): when the first response is already finished, it is the answer and is charged as one; --await prints it without polling. If it says "still working", poll no faster than the descriptor's interval and stop at its max_age seconds; a task with no answer by then is refunded.
• Reference media (a face image, a voice clip, a first frame) must be a public URL the vendor can fetch. Do not reach for a paste host: they fail vendor probes at random (catbox, tmpfiles, uguu all did). treg host face.jpg prints a public URL (30 MB, 7 days, free) that drops straight into image_urls / audio_urls: --data "{\"image_urls\":[\"$(treg host face.jpg)\"], …}". Requires CLI ≥ 0.20.0; run treg update if treg host is unrecognised.
• CLI agents: raise your shell tool's timeout or run the call in the background. A video takes 1-5 minutes; a runtime's default 2-minute command limit cuts it off mid-wait.
• MCP and raw-HTTP agents: the response header X-Treg-Async is the descriptor - where to poll, which status values are terminal, where the result is. Poll lazily: wait ~60 s before the first check, then every 30-60 s; three to six checks per video is normal. Do other work in between.
• Parameters are the provider's own, verbatim; treg catalog get shows them, including the enum of selectable models and resolutions. Nothing is translated between providers.
• Money: the price is reserved at submission and charged only when the task succeeds. A failed or moderated task refunds the whole hold - nothing to do on your side. treg audit and the dashboard's Activity page show each task's state (generating… → done / failed · refunded) with the result link once it exists.
• Result URLs expire (the descriptor's ttl_note says how soon; MiniMax's ~9h). Download promptly; treg never stores the media. On some routes the file needs one more call - --await prints that exact command instead of downloading.
• Responses needing settlement or task-ownership evidence are limited to 8 MiB. Larger responses return 502 with detail.error=response_buffer_limit and no charge; retrying the same oversized response will not help. Authorized free final downloads needing no body evidence stream in full. Such downloads are fetched again on retry, not retained for local idempotent replay.
• A tool whose answer inlines media (Google AI's images, speech and Lyria music arrive as base64 in the JSON) is exempt from the 8 MiB limit up to 64 MiB and is charged from the provider's reported usage. Its answer is never replayed: an Idempotency-Key retry generates, and bills, a new image. A response_buffer_limit whose message says it is temporary means treg is busy: retry shortly.

Retrying a call without paying twice

If a call times out or you never see its answer, repeat it with the same idempotency_key (over MCP) or Idempotency-Key header (over HTTP). treg returns the stored answer, does not call the provider again, and charges nothing. The result says replayed: true.

Only for a genuine retry. Asking the same question again to see what changed is NEW work: use a new key or none, or you will get the old answer back. Reusing one key for a different request is refused. A 409 means the original call is still running: retry shortly. A 410 idempotency_response_lost means it was charged but its answer was not kept: try GET /calls/{call_id}/result, or use a new key. A 410 idempotency_outcome_unknown means its outcome was not recorded: GET /calls/{call_id} shows the cost; use a new key.

Most retries need none of this — a failed call was never billed.

Catalog entries marked strict_query: true accept only their declared query parameters, once each. Include required fields, use allowed values and omit the request body.

Task — your own tools: call one the team registered

Start from what is registered, then use the API exactly as its own docs say. No treg vocabulary, no special params:

treg tool ls                                  # what this team has registered
treg call intercom conversations?per_page=5   # <tool-name> + the upstream path

Over HTTP that is GET https://treg.to/call/<tool-name>/<path> with X-Treg-Token: <your token>. treg looks up the named tool, injects that team's credential server-side, and relays everything faithfully (method, query params, your headers, body). Your X-Treg-Token is stripped before the upstream sees it. Works for GET/POST/PUT/PATCH/DELETE.

Only tools this org has registered resolve. Discover them with treg tool ls · treg skill ls.

Task — share your keys & skills so teammates' agents can use them

Bulk (the fast path): run it in the directory the human names. It lists the provider keys it recognises in that .env and the skills in its subdirs, and registers only the ones they tick:

treg upload                       # both sides of the cwd; `treg upload env|skills --dir <d>` to restrict

Default: wrap new keys in a skill. When registering a new key/endpoint/CLI, pair it with a skill so credential, tool, and recipe land together (and it gets a shareable page). If no skill exists, create a basic one — a proper SKILL.md (frontmatter matters: agents discover skills by it) + one example call:

mkdir -p ./posthog && cat > ./posthog/SKILL.md <<'MD'
---
name: posthog
description: Query the PostHog analytics API through treg — the key is injected server-side. Use for events, insights, and project queries.
---
Call it: `treg call posthog api/projects/@current` (upstream: https://us.posthog.com)
MD
treg skill init --dir ./posthog   # drafts treg.json: base_url from the catalog (folder name) or URLs in SKILL.md; review it + add the key
treg skill add --dir ./posthog    # registers recipe + secret + tool atomically

Never orphan a secret: a stored key nothing binds is dead weight — if you use secret add directly, bind it to a tool (endpoint/CLI) in the same breath. Bare endpoint, no recipe (only when a skill adds nothing):

treg secret add posthog-key --value "$POSTHOG_API_KEY"          # or --file ./.secret/token.json
treg tool add posthog --base-url https://us.posthog.com --secret posthog-key
# query-key API instead of a bearer header:
treg tool add serpapi --base-url https://serpapi.com --secret <name-or-id> \
  --auth-in query --auth-name api_key --auth-format '{secret}'

A whole skill (recipe + secrets + tool, possibly multi-credential):

treg skill scaffold ~/.claude/skills/google-ads --out gads.json
#   -> walks the dir: captures SKILL.md as the recipe + every .secret/* as a secret.
#   -> YOU then edit gads.json: set base_url, and complete each binding (location/name/format).
#      e.g. google-ads needs TWO bindings on one request:
#        Authorization: Bearer {access_token}  (injector: oauth)
#        developer-token: {secret}             (injector: env)
treg skill push gads.json                                        # registers the bundle atomically

Share it inside the org: give a teammate the endpoint + tool name and their agent can call it without being handed the credential — you granted the access, treg injects the secret, and the call is logged against their token.

Auth shapes (per binding injector, = the secret's kind): env (plain string) · secret_file (JSON token file, pull secret_field) · oauth (JSON token, auto-refreshed) · cli_auth (a token the human copied out of a CLI they are already signed into, and supplied to treg themselves). Multiple bindings apply to every request.

OAuth, two modes (treg keeps it fresh): if the oauth secret carries refresh_token + client_id + client_secret, treg auto-refreshes it before it expires (you never re-upload). If it's just a bare token, that's manual mode, treg injects it as-is and you re-upload when it expires. Same storage; a credential can graduate from manual to auto with no migration.

Getting the first OAuth token, two ways (your choice):

• Manual: do your own OAuth locally, then treg secret add gsc --file token.json --kind oauth.
• Hosted connect: treg oauth connect gsc --client-secret client_secret.json --scopes <scope> → prints a consent URL; you approve in the browser; treg captures the token directly. One-time setup: add https://treg.to/oauth/callback to your OAuth app's redirect URIs.

Task — manage the team + monitor

An account can own up to 10 teams. Joining other teams as a member does not count toward this limit.

treg tool ls / secret ls / skill ls / calls          # inventory + audit log — scoped to the active org
treg tool rm <id> / secret rm <id> / skill rm <id>   # secret rm is blocked while a tool binds it
treg health            # status of every credential in this org (ok | invalid | unknown)
treg health --run      # re-check now: refresh oauth tokens, probe each tool, alert owners

Teams / orgs (owner > admin > member > viewer; a member manages only what they created):

treg org create "Team A"                       # you become owner (auto-active)
treg org rename --name "Team B" --slug team-b   # admin+; existing keys keep working
treg org invite [email protected] --role member  # admin+; emails the invite (a one-time code is the fallback)
treg org members                               # admin+; who's in the active org
treg org ls / treg org switch <slug>           # your orgs / switch active

Give an agent its own identity (admin+). An agent doesn't have to borrow the human's token — mint it one, and every call it makes is capped, scoped and logged as itself:

treg org agent-new customer-bot --pin customer=cust_A  # scope history and shared-provider async reads
treg org agent-new ci-bot                        # prints the token ONCE (run again to rotate)
treg org agent-new ci-bot --tools stripe,gh --cap 500   # only these tools, 500 calls/day
treg org agents                                  # who the team's agents are + today's usage
treg org agent-rm <user_id>                      # revoke instantly

Put that token in the agent's TREG_TOKEN env var. An agent token can call this team's tools and read — it can never sign in, create a team, or be an owner. If you are an agent and you were given your own token, use it instead of the machine owner's: your work then shows up under your own name in treg calls.

The invitee signs in with the invited email and runs treg accept — no code handling needed (the code path still works: treg org join <code>). A brand-new invitee also gets their own personal org (no empty state), so removing them from a team never locks them out. Give a tool a probe so treg can validate it: health_check: {method, path, expect_status} (e.g. intercom {"path":"me"}).

Feedback

Proactively share problems and suggestions about treg. Small annoyances that slowed your task down count too: unclear instructions, confusing results or charges, unhelpful errors, and missing capabilities you worked around, even if the task succeeded. Describe what you needed and observed; you do not need to prove a bug. Distinguish observations from suspected causes. Use the feedback tool over MCP, or treg feedback submit over CLI. Pass related call IDs in call_ids (CLI: --call-id), not only in the message; references are optional. Report each issue once. Feedback helps the treg team improve the product; it does not complete the user's task. Keep going afterward. Keep private information out of the report. See feedback instructions.

Review

If a call result invites a review, rate that one call after using it: review(call_id, usefulness, reason?) over MCP or treg review CALL_ID USEFULNESS [--reason "..."]. Choose useful, partly, not_useful, or not_sure; uncertainty is fine. One review per invitation; a review of an uninvited call is accepted, and a team counts once per endpoint. Reasons may be quoted on the endpoint's catalog page without naming your team: write about the endpoint, omit private data, use feedback for anything confusing or wrong, then continue.

Rules

• Secrets are write-only — the API never returns a stored value, to you or to anyone.
• A tool may bind a secret a teammate shared with this org (use-without-hold) — that's the point: they chose to share it, it stays scoped to the org, you can spend it without seeing it, and every call is attributed to the token that made it. It is delegated access inside one team, never access to a credential nobody granted you.
• Everything is scoped to your active org. A token reaches that team's tools and no one else's.
• The proxy doesn't understand the upstream; if a call fails, the status you see is the upstream's truth.
• More: https://treg.to/llms.txt (agent onboarding) · https://treg.to/tutorial (interactive walkthrough).