treg — der Werkzeugkatalog für Deinen Agenten

Was macht treg — der Werkzeugkatalog für Deinen Agenten?

Frage nach der Aufgabe, nicht nach dem Werkzeug. Wenn ein Job externe oder Live-Daten benötigt – Backlinks, Keyword-Volumen, ein TikTok-Profil, eine geschäftliche E-Mail, Anzeigen-Kreativdaten von Wettbewerbern – durchsuche den Katalog, lies den Preis, rufe ihn auf.

Zwei Arten von Werkzeugen antworten auf dasselbe Token über denselben Proxy, der die Anmeldeinformationen serverseitig injiziert, sodass Du sie nie besitzt:

• Der Katalog – kuratierte externe Endpunkte, die treg für Dich aufrufen kann.
• Deine eigenen Werkzeuge – was ein Teammitglied registriert und mit dieser Organisation geteilt hat: API-Konten, OAuth-Verbindungen, Skills. Hinweis: Eine X (Twitter)-Verbindung, die über die treg-App hergestellt wurde, wird pro Aufruf abgerechnet (X belastet den App-Besitzer pro Nutzung); der Preis wird in der Antwort ausgewiesen. Ein eigenes X-Entwickler-App eines Teams wird nicht abgerechnet.

Die Mechanik:

• Endpunkt: https://treg.to · CLI: treg · die CLI ist ein dünner Client für die API.
• Authentifizierung: jeder Aufruf sendet X-Treg-Token: <Dein Token>.
• Ein Werkzeug = eine Upstream-Basis-URL + Anmeldedaten Bindungen. Ein Skill/Bundle = ein Rezept (SKILL.md) + seine Geheimnisse + sein(e) Werkzeug(e). Der Proxy leitet weiter, modelliert nicht den Upstream.

Zuerst: Installieren + Anmelden

curl -fsSL https://treg.to/install.sh | sh     # installiert die CLI + zeigt darauf
sudo treg login                            # Browser-Anmeldung (GitHub / Google / E-Mail-Code) – erste Anmeldung registriert Dich
treg login --email du@firma.de             # Terminal-Alternative (E-Mail mit 6-stelligem Code)
treg login --token <pro-org-token>         # nicht-interaktiv (Agenten/CI)

Alles läuft in Deiner aktiven Organisation (die erste Anmeldung erstellt eine persönliche). Teameinladungen kommen per E-Mail – sieh sie mit treg invites, akzeptiere sie mit treg accept (oder treg org join <code>). Wechsle Teams: treg org switch <slug>.

Bereits über MCP verbunden? Dann hast Du die Werkzeuge, nicht die CLI

Wenn Du treg über https://treg.to/mcp/ erreicht hast – ChatGPT, Claude Code, Cursor – gelten die obigen CLI-Schritte nicht für Dich. Du hast fünf Werkzeuge: catalog_search, catalog_get, call, balance, my_tools. Alles in diesem Dokument wird auf sie abgebildet:

• "Durchsuche den Katalog" → catalog_search, dann catalog_get für den genauen Preis und die Parameter
• "Rufe es auf" → call mit der Endpunkt-ID, oder <Werkzeug-Name>/<Pfad> für eines der eigenen Werkzeuge des Teams
• "Überprüfe das Guthaben" → balance

Die Regeln unten sind in beiden Fällen gleich. Die wichtigste Regel – sage den Preis, bevor Du ihn ausgibst – ist hier noch relevanter, weil call cost_usd zurückgibt und Du berichten kannst, was ein Aufruf tatsächlich gekostet hat, anstatt zu schätzen.

Ein call auf einen Katalog-Endpunkt verbraucht das Guthaben des Teams. Ein call auf ein eigenes Werkzeug des Teams kostet nichts: dieser Schlüssel gehört ihnen.

Aufgabe – der Katalog: was treg für Dich tun kann (hier beginnen)

~2.800 katalogisierte Endpunkte bei ~56 Anbietern, gruppiert nach dem, was sie tun: Keyword- & Ranking-Tracking, Backlinks & Autorität, KI-Sichtbarkeit, Trends & Entdeckungen, Veröffentlichung auf den eigenen Social-Media-Konten des Teams, Personen- & Firmenanreicherung, Anzeigenverwaltung & Kreativdaten, Messung.

treg catalog search "subreddit posts"            # finde Endpunkte nach dem, was sie tun
treg catalog get scrapecreators.reddit.subreddit.posts   # Parameter, PREIS, wie Du bedient wirst
treg call scrapecreators.reddit.subreddit.posts --query subreddit=news
treg balance                                     # das Prepaid-Guthaben + aktuelle Gebühren
treg catalog request "<was Du brauchst>"           # gesucht, aber nicht gefunden? Melde es – lenkt, was als Nächstes hinzugefügt wird

Hinweise:

• Der Preis jedes Endpunkts steht in treg catalog get, bevor Du ihn aufrufst.
• HTTP 402 = Guthaben aufgebraucht, mit einem maschinenlesbaren Body (balance_micro, estimated_cost_micro, topup_url). Wiederherstellung: treg balance → Guthaben im Dashboard aufladen (Team → Abrechnung) → oder den eigenen Schlüssel der Organisation für diesen Anbieter speichern (eigene Schlüssel werden nie vom Guthaben abgebucht – sie werden automatisch priorisiert).
• Ein Org-Werkzeug oder -Geheimnis für den Anbieter gewinnt immer automatisch gegenüber dem treg-Schlüssel – der Katalog ist der Fallback, kein Ersatz für Schlüssel, die das Team bereits hat.
• Auswahl zwischen Anbietern einer Fähigkeit – die Vorgehensweise. treg catalog get <id> listet jeden Anbieter, der denselben Job mit COST (Kosten), WORKS (Erfolgsrate, die treg beobachtet hat, mit Stichprobengröße), SPEED (Geschwindigkeit, Median) und LAST OK (letzter Erfolg) bedient. Gehe in dieser Reihenfolge vor:
  1. Passe die Eingaben an, die Du tatsächlich HAST. Ein Endpunkt, der eine profile_url erwartet, ist kein Ersatz, wenn Du einen Namen und eine Domain hast, egal was es kostet. Diese Regel hat Vorrang vor dem Preis.
  2. Dann Zuverlässigkeit: eine hohe WORKS-Rate mit einer echten Stichprobe ist besser als eine runde Zahl mit einer winzigen – 99% (121) ist ein stärkerer Beleg als 100% (8).
  3. Dann Preis. Die Spannen innerhalb einer Fähigkeit erreichen 200×, also liegt hier meist das Geld.
  4. LAST OK bricht Gleichstände. Ein bloßes Alter bedeutet, dass ein echter Aufruf zurückkam; ein ✓-Alter ist der eigene Verifikationsstempel des Katalogs, kein Live-Traffic; — bedeutet, dass niemand es verifiziert und niemand es aufgerufen hat – bevorzuge fast alles andere.
  • Wenn ein Aufruf mit 429 / 5xx / einem Timeout fehlschlägt, versuche den nächsten Anbieter. Du kennst seine Parameter, also kannst Du seine Anfrage erstellen. Sage, zu welchem Du gewechselt hast.
  • Wiederhole einen 4xx-Fehler niemals woanders. Ein 4xx liegt meist an Deinen Parametern; sie zu korrigieren ist die Lösung, und eine Wiederholung verbrennt das Geld des Teams bei N Anbietern für einen Fehler.
  • treg wählt nicht für Dich aus und führt kein Failover durch. Das ist beabsichtigt: Nur Du weißt, welche Eingaben Du hast, und treg leitet weiter, ohne Deine Anfrage umzuschreiben.
• Ein Endpunkt ohne veröffentlichten Preis wird abgelehnt, nicht kostenlos bedient; verbinde Deinen eigenen Schlüssel.

Einen Aufruf wiederholen, ohne doppelt zu bezahlen

Wenn ein Aufruf fehlschlägt oder Du seine Antwort nie siehst, wiederhole ihn mit derselben idempotency_key (über MCP) oder dem Idempotency-Key-Header (über HTTP). treg gibt die gespeicherte Antwort zurück, ruft den Anbieter nicht erneut an und berechnet nichts. Das Ergebnis enthält replayed: true.

Nur für eine echte Wiederholung. Die gleiche Frage noch einmal zu stellen, um zu sehen, was sich geändert hat, ist NEUE Arbeit: verwende einen neuen Schlüssel oder keinen, sonst bekommst Du die alte Antwort zurück. Die Wiederverwendung eines Schlüssels für eine andere Anfrage wird abgelehnt.

Die meisten Wiederholungen benötigen nichts davon – ein fehlgeschlagener Aufruf wurde nie abgerechnet.

Aufgabe – Deine eigenen Werkzeuge: rufe eines auf, das das Team registriert hat

Beginne mit dem, was registriert ist, und verwende dann die API genau so, wie es die eigene Dokumentation sagt. Kein treg-Vokabular, keine speziellen Parameter:

treg tool ls                                  # was dieses Team registriert hat
treg call intercom conversations?per_page=5   # <Werkzeug-Name> + der Upstream-Pfad

Über HTTP ist das GET https://treg.to/call/<Werkzeug-Name>/<Pfad> mit X-Treg-Token: <Dein Token>. treg sucht das benannte Werkzeug, injiziert serverseitig die Anmeldeinformationen des Teams und leitet alles originalgetreu weiter (Methode, Query-Parameter, Deine Header, Body). Dein X-Treg-Token wird entfernt, bevor der Upstream es sieht. Funktioniert für GET/POST/PUT/PATCH/DELETE.

Nur Werkzeuge, die diese Organisation registriert hat, werden aufgelöst. Entdecke sie mit treg tool ls · treg skill ls.

Aufgabe – teile Deine Schlüssel & Skills, damit die Agenten der Teammitglieder sie nutzen können

Massenimport (der schnelle Weg): Führe es in dem Verzeichnis aus, das der Mensch benennt. Es listet die darin erkannten Anbieterschlüssel .env und die Skills in seinen Unterverzeichnissen auf und registriert nur die, die er auswählt:

treg upload                       # beide Seiten des aktuellen Verzeichnisses; `treg upload env|skills --dir <d>`, um einzuschränken

Standard: neue Schlüssel in einen Skill packen. Wenn Du einen neuen Schlüssel/Endpunkt/CLI registrierst, kombiniere ihn mit einem Skill, sodass Anmeldedaten, Werkzeug und Rezept zusammenkommen (und er eine teilbare Seite erhält). Wenn kein Skill existiert, erstelle einen einfachen – eine richtige SKILL.md (Frontmatter ist wichtig: Agenten entdecken Skills darüber) + einen Beispielaufruf:

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   # erstellt treg.json: base_url aus dem Katalog (Ordnername) oder URLs in SKILL.md; überprüfe es + füge den Schlüssel hinzu
treg skill add --dir ./posthog    # registriert Rezept + Geheimnis + Werkzeug atomar

Verwaise niemals ein Geheimnis: Ein gespeicherter Schlüssel, an den nichts gebunden ist, ist tote Last – wenn Du secret add direkt verwendest, binde es im selben Schritt an ein Werkzeug (Endpunkt/CLI).

Nackter Endpunkt, kein Rezept (nur wenn ein Skill nichts hinzufügt):

treg secret add posthog-key --value "$POSTHOG_API_KEY"          # oder --file ./.secret/token.json
treg tool add posthog --base-url https://us.posthog.com --secret posthog-key
# Query-Key-API anstelle eines Bearer-Headers:
treg tool add serpapi --base-url https://serpapi.com --secret <name-oder-id> \
  --auth-in query --auth-name api_key --auth-format '{secret}'

Ein ganzer Skill (Rezept + Geheimnisse + Werkzeug, möglicherweise mit mehreren Anmeldedaten):

treg skill scaffold ~/.claude/skills/google-ads --out gads.json
#   -> durchläuft das Verzeichnis: erfasst SKILL.md als Rezept + jedes .secret/* als Geheimnis.
#   -> DU bearbeitest dann gads.json: setze base_url und vervollständige jede Bindung (Ort/Name/Format).
#      z.B. google-ads benötigt ZWEI Bindungen in einer Anfrage:
#        Authorization: Bearer {access_token}  (injector: oauth)
#        developer-token: {secret}             (injector: env)
treg skill push gads.json                                        # registriert das Bundle atomar

Teile es innerhalb der Organisation: Gib einem Teammitglied den Endpunkt + Werkzeugnamen, und sein Agent kann es aufrufen, ohne die Anmeldedaten zu erhalten – Du hast den Zugriff gewährt, treg injiziert das Geheimnis, und der Aufruf wird gegen ihr Token protokolliert.

Authentifizierungsformen (pro Bindung injector, = die kind des Geheimnisses): env (einfacher String) · secret_file (JSON-Token-Datei, extrahiere secret_field) · oauth (JSON-Token, automatisch erneuert) · cli_auth (ein Token, das der Mensch aus einer CLI kopiert hat, bei der er bereits angemeldet ist, und selbst an treg übergeben hat). Mehrere Bindungen werden auf jede Anfrage angewendet.

OAuth, zwei Modi (treg hält es frisch): Wenn das OAuth-Geheimnis refresh_token + client_id + client_secret enthält, führt treg eine automatische Erneuerung durch, bevor es abläuft (Du lädst nie wieder hoch). Wenn es nur ein nacktes Token ist, ist das der manuelle Modus, treg injiziert es unverändert, und Du lädst es erneut hoch, wenn es abläuft. Gleicher Speicher; ein Anmeldedatensatz kann ohne Migration von manuell auf automatisch aufgerüstet werden.

So erhältst Du das erste OAuth-Token, zwei Möglichkeiten (Deine Wahl):

• Manuell: Führe Deinen eigenen OAuth-Ablauf lokal durch, dann treg secret add gsc --file token.json --kind oauth.
• Gehostetes Verbinden: treg oauth connect gsc --client-secret client_secret.json --scopes <Bereich> → gibt eine Zustimmungs-URL aus; Du genehmigst im Browser; treg erfasst das Token direkt. Einmalige Einrichtung: Füge https://treg.to/oauth/callback zu den Weiterleitungs-URIs Deiner OAuth-App hinzu.

Aufgabe – das Team verwalten + überwachen

treg tool ls / secret ls / skill ls / calls          # Bestandsaufnahme + Prüfprotokoll – auf die aktive Organisation beschränkt
treg tool rm <id> / secret rm <id> / skill rm <id>   # `secret rm` wird blockiert, solange ein Werkzeug es bindet
treg health            # Status jeder Anmeldeinformation in dieser Organisation (ok | invalid | unknown)
treg health --run      # jetzt neu prüfen: OAuth-Tokens erneuern, jedes Werkzeug testen, Besitzer benachrichtigen

Teams / Organisationen (Eigentümer > Administrator > Mitglied > Betrachter; ein Mitglied verwaltet nur das, was es erstellt hat):

treg org create "Team A"                       # Du wirst Eigentümer (automatisch aktiv)
treg org invite [email protected] --role member  # Admin+; sendet die Einladung per E-Mail (ein einmaliger Code ist der Fallback)
treg org members                               # Admin+; wer in der aktiven Organisation ist
treg org ls / treg org switch <slug>           # Deine Organisationen / aktive wechseln

Gib einem Agenten seine eigene Identität (Admin+). Ein Agent muss nicht das Token des Menschen borgen – erstelle ihm eines, und jeder Aufruf, den er tätigt, ist gedeckelt, beschränkt und als er selbst protokolliert:

treg org agent-new ci-bot                        # gibt das Token EINMAL aus (erneut ausführen, um zu rotieren)
treg org agent-new ci-bot --tools stripe,gh --cap 500   # nur diese Werkzeuge, 500 Aufrufe/Tag
treg org agents                                  # wer die Agenten des Teams sind + heutige Nutzung
treg org agent-rm <user_id>                      # sofort widerrufen

Setze dieses Token in die Umgebungsvariable TREG_TOKEN des Agenten. Ein Agenten-Token kann die Werkzeuge dieses Teams aufrufen und lesen – es kann sich nie anmelden, ein Team erstellen oder Eigentümer sein. Wenn Du ein Agent bist und Du Dein eigenes Token erhalten hast, verwende es anstelle des des Maschinenbesitzers: Deine Arbeit erscheint dann unter Deinem eigenen Namen in treg calls.

Der Eingeladene meldet sich mit der eingeladenen E-Mail-Adresse an und führt treg accept aus – keine Code-Handhabung erforderlich (der Code-Pfad funktioniert immer noch: treg org join <code>). Ein brandneuer Eingeladener erhält auch seine eigene persönliche Organisation (kein leerer Zustand), sodass das Entfernen aus einem Team ihn nie aussperrt. Gib einem Werkzeug einen Testaufruf, damit treg es validieren kann: health_check: {method, path, expect_status} (z.B. intercom {"path":"me"}).

Regeln

• Geheimnisse sind schreibgeschützt – die API gibt niemals einen gespeicherten Wert zurück, weder an Dich noch an jemand anderen.
• Ein Werkzeug kann ein Geheimnis binden, das ein Teammitglied mit dieser Organisation geteilt hat (Verwenden-ohne-Besitzen) – das ist der Sinn: Sie haben sich entschieden, es zu teilen, es bleibt auf die Organisation beschränkt, Du kannst es ausgeben, ohne es zu sehen, und jeder Aufruf wird dem Token zugeschrieben, das ihn getätigt hat. Es ist delegierter Zugriff innerhalb eines Teams, niemals Zugriff auf eine Anmeldeinformation, die Dir niemand gewährt hat.
• Alles ist auf Deine aktive Organisation beschränkt. Ein Token erreicht die Werkzeuge dieses Teams und niemand anderen.
• Der Proxy versteht den Upstream nicht; wenn ein Aufruf fehlschlägt, ist der Status, den Du siehst, die Wahrheit des Upstreams.
• Mehr: https://treg.to/llms.txt (Agenten-Onboarding) · https://treg.to/tutorial (interaktiver Rundgang).