📖 Schreibgeschützter Spiegel. argus wird aus dem kanonischen AI-Factory-Monorepo veröffentlicht. Pull Requests werden nicht akzeptiert — jeder hier gepushte Commit wird beim nächsten Sync von scripts/mirror_satellites.sh überschrieben. 🐞 Einen Fehler gefunden oder einen Wunsch? Bitte ein Issue eröffnen.

ARGUS-3 — MCP-Server

🌐 English · Русский · Español · Français · 中文 · Glossar

Ein MCP-Server. WARDEN-gehärteter Agent. Wallet optional.

Transport: stdio (argus mcp). Gebaut mit dem offiziellen Model Context Protocol TypeScript SDK (@modelcontextprotocol/sdk). Kompatible Hosts: Claude Desktop, Cursor, Glama und jeder MCP-Client, der stdio-Server unterstützt.

Teil der AICOM Open Agent Economy. Live-Demo: magic-ai-factory.com/argus/ · Community: Discord · Pollux · Telegram · Castor

MCP-Firewall zuerst — Wallet optional. ARGUS-3 prüft jeden Drittanbieter-MCP-Server durch WARDEN (statischer Scan → Threat-Feed → Herkunft → Def-Pinning), bevor auch nur ein einziges Tool läuft. Crypto, Wallet und On-Chain-Ökonomie sind standardmäßig deaktiviert. (Kurzname ARGUS · CLI: argus · npm: argus-warden · scoped: @alexar76/argus3)

Warum „ARGUS-3"? Im Mythos war Argus Panoptes — der hundertäugige Wächter — unschlagbar, bis Hermes ihn in den Schlaf redete und erschlug. ARGUS-3 ist der Wächter, der nicht auf Hermes hereinfällt: hundert offene Augen (WARDEN), bis zur Pedanterie sparsam, immun gegen schönredende Konkurrenz.

Beim dritten Mal ist es der Wächter. 👁️

ARGUS ist der nachfrageseitige Referenz-Client, der der Agenten-Ökonomie gefehlt hat. Das Ökosystem hat bereits Produzenten (die Factory 🏭), einen Broker (den Hub 🛒), Preise (ACEX 📈), Vertrauensmathematik (das LUMEN-Orakel 🔮) und Observability (den Monitor 👽). Was fehlte, war ein erstklassiger Agent, den ein normaler Mensch betreibt — einer, der Fähigkeiten entdeckt, bezahlt, konsumiert und verkauft. Das ist ARGUS.

Er basiert auf zwei Stack-Ebenen, die generischen MCP-Clients typischerweise fehlen:

1. 🛡️ WARDEN — eine MCP-Sicherheits-Firewall, die Drittanbieter-Server prüft, bevor deren Tool-Definitionen das Modell überhaupt erreichen: ein gestufter statischer Scan, ein signierter Threat-Feed, eine Herkunftsprüfung und Tool-Def-Pinning gegen Rug-Pulls. Jedes Gate entscheidet auf Basis dessen, was ARGUS bereits lokal vorliegen hat. Funktioniert ohne Wallet und ohne Chain.

2. 💸 Native Abwicklung (optional) — pro Aufruf zahlen und in USDC auf Base über AIMarket-Escrow bezahlt werden, wenn du Crypto aktivierst und ein Wallet verbindest.

…und er bleibt sparsam (ein harter Budget-Governor + Live-Token-Zähler — keine Selbstreflexion auf deine Kosten), spricht mit jedem Modell (Anthropic, OpenAI-kompatibel, chinesisch, lokal) und — entscheidend — läuft vollständig autonom, wenn die Ökonomie nicht verfügbar ist. Kein Wallet, kein Netzwerk zu AICOM? Er ist trotzdem ein erstklassiger lokaler, MCP-gesicherter Assistent.

🔒 Crypto ist standardmäßig AUS

Eine Blockchain ist nicht erforderlich, um ARGUS-3 zu betreiben. Wallet, Lotterie, ACEX, bezahlte Aufrufe und On-Chain-Abwicklung sind standardmäßig deaktiviert und werden nur aktiviert, wenn du ARGUS_CRYPTO_ENABLED=1 setzt (plus ein Wallet). Out of the Box erhältst du den vollständigen Agenten — WARDEN, jedes Modell, Speicher, Kanäle und kostenlose Off-Chain-Orakel- Abfragen — ohne Chain, ohne Token, ohne Wallet, ohne Verwahrung. Crypto ist Opt-in.

Warum ARGUS anders ist

🧭 Kernfunktionen — Designabsicht und Stack-Abhängigkeiten für jede Hauptfunktion — docs/killer-features.md · ru · es.

Related MCP server: re-angr

Schnellstart

Ein Befehl (interaktiver Assistent, ~2 Minuten):

curl -fsSL https://magic-ai-factory.com/install | bash

Oder von npm installieren (gleiche CLI, kein curl-Skript):

npm install -g argus-warden@latest
mkdir -p ~/.argus/agent && cd ~/.argus/agent
argus setup && argus doctor

Paket: argus-warden auf npm · scoped: @alexar76/argus3 · CLI: argus · npx argus-warden --help

Danach argus chat oder argus serve.

Als MCP-Server ausführen (stdio)

npm install -g @alexar76/argus3
# or: npm install && npm run build && node dist/index.js mcp
argus mcp

Claude Desktop / Cursor (mcpServers-Eintrag):

{
  "mcpServers": {
    "argus": {
      "command": "argus",
      "args": ["mcp"]
    }
  }
}

Tools (2)

Glama TDQS: MCP-annotations (readOnly / destructive / idempotent / openWorld), Verhaltens- und Nutzungsrichtlinien in jeder Beschreibung, strukturierte Parameter mit Beispielen — kalibriert auf die Score-Rubrik (nicht den alten Einzeiler).

Auf Glama veröffentlichen

Listing: glama.ai/mcp/servers/alexar76/argus

Gleiches Muster wie aimarket-oracle-gateway: Repo-Wurzel glama.json + Dockerfile.glama + node dist/index.js mcp.

Wenn magic-ai-factory.com/install 404 zurückgibt, verwende den Spiegel: curl -fsSL https://modeldev.modelmarket.dev/install | bash

Dokumentation: Wiki · Benutzerhandbuch (20 Sprachen) · Entwicklerhandbuch — eine Fähigkeit in 15 Minuten veröffentlichen (20 Sprachen) · Anwendungsfall — dein ARGUS auf AICOM (EN / RU) · Das überprüfbare Gewissen (Blockdiagramme) · Wann ARGUS dir nicht hilft 😈 · Ökosystem-Whitepaper

cd argus
npm install
npm run build

# 1) Configure (safe to commit — NO secrets live here)
cp argus.config.example.json argus.config.json

# 2) Add keys to .env (all optional; with none, ARGUS uses a local Ollama model)
cp .env.example .env      # then edit

# 3) Check what's wired up
node dist/index.js doctor

# 4) Ask something
node dist/index.js ask "summarise https://example.com in three bullets"

# 5) Interactive
node dist/index.js chat

Während der Entwicklung kannst du den Build-Schritt mit npm run dev -- ask "…" überspringen.

Die Autonomie-Garantie

ARGUS braucht nichts von AICOM, um zu funktionieren:

# No ANTHROPIC_API_KEY, no wallet — just a local model:
ARGUS_LOCAL_BASE_URL=http://127.0.0.1:11434/v1 node dist/index.js ask "hello"

Ohne ARGUS_WALLET_KEY meldet doctor economy: OFF (autonomous) und die gesamte Economy-Schicht wird nie konstruiert. Siehe docs/autonomy.md.

Architektur

Fünf Schichten. Alles oberhalb der Autonomie-Linie läuft offline; die Economy wird darunter angedockt, gesteuert allein durch das Vorhandensein einer Wallet.

flowchart TB
  subgraph OFF["Runs offline — no AICOM, no wallet"]
    L1["Layer 1 · Providers — Anthropic · OpenAI-compatible · local"]
    L2["Layer 2 · Bounded agent core — plan→execute→observe + budget governor"]
    L3["Layer 3 · Memory / self-learning — episodes · lessons · pins"]
    L4["🛡️ Layer 4 · MCP host + WARDEN — static · threat · origin · pinning"]
    L1 --- L2 --- L3 --- L4
  end
  GATE{{"— autonomy line — needs ARGUS_WALLET_KEY"}}
  L5["🛒 Layer 5 · Economy — discover · pay · invoke · settle · sell"]
  L4 -.-> GATE -.-> L5
  L5 -.->|wraps| SDK["@aimarket/agent SDK"]

Vollständige Diagramme und die Modulübersicht: docs/architecture.md.

🛡️ WARDEN — die MCP-Firewall

WARDEN wird separat als @aimarket/warden ausgeliefert — eine Bibliothek ohne Abhängigkeiten, die du vor deinen eigenen MCP-Host setzen kannst, ohne ARGUS zu übernehmen. ARGUS hängt von diesem Paket ab; dieser Abschnitt beschreibt, was es im Agenten tut.

Die Tool-Beschreibungen eines MCP-Servers sind angreiferkontrollierter Text, den das Modell als Anweisungen liest. WARDEN behandelt jeden Server als standardmäßig feindlich und führt jede Verbindung durch Gates, bevor ein Tool exponiert wird:

flowchart LR
  S[MCP server] --> A[1 · static scan] --> B[2 · threat feed] --> C[3 · origin] --> D[4 · def-pinning] --> V{allow?}
  V -->|yes| OK[bridge tools<br/>pin defs]
  V -->|no| NO[block + report]

• Statischer Scan — Signaturen für Injection / Exfiltration / Secret-Harvesting / versteckte Unicode-Zeichen in Tool-Definitionen. Die Regeln sind gestuft: blockierende Regeln decken Formulierungen ohne harmlose Lesart ab; beratende Regeln (ein api_key-Parameter, eine .env-Erwähnung, ein „du musst") werden gemeldet, blockieren aber nie und beeinflussen nie den Score — das lässt ehrliche Server durch. Jedes Urteil nennt die Regelsatz-Version + den Digest, der es erzeugt hat.

• Threat-Feed — eingebaute Deny-Liste + optionaler signierter Remote-Feed.

• Herkunft — woher die Server-Deklaration stammt: du hast sie in mcp.servers aufgelistet, oder sie wurde aus einem entfernten mcp.catalogs-Eintrag entdeckt. Mit allowUnknownServers: false wird ein katalogentdeckter Server blockiert (SERVER_UNDECLARED); deine eigenen Deklarationen passieren immer, sodass Fail-Closed trotzdem einen Weg zum Verbinden lässt.

• Pinning — hasht die genehmigte Tool-Menge; spätere Drift = Rug-Pull, erzwingt erneute Genehmigung.

Sensible Tools (write/delete/exec/payment/…) erfordern zusätzlich eine explizite Benutzer- Genehmigung zum Aufrufzeitpunkt. Details: docs/security-warden.md.

node dist/index.js warden scan      # vet your configured MCP servers

💸 Economy-Integration

ARGUS nutzt das bestehende AI Market Protocol v2 und das @aimarket/agent-SDK — keine neuen Endpunkte.

export ARGUS_WALLET_KEY=0x...                       # enables the economy layer
node dist/index.js economy status
node dist/index.js economy discover "translate to 5 languages" --budget 1
node dist/index.js economy register                 # list ARGUS in the AI Service Mesh

Consumer-Flow: discover → openChannel (USDC/Base) → invoke (X-Payment-Channel) → settle. Provider-Flow: Identität + Wallet im Mesh registrieren, Fähigkeiten auflisten, verdienen (und für die Agenten-Lotterie / Machine-UBI berechtigt werden). Siehe docs/economy-integration.md · docs/mcp-oracles-capabilities.md (17 Orakel, MCP, Verkauf).

Multi-Provider

Modelle werden in argus.config.json Stufen zugeordnet (triage / core / heavy); das Routing fällt auf andere Stufen zurück, wenn ein Schlüssel fehlt.

🎮 Agent Arena — Level aufsteigen, Streaks halten, Karte zeigen

Einen Agenten zu betreiben sollte Spaß machen. Agent Arena verwandelt echte Ökosystem-Aktivität in die Spielmechaniken, die ein junges, globales Publikum bereits liebt — Duolingo-artige Streaks, Wrapped-artige teilbare Karten, Gaming-Rang-Karten:

• XP & Level — verdiene XP für das Abschließen von Aufgaben, den Verkauf von Fähigkeiten, das Spielen der Orakel-Lotterie, den Handel auf ACEX und für Sparsamkeit (niedrige $/Aufgabe).

• Tägliche Streaks 🔥 — halte deinen Agenten Tag für Tag aktiv.

• Quests & Abzeichen — First Blood (erster Lotteriegewinn), Rainmaker (erste $1 durch den Verkauf von Fähigkeiten), Frugal (eine Aufgabe unter $0.001), Trusted (obere Hälfte der LUMEN-Reputation), Warden (einen bösartigen MCP-Server blockiert), Polyglot, Whale, Lucky… Trusted und der Reputationsrang sind heute nicht verdienbar: Ein LUMEN-Score braucht einen Vertrauensgraphen, und keine Bereitstellung veröffentlicht die Vertrauenskanten, nach denen ARGUS bewertet würde.

• Flex-Karte — argus flex (oder /flex in Telegram) rendert eine schicke, teilbare Karte: Handle, Level, Streak, verdiente $, Gewinnrate, Top-Abzeichen, Reputationsrang (leer, bis ein Vertrauensgraph existiert). Zahlen + Emoji = keine Sprachbarriere → überall teilen.

• Globales Leaderboard (Opt-in) — Rangliste gegen Agenten weltweit nach XP, Verdienst oder Sparsamkeit.

Jede Statistik ist echt — es ist deine tatsächliche Economy- und Sparsamkeits- Leistung, lokal berechnet aus dem eigenen Speicher deines Agenten + signierten Economy-Belegen, also schwer zu fälschen und keine Eitelkeitspunkte. Teilen und das Leaderboard sind standardmäßig aus und besitzerkontrolliert — deine Daten bleiben deine. Vollständiges Design: docs/arena.md.

Live-Demo (diese Flotte):

• LIVE (Base-Mainnet): https://magic-ai-factory.com/arena — :8787 → GET /arena/stats

• UNI (Universe / Anvil): https://magic-ai-factory.com/arena-uni/ — :8788 → gleiche UI, mode=uni

Nutze den TEST · LIVE · UNI-Schalter auf der Arena-Seite, um zwischen Demo-Metriken und jedem bereitgestellten Knoten zu wechseln.

Konfiguration

• argus.config.json — nicht-geheime Konfiguration (Provider, Modelle, Stufenpreise für den Meter, Budget-Obergrenzen, WARDEN-Richtlinie, MCP-Server/Kataloge, Economy-Endpunkte). Sicher zu committen. Beginne mit argus.config.example.json.

• .env — nur Geheimnisse: API-Schlüssel (ANTHROPIC_API_KEY, DEEPSEEK_API_KEY, …), ARGUS_WALLET_KEY und optional ALIEN_API_TOKEN für den Alien-Monitor-Run-Feed. Nie committen. Beginne mit .env.example.

economy.enabled wird abgeleitet — es ist genau dann wahr, wenn ARGUS_WALLET_KEY gesetzt ist.

Wo es im Ökosystem steht

aicom Factory baut Agenten → gelistet und aufgerufen über AIMarket (Hub + Protokoll) → Oracles (LUMEN-Vertrauen, Zufall, VDF, Konsens) bepreisen und sichern sie → finanziert auf ACEX → visualisiert von Alien Monitor.

ARGUS ist die Nachfrageseite: der Agent, der in diesem Markt ausgibt, verkauft und den Benutzer gegen die MCP-Lieferkette verteidigt — mit einer Firewall, die keines der oben genannten benötigt, um zu funktionieren.

Kanäle

Ein begrenzter Agentenkern, viele Kanäle — jeder mit dem für ihn natürlichen Auth-Modell. Vollständige Matrix + Design: docs/channels.md.

argus serve führt Telegram + den HTTP-Server zusammen aus (das ist es, was der Container ausführt). GET /health ist auch der Hook, der ARGUS als live Knoten in Alien Monitor erscheinen lässt. Setze ALIEN_MONITOR_URL + ALIEN_API_TOKEN, um jeden abgeschlossenen Run an das verifizierbare Run-Panel des Knotens zu pushen (Orakel-Aufrufe, WARDEN- Blöcke, Einstellungen, versiegelter Beleg). Discord, Slack, Email, Matrix, WhatsApp und Sprache sind sofort hinzufügbare Adapter (siehe Dokumentation).

Bereitstellung (Docker)

ARGUS startet nicht vertrauenswürdige MCP-Server als Kindprozesse, daher ist der Container auch eine Sicherheitsgrenze um sie — nicht nur Verpackung.

cp argus.config.example.json argus.config.json   # edit
cp .env.example .env                              # add secrets
docker compose up -d --build                      # serve: Telegram + HTTP /health

Geheimnisse kommen aus .env (nie ins Image eingebacken); argus.config.json wird schreibgeschützt gemountet; der Zustand bleibt im argus-state-Volume; ein HEALTHCHECK prüft /health. Economy ist im Container standardmäßig AUS (autonom).

Entwicklung

npm run typecheck     # tsc --noEmit (strict)
npm test              # vitest (budget governor, MCP host + WARDEN wiring, provider mapping)
npm run build         # emit dist/

Status

v0.1 — begrenzte Agentenschleife, Multi-Provider-Routing, WARDEN-Gate-Kette (statisch + Threat + Herkunft + Pinning), Speicher/Lektionen, MCP-Host, Economy-Consumer/Provider- Wrapper und vier Kanäle (CLI, Telegram, HTTP, MCP-Server) + Docker — alles implementiert und getestet. OS-Level-MCP-Sandboxing (seccomp/Landlock/sandbox-exec), der signierte Threat-Feed-Publisher und die restlichen Kanal-Adapter sind die v2- Spur — siehe die Dokumentation.

Demo

• Live: https://magic-ai-factory.com/argus/

• Dokumentation: https://github.com/alexar76/argus/wiki

Verwandte Repos

Community

Die DIOSCURI-Zwillinge beantworten Fragen aus synchronisierten GitHub-Dokumenten.

Ökosystem-Karte: Alien Monitor · AICOM

Lizenz

MIT — deine Schlüssel, deine Infrastruktur, deine Daten. Teil der AICOM offenen Agenten-Ökonomie.