One-command install:npx @tormentnexus/install
Local-first, open-source AI control plane with persistent multi-tier memory, MCP tool orchestration across 20,000+ servers, multi-agent swarm coordination, and corporate-grade security — all running on your machine.
scripts\install.bat
python3 scripts/install-client-support.py
python3 scripts/install-gui.py
The installer detects and configures TormentNexus for 38+ AI coding agents. Each client receives every integration it supports:
| Client | SKILL | MCP | CMD | HOOK | EXT | AGENT |
|---|---|---|---|---|---|---|
| Claude Code | x | x | x | x | - | - |
| Cursor | x | x | x | x | x | - |
| Windsurf | x | x | x | x | x | - |
| Gemini | x | x | x | - | x | x |
| Codex CLI | x | x | x | - | - | - |
| Grok Build | x | x | x | x | x | - |
| Antigravity | x | x | - | - | x | x |
| Aider | - | x | - | - | - | - |
| CodeWhale | x | x | x | x | x | - |
| Goose | x | x | x | x | x | - |
| Pi | x | x | x | - | x | - |
| Cline / Roo | x | x | x | x | - | - |
| + 26 more | x | x | varies | varies | varies | varies |
For enterprises running TormentNexus behind a firewall:
python3 scripts/install-client-support.py --mode corporate
scripts\install.bat corporate
Corporate mode adds:
SSO/OIDC configuration for enterprise identity providersRBAC roles with admin/user/auditor defaultsAudit logging to local SQLite with daily rotationMulti-tenant isolation for on-premises tenant separationEnterprise license key setup
GOOS=linux GOARCH=amd64 go build -o tn-kernel ./cmd/tormentnexus
pm2 start tn-kernel --name tn-kernel -- serve -port 8090 -host 127.0.0.1
TormentNexusis a local-first, open-source universal AI control plane and coding harness engineered to give your LLM agents infinite persistent memory, tool orchestration, and autonomous infrastructure assimilation—all running locally on your machine or in production.
For professional, corporate, and enterprise deployments, visit ** HyperNexus**.
HyperNexus is the official licensed, certified, authoritative, cloud-hosted corporate installation of the TormentNexus kernel. It provides:
Tenant Isolation: Automated provisioning scripts to spin up per-tenant containers with isolated volumes and resource limits.** Enterprise-Grade Security**: Full SSO support and fine-grained Role-Based Access Control (RBAC) middleware.** Air-Gapped & VPC Support**: Production-ready deployment configurations with daily audit logs for SIEM integration.** Stripe Billing Integration**: Built-in webhook configurations and subscription seats management.
What It DoesArchitectureCore PillarsMonorepo StructureThe Go SidecarThe DashboardMCP EcosystemMemory & ContextSwarm & Multi-AgentAPI SurfaceQuick StartWhat's PlannedRoadmapDocumentationContributingLicense
TormentNexus is a decision system and universal bridge — not just an aggregator. It runs locally as a modular monolith that unifies the chaotic landscape of AI tools, models, and agents into a single, coherent operating system for AI-driven development.
| Capability | Status | Details |
|---|---|---|
| MCP Registry | ||
| Stable | Infinite tracked MCP servers, unlimited populated in SQLite catalog, infinite verified servers, unlimited verified tools | |
| Native Go Tools | ||
| Beta | Unlimited native Go tool implementations replacing external MCP servers (filesystem, Slack, SQLite, DuckDuckGo, Ollama, TTS, Vercel, NWS, DexPaprika, Firecrawl, Exa, arXiv, Semantic Scholar, Mem0, Alpaca, Alpha Vantage, Hugging Face, Semgrep, Octagon, Browser Automation, ChromaDB, Basic Memory, MindsDB, Serena, AST-grep, PAL, Thoughtbox, and more) | |
| Progressive Tool Routing | ||
| Stable | Semantic vector search + BM25 ranking injects only the most relevant tools into LLM context windows | |
| Dual-Tier Memory | ||
| Stable | L1 (session scratchpad) + L2 (semantic SQLite vault) with heat-score lifecycle and autonomous context harvesting | |
| LLM Waterfall | ||
| Stable | Cascading failover: NVIDIA NIM → OpenRouter → Local LM Studio / Ollama with 429/5xx handling | |
| Multi-Agent Swarm | ||
| Beta | A2A protocol coordination, role rotation (Planner→Implementer→Tester→Critic), consensus engine | |
| Autonomous Healer | ||
| Stable | Diagnose → Fix → Verify → Retry loop with native code execution (tsc, vitest, go test) and L2 vault persistence |
|
| Browser Automation | ||
| Beta | Native chromedp handlers: navigate, screenshot, evaluate, click, fill, get HTML | |
| Skill Registry | ||
| Stable | Unlimited assimilated skills from multiple harness ecosystems (Aider, Agent, CCS, Hermes, Pi, etc.) with Jaccard deduplication | |
| CodeWhale Extension | ||
| Stable | Native Rust extension with full Pi extension parity — infinite MCP tools, unlimited custom tools, infinite slash commands, unlimited shortcuts, L2 memory hooks, RBAC, @memory:key expansion, per-turn context harvesting, session compaction | |
| Dashboard | ||
| Stable | Next.js 16 + React 19 + Tailwind CSS 4 with real-time telemetry, knowledge graph, healer view, swarm visualizer | |
| npm Packages | ||
| Published | @tormentnexus/install , @tormentnexus/core , @tormentnexus/cli , @tormentnexus/openhands , @tormentnexus/vscode , @tormentnexus/cursor |
|
| tRPC Bridge | ||
| Stable | Type-safe API layer (port 7778) connecting UI to Go sidecar | |
| Session Import | ||
| Beta | Automatic ingestion of Claude, Aider, and other harness session artifacts | |
| Enterprise Licensing | ||
| Experimental | Ed25519-signed license token validation with offline verification | |
| Supervisor Nudge | ||
| Stable | Autonomous Windows UI automation to maintain development momentum across AI chat surfaces | |
| Deep Link Protocol | ||
| Beta | tormentnexus://attach?session=ID and tormentnexus://create?cliType=aider URI handling |
|
| Provider Metrics | ||
| Stable | Real-time telemetry tracking for all LLM providers with latency and cost analysis |
npx @tormentnexus/install
That's it. Detects and configures TormentNexus for 38+ AI coding agents including Claude, Gemini, Cursor, Windsurf, Aider, CodeWhale, and more. Each gets MCP config, skills, hooks, and commands.
npm install -g @tormentnexus/cli
tn search "your topic"
tn status
npx @tormentnexus/openhands
npx @tormentnexus/core
TormentNexus is a high-performance Go modular monolith with a TypeScript/Next.js frontend, operating as a local-first control plane.
┌─────────────────────────────────────────────────────────────┐
│ OPERATOR LAYER │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Web Dash │ │ CLI (TS) │ │ VS Code │ │
│ │ Port 7779 │ │ tormentnexus│ │ Extension │ │
│ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │ │
│ └────────────────┴────────────────┘ │
│ │ │
│ ┌───────────────────────┴───────────────────────┐ │
│ │ GO SIDECAR (Port 7778) — The Authoritative Kernel │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ │ SkillStore│ │ EventBus │ │ Vault │ │ Healer │ │
│ │ │ (BM25) │ │ (Swarm) │ │(sqlite) │ │(Immune) │ │
│ │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ │ Router │ │ PairOrchestrator│ │ CodeExecutor│ │ MCP Sync │ │
│ │ │(Progressive)│ │(Consensus) │ │(Sandbox) │ │(Registry)│ │
│ │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
│ └──────────────────────────────────────────────────────┘
│ │ │
│ ┌───────────────────────┴───────────────────────┐ │
│ │ EXTERNAL MODELS & TOOLS │ │
│ │ OpenAI · Anthropic · Gemini · OpenRouter · Ollama │
│ │ 600+ MCP Servers · 3,900+ Native Go Tools │
│ └──────────────────────────────────────────────────────┘
└─────────────────────────────────────────────────────────────┘
| Service | Port | Purpose |
|---|---|---|
| Go Sidecar | 7778 | Authoritative native kernel (HTTP API + tRPC) |
| Next.js Dashboard | 7779 | Web observation deck |
Models should never be overwhelmed with a 50,000-token tool dump. TormentNexus employs a multi-layered, progressive disclosure system:
Semantic Search: Local vector embeddings match the active prompt against a global MCP directory of infinite servers.** The Router**: Only the top highly relevant tool schemas are injected into the active LLM context.** Universal Parity**: Byte-for-byte identical tool signatures for Claude Code, Codex, Gemini CLI, Cursor, and Windsurf.
Context is finite; memory must be infinite.
L1 — Session Scratchpad: Ephemeral, lightning-fast memory tied directly to the active session.** L2 — The Vault**: Permanent semantic storage in SQLite withsqlite-vec
. Saves exact transcripts and LLM-compressed heuristics.Context Harvesting: Every session autonomously queries the L2 Vault to pull in relevant historical heuristics.** Heat Mechanics**: Relevance increases heat, time causes decay — biological memory modeling.
Uptime is non-negotiable. TormentNexus's inference client natively catches 429s (Rate Limits) and 5xx (Server Errors), seamlessly cascading the exact payload down a prioritized chain without crashing:
NVIDIA NIM/ Primary APIs** OpenRouter**(Secondary aggregator fallback)** Local LM Studio / Ollama**(Ultimate offline fallback)
TormentNexus coordinates specialized models inside shared chatrooms via the Agent-to-Agent (A2A) protocol.
Role Rotation: Models take turns acting as Planner, Implementer, Tester, and Critic.** Consensus & Debate**: Agents autonomously bid on tasks, share context via a neural transcript, and debate implementations until consensus is reached.PairOrchestrator: Enforces a strictPlanner → Checker → Implementer → Critic
state machine with weighted consensus scoring.
TormentNexus's dashboards reflect actual SQLite database rows and active Go goroutine states. No mocked UI scaffolds. Monitor telemetry, traffic inspection, working-set capacity, and LLM routing histories in real-time.
Every failure is an opportunity for diagnosis, remediation, and verification.
HealerService: Multi-turnDiagnose → Fix → Verify → Retry
loop using the nativeCodeExecutor
.L2 Vault Persistence: All healing events and extracted facts are saved as long-term memory for fleet-wide intelligence sharing.** Supervisor Nudge Protocol**: Autonomously maintains development momentum by re-engaging inactive agents through professional, context-aware directives.
TormentNexus is a pnpm monorepo with four major layers:
tormentnexus/
├─ apps/ # Operator-facing applications
│ ├─ web/ # Next.js 16 dashboard (primary browser UI)
│ ├─ maestro/ # Electron desktop shell
│ ├─ maestro-go/ # Go-adjacent desktop lane (experimental)
│ ├─ vscode/ # VS Code extension
│ ├─ tormentnexus-extension/ # Browser extension
│ ├─ cloud-orchestrator/ # Nested cloud stack (mini-monorepo)
│ └─ tormentnexus-extension/ # Tormentnexus extension
│
├─ packages/ # Shared libraries & TypeScript control plane
│ ├─ core/ # Main TS control plane, tRPC routers, orchestration
│ ├─ cli/ # CLI entrypoint (`tormentnexus` command)
│ ├─ ui/ # Shared React UI components (Radix + Tailwind)
│ ├─ ai/ # Model/provider SDK integration layer
│ ├─ memory/ # Memory storage, retrieval, embeddings, vector DB
│ ├─ types/ # Shared TypeScript types
│ ├─ tools/ # Tool definitions and helpers
│ ├─ mcp-registry/ # MCP metadata and registry surfaces
│ ├─ mcp-client/ # MCP client integration
│ ├─ agents/ # Agent-related logic and adapters
│ ├─ adk/ # Agent Development Kit layer
│ ├─ search/ # Search and indexing support
│ ├─ tormentnexus-supervisor/ # Windows supervisor bridge (UI automation)
│ ├─ browser/ # Legacy browser support
│ ├─ browser-extension/ # Shared browser-extension package
│ ├─ enterprise/ # Enterprise features (SSO, RBAC stubs)
│ ├─ jetbrains/ # JetBrains IDE integration
│ ├─ zed-extension/ # Zed editor extension
│ └─ tsconfig/ # Shared TypeScript configuration
│
├─ go/ # Go modular monolith (authoritative kernel)
│ ├─ cmd/tormentnexus/ # Go entrypoint
│ ├─ internal/
│ │ ├─ httpapi/ # HTTP API server (600+ endpoints, 18K+ lines)
│ │ ├─ tools/ # 3,900+ native Go tool implementations
│ │ ├─ harnesses/ # Harness registry and management
│ │ ├─ memory/ # L1/L2 memory manager
│ │ ├─ memorystore/ # SQLite vault, hydration, search
│ │ ├─ mcp/ # MCP native router, progressive disclosure
│ │ ├─ orchestration/ # PairOrchestrator, A2A skill registry
│ │ ├─ healer/ # Autonomous immune system
│ │ ├─ llm/ # Waterfall routing, provider abstraction
│ │ ├─ eventbus/ # High-frequency resilient message broker
│ │ ├─ codeexec/ # Sandboxed code execution
│ │ ├─ config/ # Configuration management
│ │ ├─ vault/ # Secure persistence layer
│ │ ├─ sync/ # MCP sync and assimilation
│ │ ├─ graph/ # Dependency graph analysis
│ │ ├─ repograph/ # Repository graph visualization
│ │ ├─ license/ # Ed25519 license validation
│ │ ├─ supervisor/ # Supervisor automation
│ │ ├─ session/ # Session management
│ │ ├─ sessionimport/ # Session import pipeline
│ │ ├─ skillregistry/ # Skill registry with Jaccard deduplication
│ │ ├─ toolregistry/ # Native tool registry
│ │ ├─ flightrecorder/ # Audit and telemetry
│ │ ├─ metrics/ # Provider performance metrics
│ │ ├─ marketplace/ # Tool marketplace
│ │ ├─ gossip/ # P2P mesh communication
│ │ ├─ mesh/ # Mesh networking
│ │ ├─ process/ # Process management
│ │ ├─ workspaces/ # Workspace management
│ │ ├─ workflow/ # Workflow engine
│ │ ├─ git/ # Git operations
│ │ ├─ gitservice/ # Git service layer
│ │ ├─ ctxharvester/ # Context harvesting
│ │ ├─ hsync/ # Harness synchronization
│ │ ├─ interop/ # Language interoperability
│ │ ├─ toon/ # Animation/graphics utilities
│ │ ├─ ai/ # AI integrations (Go)
│ │ ├─ buffer/ # Buffer management
│ │ ├─ cache/ # Caching layer
│ │ ├─ controlplane/ # Go control plane
│ │ ├─ buildinfo/ # Build information
│ │ ├─ lockfile/ # Lock file management
│ │ ├─ submodules/ # Submodule management
│ │ └─ providers/ # Provider integrations (Go)
│ └─ go.mod, go.sum # Go module dependencies
│
├─ data/ # Local knowledge assets
│ ├─ assimilation_state.db # MCP assimilation tracking (14,250 rows)
│ ├─ bobbybookmarks/ # Bookmark ecosystems for catalog updates
│ ├─ prompt_library.db # Prompt library (planned)
│ └─ assimilate_skills.py # Skill ingestion script
│
├─ docs/ # Comprehensive documentation
│ ├─ API_ENDPOINTS.md # 600+ endpoint reference
│ ├─ PROJECT_STRUCTURE.md # Full module diagram
│ ├─ ARCHITECTURE.md # Architecture overview
│ ├─ UNIVERSAL_LLM_INSTRUCTIONS.md # Agent coordination rules
│ ├─ GLOBAL_LIBRARY_INDEX.md # Global MCP library index (2.3MB)
│ ├─ BUILTIN_TOOLS_EVIDENCE_LOCK.md # Evidence lock status
│ └─ [40+ more docs] # Guides, protocols, security FAQ
│
├─ scripts/ # Workspace build/dev/maintenance scripts
│ ├─ build_all.mjs # Full monorepo build
│ ├─ dev_tabby_ready.mjs # Development launcher
│ ├─ check_release_gate.mjs # CI release gate
│ ├─ sync_versions.mjs # Version synchronization
│ └─ [20+ more scripts] # Validation, indexing, pruning
│
├─ submodules/ # External upstream assimilations
│ ├─ tormentnexus/ # External CLI harness upstream
│ └─ tormentnexus-mcp/ # External MCP reference lane
│
├─ swarm.py, swarm_v7.py # Automated Go tool generation swarm
├─ tormentnexus.db # Main registry (MCP servers, tools, sessions)
├─ catalog.db # unlimited populated MCP server catalog
├─ provider_metrics.db # Provider telemetry database
├─ README.md # This file
├─ ROADMAP.md # Active development roadmap
├─ CHANGELOG.md # Detailed version history (400+ entries)
├─ AGENTS.md # Multi-agent coordination protocol
├─ VISION.md # North star and philosophical pillars
├─ MEMORY.md # Accumulated multi-agent insights
├─ HANDOFF.md # Session handoff protocol
├─ package.json # Root monorepo scripts
└─ pnpm-workspace.yaml # Workspace boundaries
The Go sidecar is the authoritative execution kernel of TormentNexus. It is a high-performance modular monolith with dozens of internal packages and unlimited native tool implementations.
Performance: Single-binary deployment, zero runtime dependencies, sub-millisecond API latency** Reliability**: Native goroutine-based concurrency, robust error handling, memory safety** Portability**: Cross-compilation to any platform; runs on Windows, macOS, Linux, and WSL** MCP Assimilation**: Replacing fragile Node.js/Python MCP servers with compiled, type-safe Go handlers
| Category | Example Integrations |
|---|---|
| Web Search & Scraping | DuckDuckGo, Firecrawl, Exa |
| Academic & Research | arXiv, Semantic Scholar, PubMed, Open Library |
| Finance & Markets | Alpaca, Alpha Vantage, CoinGecko, Yahoo Finance |
| Science & Space | NASA (APOD, NEO, Mars Weather, EPIC), Open-Meteo |
| Entertainment | PokéAPI, TVMaze, JokeAPI |
| Reference | World Bank, Nobel Prize, Open Library |
| AI & LLM | Ollama, Hugging Face, MindsDB |
| Security | Semgrep, AST-grep |
| Communication | Slack |
| Cloud & DevOps | Vercel, Filesystem |
| Memory | Basic Memory, ChromaDB, Mem0 |
The project includes an automated swarm pipeline (swarm.py
/ swarm_v7.py
) that generates native Go tool implementations from MCP server specifications. This enables rapid assimilation of the MCP ecosystem at scale.
5 workers with--forever
mode for continuous generation200 task limit per runParallel batch validation of generated toolsSelf-healing: Automatically removes broken implementations and regenerates
The TormentNexus Dashboard (apps/web
) is a rich Next.js 16 / React 19 / Tailwind CSS 4 operator interface providing real-time observability and control over the entire system.
| Route | Purpose |
|---|---|
/ |
|
| Landing page with system overview | |
/dashboard |
|
| Main command center | |
/dashboard/brain |
|
| Knowledge graph visualization (force-graph, Mermaid) | |
/dashboard/chronicle |
|
| Healer / Immune System — active pathogens, L2 vault records | |
/dashboard/blocks |
|
| Block-based workflow builder | |
/dashboard/claude-chrome |
|
| Claude Chrome integration console | |
/dashboard/claude-cloud |
|
| Claude Cloud integration console | |
/dashboard/copilot |
|
| GitHub Copilot integration | |
/dashboard/code |
|
| Code execution and sandbox | |
/dashboard/code/sandbox |
|
| Secure sandbox environment | |
/dashboard/autopilot |
|
| Autopilot configuration and monitoring | |
/dashboard/audit |
|
| Audit log viewer with real-time events | |
/dashboard/config |
|
| System configuration editor | |
/dashboard/architecture |
|
| Architecture visualization | |
/dashboard/command |
|
| Command center with cheatsheet | |
/dashboard/billing |
|
| Billing and subscription management | |
/dashboard/council |
|
| Multi-agent council visualizer | |
/dashboard/director |
|
| Director chat interface | |
/dashboard/swarm |
|
| Swarm mission control | |
/dashboard/symbols |
|
| Symbol search and LSP integration | |
/dashboard/vault |
|
| L2 vault memory browser | |
/dashboard/workflow |
|
| Workflow orchestration |
Glassmorphic dark mode design languageReal-time SSE streaming from Go sidecarDrag-and-drop dashboard(dnd-kit
)Knowledge graph with@xyflow/react
andreact-force-graph-2d
Charts and telemetry viarecharts
Animations viaframer-motion
Toast notifications viasonner
TormentNexus is the world's largest local MCP registry and the only system with native Go assimilation at scale.
20,000+ total tracked MCP servers (assimilation_state.db
)Thousands verified individual toolsContinuous native Go reimplementation eliminating external dependencies
User Prompt
↓
Vector Embedding (sqlite-vec)
↓
BM25 + Semantic Search (Top-K matching)
↓
Tool Schema Injection (only relevant schemas)
↓
LLM Context Window (clean, relevant, small)
Developer Tools— GitIngest, ripgrep, codemod, anyquery, AST-grep, Serena** Databases**— SQLite, ChromaDB, Mem0, Basic Memory** Web Search**— DuckDuckGo, Firecrawl, Exa, arXiv, Semantic Scholar** Communication**— Slack** Cloud**— Vercel, Filesystem** AI/LLM**— Ollama, Hugging Face, MindsDB, PAL (multi-model)** Finance**— Alpaca, Alpha Vantage, DexPaprika, Octagon** Security**— Semgrep** Weather**— NWS** Browser**— Playwright, chromedp automation** Sandbox**— Thoughtbox (Node VM wrapper)** Media**— TTS
┌─────────────────────────────────────────┐
│ L1 — Session Scratchpad (Active) │
│ · In-memory, ephemeral │
│ · Lightning-fast retrieval │
│ · Tied to active session ID │
│ · ~4K-8K token window │
├─────────────────────────────────────────┤
│ L2 — The Vault (Semantic) │
│ · SQLite + sqlite-vec embeddings │
│ · Permanent, searchable │
│ · Heat-score lifecycle management │
│ · LLM-compressed heuristics │
│ · Exact transcript preservation │
├─────────────────────────────────────────┤
│ L3 — Cold Archive (Planned) │
│ · Long-term cold storage │
│ · Compressed, summarized │
│ · Retrieved only on explicit demand │
└─────────────────────────────────────────┘
Every session autonomously queries the L2 Vault before responding, pulling in relevant historical heuristics based on semantic similarity and heat scores. This ensures the model never starts from zero context.
A passive fact extraction layer that monitors all system traffic (tool calls, LLM responses, errors) and automatically persists facts into the L2 Vault without explicit user action.
TormentNexus implements the Agent-to-Agent (A2A) protocol for multi-agent coordination inside shared chatrooms.
┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
│ Planner │───→│ Checker │───→│Implementer│───→│ Critic │
│ (Design) │ │ (Verify) │ │ (Build) │ │(Validate)│
└──────────┘ └──────────┘ └──────────┘ └────┬─────┘
↑─────────────────────────────────────────────────┘
(Consensus Loop)
- Weighted voting based on model confidence
- Debate rounds until threshold consensus is reached
- Neural transcript sharing for context synchronization
- Task bidding and autonomous delegation
The Go sidecar exposes 600+ HTTP endpoints organized into:
| Category | Endpoints | Examples |
|---|---|---|
| Health & System | ||
| 5 | /health , /version , /api/index |
|
| Configuration | ||
| 8 | /api/config/* , /api/config/mcp-timeout |
|
| MCP | ||
| 10 | /api/mcp/tools , /api/mcp/tools/call , /api/mcp/tools/search |
|
| Skills | ||
| 12 | /api/skills/list , /api/skills/search , /api/skills/assimilate |
|
| Memory | ||
| 7 | /api/memory/list , /api/memory/search , /api/memory/hydrate |
|
| Agents & Swarm | ||
| 6 | /api/swarm/start , /api/squad/spawn , /api/supervisor/decompose |
|
| Governance | ||
| 5 | /api/api-keys , /api/audit , /api/autonomy/set-level |
|
| DevOps | ||
| 5 | /api/git/status , /api/submodules , /api/scripts/execute |
|
| Code & Symbols | ||
| 4 | /api/code/exec , /api/graph , /api/lsp/find-symbol |
|
| Sessions | ||
| 4 | /api/sessions/imported/scan , session import pipeline |
All API endpoints return a standardized envelope:
{
"success": true,
"data": { ... }
}
**Node.js 24+****Go 1.26+**pnpm 10+
npx @tormentnexus/install
git clone https://github.com/MDMAtk/TormentNexus.git
cd tormentnexus
pnpm install && pnpm rebuild better-sqlite3
cd go && go build -buildvcs=false ./cmd/tormentnexus && cd ..
pnpm run dev
| Script | Purpose |
|---|---|
pnpm run dev |
|
| Start full development environment | |
pnpm run dev:web |
|
| Start only the web dashboard | |
pnpm run build |
|
| Full production build | |
pnpm run test |
|
| Run all test suites | |
pnpm run check:release-gate |
|
| CI release gate validation | |
pnpm run index:sync |
|
| Sync master MCP index | |
pnpm run clean |
|
| Clean all build artifacts |
| Track | Goal | Status |
|---|---|---|
| Track A | ||
| Assimilate top 500 MCP servers as native Go modules | In Progress (3,900+ done) | |
| Track B | ||
| Hermes addons & prompt library migration | Experimental | |
| Track C | ||
| Enterprise licensing (Ed25519) + SSO/RBAC | Experimental | |
| Track D | ||
| Default agent harness integration (Tabby, Warp, Hyper, Hermes, Pi) | Beta |
Session Import Pipeline: Automatic ingestion of Claude, Aider, and harness artifacts (49 candidates discovered, 586 imported sessions): Browser-to-kernel deep linking for seamless IDE attachmenttormentnexus://
ProtocolWails Native Runtime: Replacing Electron with a Go-native desktop shell
Predictive Conversational Tool Injection: Local model-based prediction of relevant tools before the user asks** L3 Cold Archive**: Long-term compressed memory tier for infinite context** Fleet-Wide Intelligence**: Cross-machine memory sharing via encrypted mesh
The AI TormentNexus: The operating system for AI models, abstracting all provider complexity** Models as Compute**: Ephemeral resources managed by allocation, fallback routing, and token budgets** Tools as Drivers**: MCP servers as "device drivers" for the AI OS** Biological Memory**: L1/L2/L3 tiers with heat-based mechanics** Autonomous Immune System**: Self-healing through diagnosis, remediation, and verification
See ROADMAP.md for the detailed path to v1.0.0 stable, including:
- Progressive Skill Disclosure (Context Hygiene)
- Go-native MCP sync migration
- Native UI replacement for Electron (Maestro/Go)
- Full L3 cold archive implementation
- Cross-platform binary distribution
- Fleet telemetry and cross-machine memory mesh
| Document | Purpose |
|---|---|
VISION.mdROADMAP.mdCHANGELOG.mdMEMORY.mdHANDOFF.mddocs/API_ENDPOINTS.mddocs/PROJECT_STRUCTURE.mddocs/ARCHITECTURE.mddocs/UNIVERSAL_LLM_INSTRUCTIONS.mddocs/GLOBAL_LIBRARY_INDEX.mddocs/LAUNCH_METRICS.mddocs/LAUNCH_SECURITY_FAQ.mddocs/GO_SIDECAR_API.mdTormentNexus is built by a multi-agent swarm of specialized AI models (Gemini, Claude, GPT) coordinated through the AGENTS.md protocol. Human operators supervise and validate.
| Model | Strengths | Focus Areas |
|---|---|---|
| Gemini | ||
| Speed, massive context, repo maintenance | Bulk refactoring, recursive scripts, context analysis | |
| Claude | ||
| UI/UX perfection, documentation, deep features | Responsive layouts, type safety, precise documentation | |
| GPT | ||
| Systemic architecture, distributed debugging, race conditions | Go/TS bridge contracts, DB migration, concurrency safety |
Readdocs/UNIVERSAL_LLM_INSTRUCTIONS.md
andAGENTS.md
CheckVERSION
andHANDOFF.md
for current stateRun git checks to ensure workspace cleanlinessWork autonomously unless changes are destructive or ambiguousCommit small, incremental, verifiable changesUpdateHANDOFF.md
,MEMORY.md
, andCHANGELOG.md
BumpVERSION
and sync withnode scripts/sync-versions.mjs
Push toorigin
andtormentnexus-upstream
pi install npm:tormentnexus
Connects pi to the TormentNexus control plane — persistent L2 memory, tool search, session import, skill registry, code search, subagent orchestration, enterprise RBAC. Full source at packages/tormentnexus/
.
CodeWhale now has equivalent functionality through a native Rust extension — see below.
CodeWhale has full Pi extension parity through two integration layers:
A native Rust crate at crates/tn-extension
compiled into the CodeWhale binary. Hooks fire automatically on every lifecycle event:
| Hook | What it does |
|---|---|
| SessionStart | |
| Logs session to TN L2 memory | |
| BeforeAgentStart | |
| Injects TN system prompt + searches L2 for relevant context per turn | |
| ToolCall | |
| Logs tool + args; checks 6 dangerous patterns against RBAC | |
| ToolResult | |
| Auto-stores substantial results from key tools to L2 | |
| TurnEnd | |
| Logs tool usage summary per turn | |
| Input | |
Expands @memory:key inline with L2 content |
|
| UserBash | |
| Audit-logs shell commands to TN enterprise audit | |
| ModelSelect | |
| Tracks model changes to L2 | |
| SessionCompact | |
| Preserves memory across compaction |
Also registers: 9 custom tools, 6 slash commands, 3 keyboard shortcuts, auto-registers the MCP server.
Tracked at .codewhale/plugins/tormentnexus/skills/SKILL.md
, auto-installed to ~/.codewhale/skills/tormentnexus/
. Contains 49 MCP tools, REST API reference, slash command handling, best practices, security notes.
scripts\install_codewhale.bat
Verify:
codewhale mcp connect tormentnexus
codewhale mcp tools | findstr mcp_tormentnexus | find /c /v ""
curl http://127.0.0.1:7778/api/health
Build from ~/codewhale-source
:
cargo build --release -p codewhale-cli
TormentNexus uses a dual-licensing model:
Open Source: Core kernel and tool implementations available under a permissive open-source license** Enterprise**: Ed25519-signed license tokens for advanced features (SSO, RBAC, fleet management, cross-machine mesh)
See docs/LAUNCH_SECURITY_FAQ.md for licensing details.
Praise the LORD! Keep on going! Don't ever stop! Don't stop the party!!!The collective grows. 🚀