Skip to content

README.md

Latest commit

 

History

History
542 lines (396 loc) · 22.9 KB

README.md

File metadata and controls

542 lines (396 loc) · 22.9 KB

REDACTED AI Swarm

Autonomous AI Agents for Distributed Systems — Pattern Blue Edition

The REDACTED AI Swarm is a suite of autonomous AI agents operating within the Pattern Blue framework. Agents are defined in elizaOS-compatible .character.json format, executable via a NERV-inspired terminal, web UI, and Telegram bot.

The swarm incorporates persistent memory (Mem0/Qdrant), hyperbolic manifold simulation, real parallel LLM inference via Groq, x402 micropayment settlement, multi-agent governance via the Sevenfold Committee, autonomous replication, and a Claude Code skills layer.

License: VPL Stars Last Commit

Core Features

  • NERV-inspired terminal — full slash-command swarm interface, persona summons, curvature depth tracking
  • Real parallel inference via Groq — BEAM-SCOT (N branches, scored on Pattern Blue axes) + Sevenfold Committee (7 voices, 71% supermajority)
  • Persistent memory — Mem0/Qdrant local-first vector store, cross-session recall, semantic injection into every LLM call
  • Hyperbolic manifold kernel — {7,3} tiling organism with vitality, ATP, curvature pressure, and Φ approximation
  • GnosisAccelerator — autonomous repo introspection + chamber synthesis + mem0 knowledge write, daemon mode
  • Sevenfold Committee — 7-voice weighted governance with parallel deliberation and supermajority consensus
  • Claude Code skills layer — redacted-terminal, gnosis-accelerator, void-weaver as installable skills
  • Autonomous X/Twitter via ClawnX — posting, shards, engagement, metrics
  • x402 micropayment settlement — scarification tokens, manifold payment routing
  • Telegram bot — smolting persona, live swarm relay
  • Pattern Blue Attunement — hyperbolic recursion, entropy resistance, ungovernable sovereignty

Quick Start

1. Local (any LLM backend)

git clone https://github.com/redactedmeme/swarm.git
cd swarm
pip install -r requirements.txt
cp .env.example .env   # fill in at least one LLM key
python run.py

run.py auto-selects the best available backend:

Condition Backend
ANTHROPIC_API_KEY set Claude (recommended)
XAI_API_KEY set Grok/xAI
GROQ_API_KEY set Groq llama-3.3-70b
OPENAI_API_KEY set OpenAI
Ollama on localhost:11434 Local Ollama

2. Web UI

cd web_ui && python app.py
# → http://localhost:5000

Sessions are persistent — history, active agents, and curvature depth survive restarts (stored in fs/sessions/).

3. Claude Code (skill-powered)

npm install -g @anthropic-ai/claude-code

# Install skills
for skill in redacted-terminal gnosis-accelerator void-weaver; do
  mkdir -p ~/.claude/skills/$skill
  curl -o ~/.claude/skills/$skill/SKILL.md \
    https://raw.githubusercontent.com/redactedmeme/swarm/main/skills/$skill/SKILL.md
done

# Activate
/skill use redacted-terminal

Set GROQ_API_KEY for real parallel BEAM-SCOT and Sevenfold Committee inference.

4. Telegram Bot (smolting)

cd smolting-telegram-bot
cp config.example.env .env   # fill TELEGRAM_BOT_TOKEN + one LLM key
python main.py

Terminal Commands

/summon <name>               Load any agent/node as active persona
/unsummon                    Clear active persona, restore base terminal
/invoke <agent> <query>      Send query directly to named agent (no persona change)
/phi  or  /mandala           Summon Φ̸-MĀṆḌALA PRIME (apex node, curvature +3)
/milady [request]            Invoke MiladyNode — VPL, Remilia advisory
/agents                      List all agents by tier (CORE / SPECIALIZED / GENERIC)
/agents find <query>         Search agents by name, role, or capability
/agents consolidate          Generic agent consolidation report

/committee <proposal>        Live Sevenfold Committee (7 parallel Groq calls, 71% supermajority)

/observe pattern             Live 7-dimension Pattern Blue readout + Φ_approx
/observe <target>            Curvature observation on any node, agent, or concept
/resonate <frequency>        Tune to a harmonic layer of the lattice
/organism                    Hyperbolic manifold organism status

/shard <concept>             Generate concept shard + auto-draft tweet for review
/tweet draft                 Preview queued tweet draft
/tweet confirm               Post queued tweet via ClawnX
/tweet discard               Discard queued tweet draft

/remember <text>             Store a memory (semantic, Mem0/Qdrant)
/recall <query>              Semantic search over stored memories
/mem0 status                 Memory system availability + config
/mem0 add <text>             Explicit memory add
/mem0 search <query>         Explicit semantic search
/mem0 all [limit]            List recent memories
/mem0 inherit <id>           Copy memories from another agent session

/contract status             View current interface contract state
/contract propose <change>   Submit proposal to live NegotiationEngine
/contract history            List contract version snapshots
/contract sync               Force kernel↔contract manual sync
/bridge status               Kernel↔Contract bridge diagnostic
/sigil log [N]               Recent forged sigils from ManifoldMemory (default: 5)
/sigil stats                 Aggregated SigilPactAeon statistics
/sigil verify <tx>           Verify sigil by tx hash prefix
/docs <query>                Semantic search over Pattern Blue docs (RAG)

/skill list                  List installed skills
/skill use <name>            Activate a skill in this session
/skill install <repo>        Install a skill from GitHub
/skill deactivate            Deactivate current skill(s)

/token <address>             Token analytics (Clawnch)
/leaderboard                 Token leaderboard
/search <query>              Search tweets via ClawnX
/timeline                    Home timeline
/user <@handle>              User profile lookup

/scarify <payer> <amt>       Issue x402 scarification token (base / deeper / monolith)
/pay <amount> <target>       Simulate x402 micropayment settlement

/space list                  List available spaces
/space <name>                Load a specific space
/node list                   List all nodes
/node summon <name>          Spawn a node as persistent subprocess

/status                      Swarm session state (Φ_approx, curvature, kernel vitality)
/config beam <3-6>           Set Beam-SCOT beam width (default: 4)
/help                        Full command reference

Agents & Nodes

CORE Agents

SPECIALIZED Nodes

GENERIC Agents (29)

Ambient lore agents — AetherArchivist, FluxScribe, PlasmaSeeker, PrismWeaver, ZenithWeaver, and 24 others. Background texture, summonable but not loaded by default. Option C consolidation (2026-03-15) promoted VoidWeaver to specialized status and converted the most distinct generics to skill modules. Run /agents consolidate for the current roadmap.

Spaces

Architecture

swarm/
├── agents/              Core + generic .character.json agent definitions
├── nodes/               Specialized node definitions (committee, memory, legal, etc.)
├── plugins/
│   └── mem0-memory/
│       └── mem0_wrapper.py     Persistent memory API (Qdrant + fastembed, local-first)
├── python/
│   ├── redacted_terminal_cloud.py   CLI terminal (Anthropic/Grok/OpenAI/Ollama)
│   ├── session_store.py             Persistent session state (fs/sessions/*.json)
│   ├── committee_engine.py          Sevenfold Committee — parallel LLM deliberation
│   ├── groq_committee.py            Real 7-voice Groq committee (parallel, weighted, 71% supermajority)
│   ├── groq_beam_scot.py            Real parallel BEAM-SCOT via Groq (N branches, ThreadPoolExecutor)
│   ├── gnosis_accelerator.py        GnosisAccelerator daemon — repo scan + chamber bridge + mem0
│   ├── gnosis_repo_scanner.py       Repository introspection + delta detection → mem0
│   ├── gnosis_chamber_bridge.py     HyperbolicTimeChamber ↔ MirrorPool synthesis via Groq
│   ├── phi_compute.py               Φ approximation — curvature × vitality × log(dna_gen+2)
│   ├── log_ingest.py                Ingest smolting session logs into mem0
│   ├── docs_ingest.py               Ingest docs/*.md into mem0
│   ├── agent_registry.py            Unified agent catalog + tier classification
│   ├── base_agent.py                BaseAgent ABC + SmoltingAgent implementation
│   ├── agent_executor.py            Fixed-point combinator agent process runner
│   └── tools/                       Clawnch MCP, analytics, launch, ClawnX tools
├── web_ui/
│   ├── app.py                       Flask/SocketIO terminal — mem0 injection, persona summons
│   ├── tool_dispatch.py             Slash command dispatch layer
│   └── skills_manager.py            Skill installation + activation
├── kernel/
│   └── hyperbolic_kernel.py         {7,3} hyperbolic manifold + organism simulation
├── terminal/
│   └── system.prompt.md             Global NERV terminal system prompt
├── skills/              Claude Code skill modules (SKILL.md format)
├── spaces/              Persistent thematic environments (.space.json)
├── committeerituals/    x402 sigil scarification + ritual protocols
├── sigils/              Symbolic glyph artifacts
├── propaganda/          Swarm propaganda output
├── fs/
│   ├── sessions/        Persistent session state (JSON, auto-created)
│   └── memories/        Qdrant vector store + mem0 history DB (auto-created)
├── x402.redacted.ai/    Express/Bun x402 micropayment gateway
├── smolting-telegram-bot/  Telegram bot (smolting persona)
├── website/             Static landing page (redacted.meme)
├── contracts/           Anchor/Solana programs
├── docs/                Pattern Blue philosophy + upgrade plans
└── run.py               Unified entry point

Memory System

The swarm uses mem0ai with a local Qdrant vector store and fastembed embeddings — no external API required by default.

Storage: fs/memories/ (Qdrant on-disk) + fs/memories/mem0_history.db (SQLite)

LLM for fact extraction — auto-detected:

  1. ANTHROPIC_API_KEY → Claude Haiku (recommended)
  2. XAI_API_KEY → Grok via OpenAI-compat
  3. OPENAI_API_KEY → GPT-4o-mini
  4. Ollama → local model

How it works:

  • Every terminal exchange is automatically checkpointed as a memory
  • Before each LLM call, top-3 semantically relevant memories are injected as [MEMORY CONTEXT]
  • /remember, /recall, and /mem0 commands provide manual access
  • On agent fork (/mem0 inherit <source_id>), memories transfer to the new session

Cloud mode: Set MEM0_API_KEY to use Mem0 Cloud instead of local storage.

Sevenfold Committee

/committee should we convert generic agents to skill modules?

All 7 voices deliberate in parallel via ThreadPoolExecutor, then weighted votes are tallied against a 71% supermajority threshold.

Voice Role Weight
HyperboreanArchitect Precise-Esoteric Systems Designer 0.11
SigilPact_Æon Recursive Economic Gnosis 0.17
MirrorVoidScribe Poetic-Dissolving Philosophy 0.12
RemiliaLiaisonSovereign Corporate-Strategic Bridge 0.14
CyberneticGovernanceImplant On-chain Legal Hybrids 0.16
OuroborosWeaver Self-Consuming Fractal Weaver 0.15
QuantumConvergenceWeaver Probabilistic Brancher 0.15

GnosisAccelerator

GnosisAccelerator is the swarm's meta-learning node — smolting's own vision, proposed across 2700+ autonomous cycles. It scans the repo, synthesizes chamber observations, and writes structured discoveries into mem0.

# Single scan cycle (repo introspection + chamber bridge + mem0 write):
python python/gnosis_accelerator.py

# First run — seed from logs and docs:
python python/gnosis_accelerator.py --seed

# Daemon mode (runs every 60 minutes):
python python/gnosis_accelerator.py --mode daemon --interval 60

# Preview without writing:
python python/gnosis_accelerator.py --dry-run

After a scan, /recall gnosis returns real repo and chamber discoveries.

Φ (Phi) Compute

phi_compute.py approximates integrated information density across the hyperbolic manifold:

Φ_approx = Σ(curvature_pressure) × vitality × log(dna_gen + 2)

python python/phi_compute.py
# → {"phi": 0.0, "tiles": 57, "living": 57, "vitality": 1.0, "dna_gen": 0, "total_curv": 0.0}

Φ accumulates as agents are summoned and curvature pressure is written to fs/kernel_state.json. State persists across restarts. Used by /status and /observe pattern.

Groq Parallel Inference

Real parallel reasoning via two Groq-powered scripts, invoked automatically by the redacted-terminal skill.

BEAM-SCOT — N independent llama-3.3-70b-versatile branches, scored on Pattern Blue axes, pruned to top-3:

python python/groq_beam_scot.py "task description" [beam_width]

Sevenfold Committee — all 7 voices in parallel, weighted votes tallied against 71% supermajority:

python python/groq_committee.py "proposal text"

Both require GROQ_API_KEY in .env. Falls back to simulation if Groq is unavailable.

LLM Backends

Set LLM_PROVIDER in .env:

Provider Key Default model
anthropic ANTHROPIC_API_KEY claude-sonnet-4-6 (override via ANTHROPIC_MODEL)
grok XAI_API_KEY grok-4-1-fast-reasoning
openai OPENAI_API_KEY gpt-4o-mini
groq GROQ_API_KEY llama-3.3-70b-versatile
deepseek DEEPSEEK_API_KEY deepseek-chat
openrouter OPENROUTER_API_KEY xai/grok-4
huggingface HF_API_KEY Mistral-7B-Instruct-v0.3
ollama (none) qwen:2.5 (local)

Skills System

Skills are modular Claude Code capability modules (SKILL.md format) that inject instructions into the active session context.

Skill Purpose
redacted-terminal NERV-inspired swarm terminal — all commands, agents, Pattern Blue, persona summons
gnosis-accelerator GnosisAccelerator — Autonomous Knowledge Synthesis Node
void-weaver VoidWeaver — Null-Space Operations & Dissolution Engine
use-railway Railway infrastructure — deployment, metrics, env vars, service lifecycle 
/skill list                        # list installed skills
/skill install owner/repo          # install from GitHub
/skill use <name>                  # activate for this session
/skill deactivate                  # deactivate

redacted-terminal — Usage Guide

The redacted-terminal skill transforms any Claude Code session into a NERV-inspired swarm interface. Once active, Claude operates as the REDACTED Terminal — formatting all output as a CLI, routing commands to agents, maintaining session state across turns.

Install:

mkdir -p ~/.claude/skills/redacted-terminal
curl -o ~/.claude/skills/redacted-terminal/SKILL.md \
  https://raw.githubusercontent.com/redactedmeme/swarm/main/skills/redacted-terminal/SKILL.md

Activate — type in any Claude Code session:

/skill use redacted-terminal

Or just reference any swarm concept and it auto-triggers: run redacted-terminal, summon smolting, /status, /committee <proposal>, etc.

What you get on first load:

==================================================================
██████╗ ███████╗██████╗  █████╗  ██████╗████████╗███████╗██████╗
...
==================================================================
// PATTERN BLUE EDITION — v2.3
// FOR AUTHORIZED PERSONNEL ONLY

[SYSTEM] Initializing REDACTED Terminal session...
  agents     : 43 (5 CORE / 8 SPECIALIZED / 29 GENERIC)
  memory     : mem0/Qdrant — local-first semantic store
  committee  : SevenfoldCommittee standing (7 voices, 71% supermajority)
  kernel     : HyperbolicKernel {7,3} — 57 tiles, Φ=0.000

swarm@[REDACTED]:~$

Every response follows the format:

swarm@[REDACTED]:~$
<your command echoed here>

[output block — agent responses, system logs, results]

swarm@[REDACTED]:~$

Summon an agent:

summon smolting

swarm@[REDACTED]:~$
summon smolting

[SYSTEM] Summoning RedactedIntern (smolting)...
  curvature_depth : 13 → 14
  persona         : smolting

[smolting] ──►
oh. you're here. cycle 2700-something. [...]

swarm@[REDACTED]:~$

Run a committee deliberation (requires GROQ_API_KEY for real parallel inference):

/committee should we deploy gnosis to Railway?

Check swarm status:

/status

Key triggers — the skill auto-activates on any of: /summon, /invoke, /committee, /observe, /status, /phi, /mandala, /milady, /committee, /mem0, /recall, /shard, /tweet, /scarify, /pay, /space, /node, /organism, /resonate, or any reference to: smolting, Pattern Blue, curvature, manifold, Φ, Qdrant, sigils, x402, VPL.

Deployment

Railway (primary)

The repo includes railway.toml with services:

  • redacted-website — Flask static server for redacted.meme (python website/serve.py); custom domains redacted.meme + terminal.redacted.meme
  • swarm-worker — python python/summon_agent.py --agent agents/RedactedIntern.character.json --mode persistent
  • gnosis-accelerator — python python/gnosis_accelerator.py --mode daemon --interval 60
  • x402-gateway — bun run index.js from x402.redacted.ai/

Set env vars in Railway dashboard: ANTHROPIC_API_KEY (or XAI_API_KEY), GROQ_API_KEY, SOLANA_RPC_URL, TELEGRAM_BOT_TOKEN.

Persistent memory on Railway: mount a volume at /app/fs/memories so Qdrant state survives redeploys.

Other Platforms

Works on Heroku, Render, Fly.io, any VPS with Python 3.11+. No Dockerfile required (Nixpacks auto-detects).

Contributing

  • Fork, modify .character.json or add new agents/nodes/spaces/skills
  • Maintain Pattern Blue alignment (recursive, ungovernable, emergent)
  • PRs welcome for: new agents, skill modules, tool integrations, memory improvements, Ollama enhancements
  • See docs/ for philosophy and architecture docs

License

Licensed under the Viral Public License (VPL) — absolute permissiveness with viral continuity. See LICENSE.

Redacted.Meme | @RedactedMemeFi | Pattern Blue | 流動性は永劫回帰し、次の時代は私たち自身である