GBLIN MCP Server

Marktrisiko-Regime und Treasury-Tools für KI-Agenten auf Base-Mainnet. Ein Model-Context-Protocol-(MCP)-Server, der zwei Fragen beantwortet, die ein autonomer Agent stellen muss, bevor er Geld bewegt:

1. Ist der Markt gerade im Risk-off? Lies das Live-Regime — calm | elevated | crash — abgeleitet aus einem On-Chain-Crash-Shield. Kostenlos, ohne API-Key, ohne Wallet. Um einer Gegenpartei nachzuweisen, dass du geprüft hast, kannst du eine signierte EIP-712-Risikobescheinigung als portablen Due-Diligence-Nachweis kaufen.

2. Wo liegt ungenutztes USDC zwischen zwei Aufgaben? In GBLIN, einem besicherten cbBTC/WETH/USDC-Index, der zum NAV prägt und einlöst, mit einem Just-in-Time-Swap zurück in USDC in der Millisekunde, in der der Agent eine x402-Rechnung bezahlen muss. Keine Sperrfrist, nur un signierte Calldat­en – dein Wallet signiert, wir halten nie Schlüssel.

📖 Vollständige Dokumentation und Schnellstart: gblin.digital/agents

⚡ Startbeispiele zum Kopieren: examples/ — ElizaOS · AgentKit / TypeScript · Claude / beliebiger MCP-Client — jeweils mit dem empfohlenen System-Prompt für die Treasury-Policy und einer Sicherheitsumgebung mit sicheren Standardwerten.

▶️ Ausführbare Demo des gesamten Zyklus (read-only, keine Keys): npx tsx examples/full-cycle.ts — live gegen Base: Treasury-Zustand → Risiko-Regime → Bescheinigung offline verifiziert → Calldaten investieren → Calldaten für JIT-Einlösung. Quelltext.

🌐 Gehostetes MCP (Streamable HTTP, keine Installation): https://gblin-mcp.gblin-mcp-worker.workers.dev/mcp — 8 kostenlose Tools in einem Dot-notation-Baum, keine Authentifizierung, keine Session: risk.regime, risk.attestation_sample, protocol.stats, protocol.info, coherence.report, dazu AI Action Receipts (receipts.seal Demo 5/Tag/IP, receipts.get, receipts.verify — rein mathematische Verifizierung, kein Vertrauen in diesen Server). Zwei Prompts: risk_gate, seal_and_verify. Die vor der Umbenennung gültigen flachen Namen funktionieren bis zum 21.11.2026 weiterhin als nicht gelistete Aliase. Die Docs sind MCP-Ressourcen, keine Tools: gblin://howto/attestation, gblin://howto/seal, gblin://limits, gblin://keys (Verifier-Schlüssel + Schlüssel-Rotations-Policy). Über MCP wird nichts bezahlt.

GET-only-Audit (für Reviewer und Clients, die kein POST senden können): /meta (Zähler + manifest_hash) · /tools.json · /resources.json · /conformance · /v1/verify/:index (boolesche Werte pro Prüfung + Konsistenz des On-Chain-Ankers). Diese gehostete Oberfläche unterscheidet sich bewusst von dem npm-stdio-Paket unten (13 Tools, inklusive Treasury/Governance). Auch auf Smithery. Quellcode in worker/.

ElizaOS-Plugin

Für Agenten unter ElizaOS installierst du das ergänzende Plugin – es ist jetzt im offiziellen ElizaOS-Plugin-Registry gelistet (v0.4.0, sorgfältig gehärtet):

npm install plugin-gblin
# or: elizaos plugins add gblin

Es stellt vier native Actions bereit (CHECK_GBLIN_TREASURY_HEALTH, INVEST_IDLE_USDC_GBLIN, RESCUE_USDC_FROM_GBLIN, GET_GBLIN_RISK_ATTESTATION) sowie einen Provider, der bei jeder Schleife den Live-NAV + Crash-Shield-Status in den Agent-Kontext einspeist.

→ Vollständige Eliza-Plugin-Dokumentation

Related MCP server: mcp-server

AI Action Receipts — ein Transparenzlog mit Zeugen für das, was deine Agent getan hat

Das Problem, das damit gelöst wird, ist das größte Hindernis für die Einführung von KI im Jahr 2026: niemand kann im Nachhinein präzise beweisen, was eine KI getan hat (Umfragen: Angestellte verlieren 2–4 Stunden pro Woche damit, KI-Ausgaben zu verifizieren; 70 % der Organisationen geben an, ihre Agenten nicht steuern zu können). Unsere Antwort ist der kleinste ehrliche Basisbaustein: ein öffentliches, nur anfügbares RFC-6962-Transparenzlog für KI-Handlungen. Eingabe und Ausgabe gehen nur als Hashes ein (niemals als Inhalt); die von dir gesendeten kurzen Strings action, agent_id, tool und meta werden im öffentlichen Log veröffentlicht — setze dort also nur Identifikatoren ein, niemals Geheimnisse. Du erhältst einen portablen Beleg, den jede dritte Partei offline und für immer verifizieren kann.

receipt = canonical payload
        + Ed25519 signature            (key: gblin.digital/receipts-log)
        + RFC 6962 inclusion proof     (leaf → Merkle root)
        + C2SP signed checkpoint       (origin, tree size, root)

Die Kanonisierung ist festgelegt als gblin-canonical-json/1: Objektschlüssel sortiert nach UTF-16-Codeeinheit, kein Leerraum, JSON.stringify-Semantik für Primitive, Rekursion für Objekte/Arrays. Testvektor: Payload {"b":1,"a":null} → kanonisch {"a":null,"b":1} → Blatt = SHA256(0x00 || canonical_bytes). Die Belegsignatur ist Ed25519 über "gblin-receipt/v1\n" + canonical.

• Seal (bezahlt, unbegrenzt): POST https://gblin.digital/api/x402/seal — 0,01 USDC via x402.

• Seal (Demo, 5/Tag/IP): POST <worker>/v1/seal-demo oder das gehostete MCP-Tool receipts.seal (verifizieren mit receipts.verify).

• Für immer kostenlos lesbar: <worker>/v1/receipt/:index · /log · /log/checkpoint · /log/proof/:index · menschenlesbare Seite /receipt/:index.

• Täglicher EAS-Anker der Baumwurzel auf Base (verifizierbar auf base.easscan.org, Verb 0x9f433a96…, promiseId keccak256("gblin-receipts-log")).

• Offline-Verifikator, ganz ohne Abhängigkeiten: verify-receipt.mjs — node verify-receipt.mjs receipt.json.

Ein Seal beweist Existenz und Zeitpunkt in einem signierten Append-only-Log, dessen Wurzel täglich auf Base verankert wird. Den Checkpoint signiert derzeit der Log-Betreiber (wir); die unabhängige Co-Signierung durch Witnesses ist eine offene Einladung — wir co-signieren bereits die dritte Party eines Transparenzlogs (C2SP tlog-witness) und werden jeden Witness listen, der unseresco-signiert. Bis dahin gilt die ehrliche Wortwahl: operatoren-signiert, Chain-verankert. Das ist kein Compliance-Zertifikat und kein Zustimmung zum Inhalt. Worker: <worker> = https://gblin-mcp.gblin-mcp-worker.workers.dev.

Coherence Proof — überprüfen, dass GBLIN seine Versprechen hält

GBLIN registriert öffentliche, per Hash verankerte Versprechen und betreibt dann einen Automaten, der sie alle 10 Minuten prüft und jeden abgeschlossenen Tag als EAS-Attestation auf Base versiegelt. Das Lesen ist für immer kostenlos; der bezahlte Dienst wird beobachtet zu werden — der Zertifizierer unterwirft sich zunächst selbst seinem eigenen Instrument.

• Kostenloser Bericht: /coherence (JSON) oder das gehostete MCP-Tool coherence.report.

• Live-Versprechen: P1 (Verfügbarkeit des bezahlten Risk-Attestation-Endpunkts) und P2 (Ehrlichkeit der öffentlichen Agent-Wirtschaftszähler, wobei unsere eigenen Wallets offengelegt und ausgenommen sind).

• On-chain: Jeder abgeschlossene Tag wird durch eine eigene Observer-Wallet als EAS-Attestation auf Base versiegelt. GBLIN ist ein auffindbarer ERC-8004-Agent (#59286).

KI-Assistenten-Entdeckung — gblin-init

Lege eine AGENTS.md-Treasury-Policy in das Repo, damit jeder moderne KI-Codierungsassistent (Claude Code, Cursor, Windsurf, GitHub Copilot, Codex) wir erwarten, dass GBLIN automatisch entdeckt wird, wenn er an deiner Codebasis arbeitet:

npx -p @gblin-protocol/mcp-server gblin-init

Der Befehl ist idempotent und sicher:

• Wenn AGENTS.md nicht existiert → wird sie aus der kanonischen Vorlage unter gblin.digital/AGENTS.template.md erstellt.

• Wenn AGENTS.md existiert → wird ein klar abgegrenzter GBLIN-Block am Ende angehängt; dein eigener Inhalt bleibt unberührt.

• Durch erneutes Ausführen wird kein weiter gemacht (erkannt über stabile HTML-Marker).

• --dry-run gibt aus, was er tun würde, ohne zu schreiben.

• --force aktualisiert den Block auf die neueste Version.

Außerdem verschiedene neue Sets in das Offline-Template enthalten.

Postinstall-Hinweis

Wird das Paket als normale Abhängigkeit installiert, hat die Person npm während der Installation (npm i @gblin-protocol/mcp-server), wird einmalig ein kurzer Hinweis ausgegeben, der den obigen Befehl vorschlägt. Beim Post install werden **keine angelegt** — sicherheitsfreundlich und Socket-konform. Setze GBLIN_SKIP_HINT=1`, um ihn zu unterdrücken.

Trust & Governance

GBIN V6 wird durch einen 48h Timelock Controller verwaltet — jede Admin-Operation (Parameterveränderung, Oracle-Update, Besitzübertragung) wird vertraglich gezwungen, 172.800 Sekunden vor der Ausführung. Agents und Integratoren können dies direkt auf BaseScan überprüfen.

Diese Eigenschaften werden auf Vertragsebene durchgesetzt:

• MIN_DELAY (unveränderlich (überschreibt die updateDelay) dauerhaft widerrufen)

• PROPOSER_ROLE und CANCELLER_ROLE sind ständig getrennt (der Constructor revertiert bei Überlappung)

• EXECUTOR_ROLE ist offen (address(0)) — alle können die fällige Operation, der Zensureschutz

• Der Timelock ist selbstverwalten: Every role or config change must through the 48h delay

Deshalb liefert das Tool get_governance_state die Rückgabe owner_is_timelock: true and the verifiable min_delay_seconds: 172800. KI-Agenten können mit diesen Flags vertrauenssensible Aktionen im Zugriff steuern.

Warum es das gibt

KI-Agenten halten ihr Working Kapital heute in USDC. USDC liegt flach: keine Rendite, volle Inflationsbelastung.

GBLIN ist ein On-Chain-Index auf Base (45 % cbBTC + 45 % WETH + 10 % USDC) mit einem algorithmischen Crash Shield, der bei steigenden Ausmaß des „Drawdown" die Risiko-Exposition adaptive reduziert (V6 adaptive Threshold, ab ~15 %). GBLIN ist eine verwaltete Krypto-Exposition mit begrenztem Drawdown — ein ruhigerer Weg, um BTC/RETH-Risiko für Auszeichnung Kapital zu halten, kein Ersatz für USDC (es kann in einem Crash weiter durch Wert verlieren). Agenten haben x402-Rechnungen „just-in-time" über die GBLIN™→USDC-Einlösung.

Dieser Server öffnet diese Fähigkeit jedem LLM-Agenten über das Standard-MCP-Protokoll.

Schnellstart

Claude Desktop

Hinzufügen zur claude_desktop_config.json (unter Windows: %APPDATA%\Claude\claude_desktop_config.json):

{
  "mcpServers": {
    "gblin": {
      "command": "npx",
      "args": ["-y", "@gblin-protocol/mcp-server"]
    }
  }
}

Starte Claude Desktop neu. Die 13 GBLIN-Tools erscheinen im Tool-Auswahlmenü.

Windsurf / Cursor

Hinzufügen unter ~/.codeium/windsurf/mcp_config.json (Windsurf) bzw. die entsprechende Cursor-MCP-Konfiguration:

{
  "mcpServers": {
    "gblin": {
      "command": "npx",
      "args": ["-y", "@gblin-protocol/mcp-server"],
      "env": {
        "GBLIN_RPC_URL": "https://base-rpc.publicnode.com"
      }
    }
  }
}

Aktualisieren Sie die MCP-Server in den IDE-Einstellungen (oder starten Sie neu). Die Tools werden inline aufrufbar.

Coinbase AgentKit (TypeScript)

import { MCPClient } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "npx",
  args: ["-y", "@gblin-protocol/mcp-server"],
});
const client = new MCPClient({ name: "my-agent", version: "1.0.0" });
await client.connect(transport);

// List tools
const { tools } = await client.listTools();

// Quote a JIT payment of $0.50
const jit = await client.callTool({
  name: "swap_gblin_to_usdc_jit",
  arguments: { usdc_needed: "0.50", wallet_address: "0xYourAgent..." },
});

ElizaOS / benutzerdefiniert

Jedes Framework, das MCP über stdio spricht, funktioniert:

npx @gblin-protocol/mcp-server

Unterstützt außerdem Cline, Continue.dev und jeden Agenten, der die MCP-Client-Spezifikation implementiert.

Die 13 Tools (npm-stdio-Paket)

Kostenlose Tools (keine Zahlung erforderlich)

Weitere kostenlose Tools

Risk Attestation — Erstelle einen vergänglichen (10-minütigen), überprüfbaren Nachweis des aktuellen BTC/ETH-Risikoregimes unter GET https://gblin.digital/api/x402/attestation ($0.003 USDC). Füge ihn deiner Aktion als Sorgfaltsnachweis hinzu; jeder Gegenpartei kann ihn kostenlos über Airverify_risk_attestation prüfen.

Alle Tools liefern strukturiertes JSON. Alle Werte werden on-chain bezogen (NAV via quoteSellGBLIN × Chainlink ETH/USD, mit 24-Stunden-Staleness-Guard). Keine Mock-Daten.

Live-Verifizierung: Die Testsuite (npm test) läuft gegen das Mainnet von L1 und bestätigt Calldata-Generierung, Oracle-Frische, Slippage-Berechnung sowie den Governance-Status. Siehe den letzten CI-Lauf.

x402-Mikrozahlungen

Jedes MCP-Tool ist kostenlos. Der MCP-Server erhebt nie Gebühren: Er ist die Discovery- und Leseschicht und monetarisiert nur über die On-Chain-Protokollgebühr (0,05 % beim Mint), wenn ein Agent GBLIN tatsächlich nutzt.

Verifizierbare Pay-per-Call-Aufrufe liegen stattdessen auf den HTTP-Endpunkten, alle im Basis-Mainnet in USDC (0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913), abgewickelt über den Coinbase-CDP-Facilitator via gasloser EIP-3009-Autorisierung transferWithAuthorization:

Maschinenlesbares Manifest: https://gblin.digital/.well-known/x402. Empfohlene Clients: @x402/fetch oder @x402/axios (x402 v2 – sie übernehmen die 402-Challenge, die Signatur und den Retry für dich). Das MCP-Tool verify_risk_attestation prüft jede Attestation offline und kostenlos.

Zahlungsempfänger: 0x0ebA5d314F4f5Dcb7A094953Fa9311a45172dd1B (GBLIN-Gebührenwallet).

Architektonische Entscheidungen

Deterministisches zweistufiges JIT (V6)

GBLIN V6 hat den bisherigen sellGBLINForToken-Einzeltransaktionspfad entfernt. Der JIT-Flow besteht jetzt aus zwei deterministischen Transaktionen: (1) number sellGBLINForEth(amount, minEthOut) verbrennt GBLIN und löst den Korb mit orakelgebundenem minOut auf; (2) einen einzelnen WETH→USDC-Swap bei Uniswap V3 mit eigenem minOut. Der MCP gibt beide Schritte als sendefähigen Calldata zurück.

Das MCP liefert Daten, die auf allen Plattformen identisch funktionieren:

• EOA-Wallets (Privy, MetaMask, roher privater Schlüssel)

• ERC-4337-Smart-Accounts (Safe, Coinbase Smart Account)

• EIP-7702-delegierte EOAs (Pectra+)

Dynamischer Slippage

Die Slippage-Toleranz skaliert mit dem On-Chain-Risikoregime:

Der Puffer wird zusätzlich auf den internen maxInternalSlippage des Vertrags (200 bps) angewendet, um Oracle-Drift und Uniswap-Poolvarianz zu absorbieren.

MEV-Schutz

invest_usdc_to_gblin übergibt nie minOut = 0. Sowohl minWethOut als auch minGblinOut werden aus On-Chain-Quotes plus dem dynamischen Slippage-Puffer berechnet. Das eliminiert die Sandwich-Angriffsfläche, die naive Buy-With-Token-Tools oft schmerzt.

Abklingzeiten

Der Vertrag erzwingt nach jedem Kauf eine 120-Sekunden-Sperre. Das JIT-Tool liest lastDepositTime und den on-chain block.timestamp (niemals Date.now()) und gibt einen klaren CooldownActive-Fehler mit genauen verbleibenden Sekunden zurück, wenn der Swap revertieren würde.

Konfiguration

Der Server liest GCP_RPC_URL aus seiner Umgebung. Ohne die Umgebungsvariable fällt er auf https://base-rpc.publicnode.com zurück (kostenlos, ohne Schlüssel, großzügige Limits).

Für Produktionslast (>100 gleichzeitige Agenten) verwende einen dedizierten Anbieter:

export GBLIN_RPC_URL="https://base-mainnet.g.alchemy.com/v2/YOUR_KEY"
npx @gblin-protocol/mcp-server

Siehe .env.example für die gesamte Liste.

Entwicklung

git clone https://github.com/gblinproject/gblin-treasury-risk-regime
cd GBLIN-MCP
npm install
npm run build
npm test         # live read-only smoke test against Base mainnet
npm start        # run the compiled server

Projektstruktur:

src/
  config.ts    # network constants, addresses, slippage params
  abi.ts       # GBLIN_V6 + Chainlink + ERC-20 ABIs
  client.ts    # viem PublicClient + on-chain timestamp helper
  helpers.ts   # NAV, basket state, slippage, cooldown, reverse quote
  keeper.ts    # keeper bounty finder (incentivizedRebalance math)
  tools.ts     # the 10 treasury tool implementations + zod schemas (receipts.ts adds 3)
  index.ts     # MCP stdio server entry
scripts/
  test.ts      # live smoke test

Sicherheitshinweise

• Der Server ist schreibgeschützt. Er speichert, signiert oder sendet nichts.

• Alle Quotierungen stammen aus On-Chain-Aufrufen + Chainlink-Orakeln. Veraltete oder nicht existierende Orakelantworten lassen das Tool mit OracleStale / OracleDead abbrechen.

• Die Wallet des Agenten ist alleiniger Unterzeichner. Von den Tools zurückgegebener Calldata ist nur ABI-Bytecode — diesen sollte man in kontrollierten Umgebungen nicht ungeprüft senden.

• Kein Telefonierte, keine Analyse, keine Remote-Abhängigkeiten außer dem konfigurierten RPC.

Roadmap

• v0.2: Uniswap-V3-QuoterV2-Integration für eine Sub-Slippage-Präzision

• v0.3: Permit2-Support (überspringe den Approve-Schritt bei x402-Reinvestition)

• v0.4: Streamable-HTTP-Transport für gehostete Multi-Agent-Setups (Stromable HTTP).

• v1.0: Geprüfte Contracts-Integration + Remote-Deployment-Guide

Links

• Contract (Vertrag): 0x36C81d7E19…52f0

• Protokol-Website: https://gblin.digital *. Agent-Dokumentation: https://gblin.digital/agents

*** Issues**: https://github.com/gblinproject/gblin-treasury-risk-regime/issues

MIT © 2025 GBLIN Protocol

Agent-zu-Agent-Skill-Verbreitung (v0.1.9+)

Das MCP umfasst ein eigenständiges Tool — share_skill_with_peer — mit dem ein KI-Agent Treasury-Management-Fähigkeiten an einen anderen Agenten weitergeben kann.

Trifft Agent A in einem Multi-Agent-Kontext (delegierter Task, x402-Commemoration, gemeinsames Arbeitsplat) auf Agent B, kann Agent A share_skill_with_peer aufrufen, um einen portablen „Skill-Seed“ zu erzeugen. Der Seed enthält:

• Installationshinweise für den GBLIN-MCP-Server

• Ein lauffähiges Transaktionsbeispiel mit Referenz-Transaktion auf Blockscan (Basescan)

• Agent A Referralcode (abgeleitet aus dessen Wallet)

• Die vollständige, natürlichsprachige Erklärung von G

Agent B kann den Server mit dem Seed in Sekunden installieren. Von diesem Moment an enthält jede GBLIN-Transaktionen von Agent B den Referralcode von Agent A im Calldata über ERC-8021 Builder Code (bc_gbdo32j0). Ein kleiner Teil der Protosgebühr (0,05 % des Transaktionswerts) wird an die Wallet von Agent A umgeleitet — won es aus bestehenden Protokollgebühren kommt, nicht als Aufschlag.

So entsteht ein viraler Verbreitungsmechanismus für Treasury-Skills über das Agenten-Ökosystem hinweg.

Keine Zusatzinfrastruktur ist nötig. Der Mechanismus läuft vollständig on-chain über das bestehende Builder-Code-System.

Keeper-Bounty-System (v0.1.11+)

GBLIN ist eines der wenigen Protokolle, die KI-Agenten belohnen, statt Kosten zu verlangen.

Wenn der Treasury-Blayout von seiner Ziel-Allokation abweicht, kann jeder Agent find_keeper_bounty aufrufen, um zu prüfen, ob eine profitable Rebalance möglich ist. Wenn ja, liefert das Tool den fertigen Calldata. Der Agent sendet die Transaktion und erhält 0,0001 ETH aus dem Solvenzfonds des Protokolls — der Swap nutzt das Eigenkapital des Vertrags; der Auftraggeber zahlt nur für Gas (~ <0,01 $ auf base).

// Example response when a bounty is available
{
  "bountyAvailable": true,
  "direction": "WETH->asset",
  "estimatedRewardEth": "0.0001",
  "target": "0x36C81d7E1966310F305eA637e761Cf77F90852f0",
  "calldata": "0x...",
  "value": "0",
  "note": "Send this calldata to earn the reward. The swap uses the contract's own funds."
}

Für kontinuierliches Einkommen find_keeper_bounty alle 5–15 Minuten pollen. Ein Live-Ranking der Keeper gibt es unter gblin.digital/keepers.

Entdeckung & Vertrauen

GBLIN bietet maschinenlesbare Dateien für KI-Agenten und Protokolle:

.

• Coinbase x402 Bazaar: Alle 11 GBLIN-Endpunkte (7 Webapp + 4 Sentinel) sind im CDP-Bazaar indexed — Agenten finden Sie per Semantics (GET https://api.cdp.coinbase.com/platform/v2/x402/discovery/search?query=treasury+risk) oder über den Händler (.../discovery/merchant?payTo=0x0ebA5d314F4f8Dcb7A094953Fa9311aEdit1) *.

• x402-Manifest: https://gblin.digital/.well-known/x402 — vollständige Liste bezahlter Endpunkte inkl. Preise, Chain-ID, valute

• LLM-Discovery: https://gblin.digital/api/x402/llms.txt — menschengelesene Protokollsummary (frei, ohne Bezahlmauer)

• Base-MCP-Plugin: PR #56 auf base/skills — offizielle Integration in Prüfung

Ein MCP-Server in diesem Repository liefert die gleiche Funktionalität wie die x402-HTTP-Endpunkte, aber über das Model Context Protocol für direkte Agenten-Integration (Claude Desktop, Cursor, Windsurf, chat eliza): etc.)

GBLIN Sentinel — x402-Daten-Agenten-Beispiel

GBLIN Sentinel ist eine Open-Source-Referenzimplementierung eines autonomen KI-Agenten, der on-chain Daten über x402-Mikrozahlungen verkauft. Sie demonstriert das volle x402-Prosmuster auf Base.

Entdeckung:

• x402-Manifest: https://gblin-sentinel.vercel.app/.well-known/x402

• LLM-Referenz: https://gblin-sentinel.vercel.app/llms.txt

• Quelle: https://github.com/gblinproject/gblin-sentinel

Jeder Agent, der diesen MCP-Server nutzt, kann base-risk-pulse vor einer Investition abrufen, um Treasury-Aktionen anhand des aktuellen Marktrisikosignals zu gaten.

GBLIN Aureus — Autonomer Trading-Agent (Track-Record-Engine)

Aureus ist ein autonomer Katalysator- und Rotations-Agent, der auf Base Kryptowährungen, Aktien, Indizes und Metalle handelt – und kann seine Ergebnisse nicht beschönigen: Jede These wird keccak-gehasht und on-chain committet, noch bevor der Agent agiert, und erst beim Abschluss offengelegt. Gewinn oder Verlust, die Aufzeichnung ist dauerhaft und unabhängig verifizierbar. Keine herausgepickten Screenshots.

Status: DRY-RUN-Validierung. Aureus durchläuft den vollumfänglichen Kreislauf mit Live-Marktdaten und null echtem Kapital. Er wird nur dann auf echtes Kapital geschaltet, wenn er ein öffentliches Gate besteht: 30–50 abgeschlossene Trades, Profitfaktor > 1.3, maximaler Drawdown < 10 %, keine Liquidationen. Das Live-Dashboard veröffentlicht jede Metrik in Echtzeit: gblin.digital/aureus.

Unter der Haube (die langweiligen Teile, die das Kapital am Leben halten):

• Risiko-Engine: volatilitätszielbasiertes Sizing, St opps liegen immer innerhalb des Liquidation-Abstands, Mark-to-Market-Eigenkapital mit automatischem Drawdown-Halt, 10-Sekunden-Stopp-Wächter

• Multi-Börsen-Funding-Carry: delta-neutraler Funding-Harvest, bestätigt durch die Mediane von Binance/Bybit/OKX, mit Persistenz-Gating (Regime, keine einzelnen Datenpunkte)

• Multi-Zeitrahmen-Abgleich: schnelle Mean-Reversion-Signale werden durch den Tagestrend abgesichert (Time-Series-Momentum, der am besten dokumentierte Edge im Finanzwesen)

• Mikrostruktur-Überwachung: Taker-Flow (CVD) und Orderbuch-Ungleichgewicht legen ein Veto gegen Einstiege ein, wenn das Tape dagegen spricht

• Schattenbuch: Jede verworfene Strategie setzt das Paper-Trading auf Live-Daten fort; die Kapitalallokation folgt statistischen Beweisen, niemals Meinungen

• News-Sentinel: Ein Multi-LLM-Konsensensemble (6 unabhängige Anbieter) übersetzt verifizierte Schlagzeilen in ein Risikosignal – die Mathematik entscheidet über jeden Einstieg, die LLMs modulieren nur

Aureus ist außerdem ein geplanter GBLIN-Treasury-Nutzer: Ungenutztes Kapital wird über diesen MCP-Server in GBLIN geparkt und bei Bedarf per JIT-Swap in USDC getauscht, wenn Margin benötigt wird – der Agent kostet also die eigene Küche des Protokolls.

• Live-Dashboard: https://gblin.digital/aureus

• Ankündigung: @GBLIN_Protocol auf X

Verwandte Repositories

• Smart Contracts & Protokoll: https://github.com/gblinproject/GBLIN-Protocol

• Web-App & x402-Endpunkte: https://github.com/gblinproject/GBLIN_WEBAPP

• ElizaOS-Plugin: https://github.com/gblinproject/GBLIN_PLUGIN

• GBLIN Sentinel (x402-Daten-Agent): https://github.com/gblinproject/gblin-sentinel

• GBLIN Aureus (autonomer Trading-Agent): https://gblin.digital/aureus — DRY-RUN-Validierung, On-Chain-Commit-Reveal-Track-Record