Multi-Agent AI Orchestration Platform — 100% Local & Private

Describe a goal. NEXUS dispatches a team of specialist AI agents — in parallel — and delivers one unified answer.
Run it entirely on your own machine. No cloud dependency. No data leaves your hardware.

Quick Start · Why Self-Host? · Local LLM Setup · Agents · Orchestrator · Architecture · Memory

✦ Overview

NEXUS is not a chatbot. It is a multi-agent runtime where a planner agent decomposes your goals into parallel sub-tasks and dispatches them to specialist agents — a legal researcher, a financial analyst, a career strategist, a medical advisor, a travel architect, an academic tutor, and more — all working simultaneously. Their findings are merged into a single structured response streamed in real-time.

In plain terms: Instead of asking one AI to do everything (like ChatGPT), NEXUS has a team of specialist AIs that work together. Tell it what you need, and it figures out which experts to use, runs them all at the same time, and gives you one combined answer.

✦ 100% Local & Private by Design

NEXUS is built from the ground up as a local-first, self-hosted platform. It is designed to run entirely on your own hardware, ensuring complete privacy, zero external cloud dependencies, and no vendor lock-in.

✦ Why NEXUS?

✦ Why Self-Host?

🔒 Privacy & Data Sovereignty

When you self-host NEXUS, every byte stays on your hardware:

• Conversations and decisions stored in local SQLite databases — never transmitted
• Uploaded documents stay in local file storage — no cloud sync
• Context graph (your profile, preferences, history) lives on your machine
• No telemetry, no analytics pings, no background data collection
• If you use Ollama for LLMs and disable web search, NEXUS can run completely air-gapped — no external network connections at all

💰 Zero Operating Cost

Self-hosting with Ollama means:

• No OpenAI/Anthropic subscription — use free, open-source LLMs
• No per-token costs — pay only for electricity and hardware
• Unlimited usage — no message caps, no rate limits (only your hardware limits)
• Run multiple agents simultaneously — orchestration scales with your hardware

🧠 Model Freedom

Swap models per agent dynamically:

• Use a small fast model (Llama 3.1 8B) for the Planner agent (fast decomposition)
• Use a larger model (Mistral Large, Qwen 72B) for Legal Helper (deep reasoning)
• Use a code-specialized model (DeepSeek Coder) for code execution tasks
• Use a multilingual model (Qwen 2.5) for Hindi/regional language queries
• Switch models whenever you want — no vendor lock-in

⚡ Local OpenClaw — Your Private AI Bridge

The entire Slack × OpenClaw integration runs locally too:

• Deploy OpenClaw alongside NEXUS on the same machine
• All Slack notifications processed locally — no external API
• Works with Ollama for fast, local message handling
• Fully self-contained messaging + AI orchestration stack

NEXUS is designed for the person who values privacy, control, and freedom. Everyone else's AI runs on someone else's computer. Yours runs on yours.

✦ Local LLM Setup (Ollama)

NEXUS supports any LLM provider through OpenRouter, but the recommended setup is to run entirely locally with Ollama.

One-Command Local Setup

# 1. Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# 2. Pull your models (pick what fits your hardware)
ollama pull llama3.1:8b      # Fast, general purpose (~4.7GB)
ollama pull mistral:7b        # Good reasoning (~4.1GB)
ollama pull qwen2.5:7b        # Multilingual, strong on coding (~4.3GB)
ollama pull nomic-embed-text  # For vector embeddings (~274MB)

# 3. Start NEXUS (see Quick Start below)
docker compose up

Model Configuration

Configure which model each agent uses via environment variables:

# ── Use Ollama (local, free, private) ──
MODEL_CHATBOT=ollama/llama3.1:8b
MODEL_LEGAL=ollama/mistral:7b
MODEL_BROKER=ollama/qwen2.5:7b
MODEL_MEDICAL=ollama/llama3.1:8b
MODEL_PLANNER=ollama/llama3.1:8b        # Orchestrator planner
MODEL_EMBEDDINGS=ollama/nomic-embed-text

# ── Or use OpenRouter (cloud models, pay per token) ──
# OPENROUTER_API_KEY=sk-or-xxx
# MODEL_CHATBOT=openrouter/meta-llama/llama-3.1-8b-instruct

Hardware Requirements

💡 Running on CPU only? Use quantized models (e.g., llama3.1:8b-q4_K_M) — they use ~60% less RAM with minimal quality loss.

Running Fully Air-Gapped

For maximum security — no internet connection at all:

# 1. Install everything on an offline machine
# 2. Pull models once while online, then disconnect
# 3. Disable web search in agent config:
DISABLE_WEB_SEARCH=true
# 4. Run with no external dependencies:
docker compose up

No telemetry, no API calls, no data leaving your network. NEXUS becomes a fully self-contained AI platform on your local network.

✦ 11 Specialist Agents

All agents work identically whether you use local Ollama models or cloud models. The experience is the same — only the privacy and cost differ.

✦ The Orchestrator Pipeline

User Goal → Planner Decomposition → Context Assembly
    ↓
Parallel Agent Execution (Promise.all)
    ├── Legal Helper → analyzes notice period rights
    ├── Career Navigator → drafts negotiation strategy
    └── Stock Broker → calculates salary gap & ESOP impact
    ↓
Result Merger → Structured Briefing → Memory Storage → SSE Delivery

How It Works — Step by Step

Key Pipeline Features

• Real-time streaming via Server-Sent Events — watch each agent work live with progress indicators
• Execution trace — see exactly which agents ran, what tools they used, and what they found
• Smart early termination — detects complete answers to exit the loop, saving tokens (relevant even with local models)
• Tool result caching — same tool + args within the same request returns cached result
• Consecutive failure handling with automatic retries across fallback models
• Project awareness — the orchestrator automatically scans for overdue, due-soon, and stalled projects, and injects a check-in task in parallel

✦ Architecture

┌──────────────────────────────────────────────────────────┐
│          YOUR LOCAL MACHINE / SELF-HOSTED SERVER          │
│                                                          │
│  ┌────────────────────────────────────────────────────┐  │
│  │              CLIENT (React + Vite)                  │  │
│  │  ┌──────────┐  ┌──────────┐  ┌───────────────┐    │  │
│  │  │  Chat    │  │   Docs   │  │  Integration   │    │  │
│  │  │  Views   │  │  & APIs  │  │  Page (Slack)  │    │  │
│  │  └────┬─────┘  └────┬─────┘  └───────┬───────┘    │  │
│  │       │             │                │             │  │
│  │       └─────────────┼────────────────┘             │  │
│  │                    │                               │  │
│  │   Framer Motion · Tailwind CSS · Zustand            │  │
│  │   React Router · SSE Streaming Client               │  │
│  └──────────────────┬──────────────────────────────────┘  │
│                     │ HTTP / SSE (localhost only!)         │
│                     ▼                                      │
│  ┌────────────────────────────────────────────────────┐  │
│  │              SERVER (Bun.js + Hono)                 │  │
│  │  ┌──────────────┐  ┌────────────────┐  ┌──────┐  │  │
│  │  │   Router     │  │  OpenClaw      │  │Slack │  │  │
│  │  │   (Hono)     │  │  Bridge (local)│  │ OAuth│  │  │
│  │  └──────┬───────┘  └───────┬────────┘  └──────┘  │  │
│  │         │                  │                      │  │
│  │  ┌──────▼──────────────────▼────────────────────┐  │  │
│  │  │               ORCHESTRATOR ENGINE              │  │  │
│  │  │  ┌──────────┐  ┌───────────┐  ┌───────────┐  │  │  │
│  │  │  │ Planner  │  │  Agent    │  │  Context  │  │  │  │
│  │  │  │ (Ollama) │  │  Loop     │  │  Graph    │  │  │  │
│  │  │  └──────────┘  └───────────┘  └───────────┘  │  │  │
│  │  │  Tool Registry · Memory Service · Project     │  │  │
│  │  │  Style Inferrer · Daily Brief                 │  │  │
│  │  └───────────────────────────────────────────────┘  │  │
│  │                                                      │  │
│  │  ┌──────────────┐  ┌────────────────┐  ┌──────────┐│  │
│  │  │   SQLite     │  │   Ollama        │  │  File    ││  │
│  │  │   Database   │  │   (local LLM)   │  │  Storage ││  │
│  │  └──────────────┘  └────────────────┘  └──────────┘│  │
│  └────────────────────────────────────────────────────┘  │
│                                                          │
│  ┌──── OpenClaw (runs locally too!) ──────────────────┐  │
│  │  Slack Bridge → Polls notifications → Local agent  │  │
│  │  Simple queries handled locally (no LLM needed)     │  │
│  │  Complex queries → local NEXUS orchestrator         │  │
│  └────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────┘

Everything in this diagram runs on your local machine. No cloud services required. No data leaves this boundary.

Tech Stack — All Self-Hosted

✦ Memory & Context Graph

Every interaction feeds into a persistent, cross-agent memory system that every agent reads before responding:

All four layers are stored locally on your machine. Nothing is sent to external servers. Your memory is yours.

What This Enables

• Cross-agent memory synthesis: "Based on your legal query last week and your portfolio analysis, here's what to watch for in your ESOP clause."
• Proactive nudges: "You haven't revisited your apartment search in 5 days and the deadline is approaching."
• Decision pattern mirroring: "When you evaluated your last 3 job offers, stability consistently ranked above salary. Here's how this offer compares."
• Style echo: After enough conversations, the agent adapts to your communication style.

NEXUS gets smarter the more you use it. Every new interaction compounds the system's knowledge. Switch between agents seamlessly — they all read from and write to the same context graph. All of it stays local.

✦ Slack × OpenClaw Integration — Runs Locally Too

NEXUS integrates with Slack through OpenClaw — a persistent AI agent that bridges messaging platforms with multi-agent orchestration. OpenClaw runs alongside NEXUS on the same machine.

What You Can Do from Slack

• Send a DM to OpenClaw with any question — legal, financial, medical, travel
• Use the /nexus slash command in any Slack channel to summon specialist agents
• Receive proactive alerts for overdue projects and approaching deadlines
• Get a daily morning briefing with project status and market updates
• Switch between web app and Slack seamlessly — conversations are remembered
• All messages processed locally — OpenClaw uses the same Ollama instance as NEXUS

Local Architecture Flow

Slack App (your workspace) → OpenClaw Bridge (your machine)
    ↓
Simple queries handled locally (greeting, weather) → instant response
Complex queries → NEXUS Orchestrator (your machine)
    ↓
Multi-agent parallel execution using your local Ollama models
    ↓
Merged briefing streamed back to Slack via your local bridge

Notification System

Security — End-to-End Local

• All bot tokens and webhook URLs encrypted at rest with AES-256-GCM
• Slack OAuth tokens exchanged server-side, never exposed to the client
• HMAC-SHA256 signature verification for Slack slash commands
• Anti-replay protection (5-minute timestamp window)
• Multi-workspace: each Nexus user connects their own Slack workspace independently
• Zero external data transmission when using local models

✦ Quick Start

Option 1: Self-Host with Docker (Recommended)

Get the full local, private experience — all data stays on your machine:

# 1. Install Docker & Docker Compose
#    (https://docs.docker.com/engine/install/)

# 2. Clone the repository
git clone https://github.com/saarlabs/nexus
cd nexus

# 3. Install Ollama and pull models
curl -fsSL https://ollama.ai/install.sh | sh
ollama pull llama3.1:8b
ollama pull nomic-embed-text

# 4. Configure .env — point to your local models
cp .env.example .env
# Set: MODEL_CHATBOT=ollama/llama3.1:8b
# Set: MODEL_EMBEDDINGS=ollama/nomic-embed-text

# 5. Launch everything
docker compose up -d

Open http://localhost:3000 in your browser. That's it. You're running your own local multi-agent AI platform.

Option 2: Try the Hosted Demo (Sandbox Playground)

1. Visit the public demo at saarlabs.in (hosted playground for quick testing)
2. Choose an agent from the sidebar (Legal Helper, Stock Broker, etc.) or type a complex goal
3. Watch agents work — responses stream in real-time with live execution trace
4. Authenticate if you want to save your conversation history, or self-host your own instance for unlimited private access
5. Connect Slack from Settings → Notifications to test proactive alerts

The hosted sandbox demo uses OpenRouter for LLMs. For full privacy and offline execution, use Option 1.

Option 3: Local Development (Full Control)

# Terminal 1: Start Ollama (if using local models)
ollama serve

# Terminal 2: Start NEXUS server
cd server
bun install
bun run dev

# Terminal 3: Start NEXUS client
cd client
npm install
npm run dev

Environment Variables

# ── Required ──────────────────────────────────
# Pick ONE LLM provider:
#   Ollama (local, free, private):
OLLAMA_BASE_URL=http://localhost:11434
MODEL_CHATBOT=ollama/llama3.1:8b
#   OR OpenRouter (cloud, pay per token):
# OPENROUTER_API_KEY=sk-or-xxx

# ── Optional (extended features) ──────────────
DISABLE_WEB_SEARCH=false        # Set true for fully air-gapped operation
TAVILY_API_KEY=                 # Web search (1000 free queries/month)
NEXUS_OPENCLAW_API_KEY=         # Slack integration bridge auth (runs locally)
SLACK_CLIENT_ID=                # Slack OAuth (optional for local-only)
SLACK_CLIENT_SECRET=            # Slack OAuth (optional for local-only)
GOOGLE_CLIENT_ID=               # Google OAuth (optional for local-only)
GOOGLE_CLIENT_SECRET=           # Google OAuth (optional for local-only)
MODEL_PLANNER=                  # Override default LLM model per component
MODEL_LEGAL=
MODEL_BROKER=
MODEL_EMBEDDINGS=ollama/nomic-embed-text    # Local embeddings model

✦ Running Fully Air-Gapped

For environments with zero internet access (secure facilities, remote locations, air-gapped networks):

# 1. On an internet-connected machine, download:
#    - NEXUS source code
#    - Docker images (docker save/load)
#    - Ollama models (ollama pull)
# 2. Transfer everything via USB drive
# 3. On the air-gapped machine:
DISABLE_WEB_SEARCH=true
docker compose up

Result: A fully functional multi-agent AI platform with zero external network dependencies. All LLM inference, vector embeddings, storage, and tools run entirely on the local machine.

✦ API Endpoints

Chat & Orchestration

Context Graph & Memory (all local)

Slack & OpenClaw Bridge (local)

File Processing (all local)

✦ Documentation

✦ Limitations & Honesty

• Legal Helper uses web search (if enabled) or local document analysis to find legal information. It does not have a built-in database of Indian statutes. Always verify important legal matters with a qualified advocate.
• Stock Broker provides educational market data via Yahoo Finance. Not a dedicated Bloomberg terminal or SEBI database. Do not make investment decisions solely on AI advice.
• Medical Core provides educational health information only. Not a substitute for professional medical advice, diagnosis, or treatment.
• File uploads are limited to 20MB per file. Supported: PDF, TXT, CSV, MD, JSON, DOCX, images (JPG, PNG, GIF, WebP).
• Ollama performance depends on your hardware. Larger models (70B+) require significant RAM/VRAM. Quantized models are recommended for resource-constrained setups.
• Web search (Tavily API) requires internet access. Disable with DISABLE_WEB_SEARCH=true for fully local operation.
• Image generation (FLUX) currently requires an external API. When running locally, use the Vision Canvas persona for text-based brand guidance.
• Model fallbacks: If using Ollama and it's not running, the platform will return an error. Ensure ollama serve is running before starting NEXUS.

✦ Repository & Open Source

This project is released under the MIT License and is fully open-source.

Roadmap & Next Steps:

• Contributor guidelines and community issues
• Enhanced self-hosting documentation
• One-command installer (curl | sh)
• Plugin system for custom personas
• CLI tool for headless operation
• Pre-built Docker images for Raspberry Pi / ARM64

🚀 NEXUS is 100% free and open-source. The MIT license gives you the freedom to run, modify, and distribute the project for any purpose — personal, educational, or commercial.

✦ Security

• All data stays local — SQLite databases, uploaded files, context graph — everything on your machine
• No telemetry — NEXUS does not phone home. No analytics, no crash reports, no usage data
• Encryption at rest — all sensitive tokens (Slack bot tokens, webhook URLs) encrypted with AES-256-GCM
• API key authentication — bridge endpoints require X-Nexus-Api-Key header
• Slack OAuth tokens exchanged server-side, never exposed to the client
• HMAC-SHA256 signature verification for Slack slash commands with anti-replay protection
• Air-gap capable — with DISABLE_WEB_SEARCH=true and local LLMs, NEXUS requires zero network connectivity

Self-hosting is the most secure way to use NEXUS. When you run everything locally, there's no data to intercept, no server to breach, no third-party to trust. Your AI platform. Your hardware. Your data. Your rules.

✦ Acknowledgments

• AI Models: Ollama — run LLMs locally, fully offline. OpenRouter — cloud model access when needed
• Icons: Lucide and @dev.icons
• UI Animations: Framer Motion
• Messaging: Slack API
• Inspiration: The open-source AI community. NEXUS is built on the shoulders of Llama, Mistral, Qwen, DeepSeek, and the entire Ollama ecosystem.

An Open-Source Project by Saar Labs
A community-driven, fully self-hostable multi-agent AI orchestration platform
Run it anywhere. Own everything. Trust nothing but your own hardware.

saarlabs.in · Ollama