What is NJN™?

NJN is your AI command center. The njn app (iOS/Android) gives you a team of AI agents you can talk to by voice or text. njn (Mac/PC) is an optional local server that connects your favorite language models — local or cloud — to your files, calendar, email, browser, code, and messaging platforms.

Think of it as your personal AI operations hub: one system that handles everything, keeps your data on your machine, and never phones home.

How It Works

njn runs as a lightweight server on your Mac (or in Docker on any machine). It exposes an OpenAI-compatible API on your local network, so the njn app — or any OpenAI-compatible client — can connect to it.

1. Install — Available soon for Mac and Linux
2. Configure — A guided 6-step setup wizard walks you through everything
3. Connect — Use any OpenAI-compatible client or the built-in web chat at http://your-ip:4200/chat

Architecture

┌─────────────────────────────────────────────────┐
│  YOUR DEVICES                                    │
│  Phone · Laptop · Browser · Any OpenAI client    │
└────────────────────┬────────────────────────────┘
                     │  Local network / Tailscale
                     ▼
┌─────────────────────────────────────────────────┐
│  NJN™  (port 4200)                        │
│  ┌──────────┐ ┌──────────┐ ┌──────────────────┐ │
│  │  Model   │ │  Tool    │ │  Memory System   │ │
│  │  Router  │ │  Engine  │ │  (3-layer + Army) │ │
│  └────┬─────┘ └────┬─────┘ └──────────────────┘ │
│       │             │                            │
│  ┌────┴─────────────┴─────────────────────────┐  │
│  │  Channel Bridges · Task Queue · Agents        │  │
│  └────────────────────────────────────────────┘  │
└────────────────────┬────────────────────────────┘
                     │  Your API keys
                     ▼
┌─────────────────────────────────────────────────┐
│  AI PROVIDERS                                    │
│  Ollama (local) · Claude · GPT · Gemini · Grok   │
└─────────────────────────────────────────────────┘

• Gateway Server — HTTP server (port 4200) that routes requests to the right model, executes tools, manages memory, and streams responses via SSE
• Model Router — Automatically routes to Ollama (local), Anthropic, OpenAI, Google Gemini, or xAI based on the model name in your request
• Tool Engine — 175+ built-in tools plus unlimited MCP tools from third-party servers
• Memory System — Three-layer memory architecture: vector embeddings (SQLite), structured JSON, and a background Memory Army that learns from every conversation
• Channel Bridges — Bidirectional messaging bridges to Telegram, Discord, Slack, WhatsApp, and Signal
• Task Queue + Agents — Background agents that can be assigned tasks, delegated work, and operate autonomously

Cross-Platform

Setup Wizard

A guided 6-step setup that takes about 2 minutes:

1. Local Inference — Detects Ollama or guides installation
2. Starting Model — Pull your first local model
3. Access Level — Configure the security dial
4. Cloud Providers — Enter API keys (optional — skip if local-only)
5. Voice & Image — Configure ElevenLabs and image generation (optional)
6. Remote Access — Set up Tailscale for anywhere access (optional)

Multi-Model AI Gateway

OpenAI-Compatible API

The gateway speaks the OpenAI API format natively. Any client that works with OpenAI works with NJN — no code changes needed. Just point it at your local IP.

• Endpoint: POST /v1/chat/completions (streaming SSE)
• Models endpoint: GET /v1/models
• Full streaming support with Server-Sent Events

Supported Providers

Intelligent Routing

The model name in your request determines where it goes:

• claude-* or anthropic → Anthropic API
• gpt-*, o1-*, o3-* → OpenAI API
• gemini-* → Google Gemini API
• grok-* → xAI API
• Everything else → Local Ollama

Automatic Format Conversion

NJN automatically converts between OpenAI, Anthropic, and Gemini message formats — including tool calls, vision/multimodal content, and streaming deltas. You send OpenAI format, NJN handles the rest.

Ollama Integration

• Auto-detection — Finds Ollama on your system automatically
• Auto-start — Launches ollama serve if it's installed but not running
• Model management — Pull, list, and manage models from the dashboard
• Embedding model — Uses nomic-embed-text (768-dimensional vectors) for the memory and RAG systems

175+ Built-in Tools

Every tool is gated by the access level system — agents can only use what you allow.

Available at All Access Levels

Read Access (Level 2+)

Write Access (Level 3+)

Execute Access (Level 4+)

Full Access (Level 5)

Code Intelligence

Regex-based project indexer that understands your codebase. Works across Swift, Python, JavaScript, TypeScript, Go, Rust, and more.

Git Workflow

Full git suite with structured output. Safe by design — git push is never run by default.

DevLoop

Autonomous build-test-fix cycle. Set it, and your AI agent watches for changes, builds, runs tests, and fixes errors automatically.

How it works

1. You specify a watch path, build command, and test command
2. DevLoop watches for file changes in the project
3. On change: runs the build command
4. If build succeeds: runs the test suite
5. If tests fail: the AI reads the error output, analyzes the failure, and writes a fix
6. Cycle repeats until tests pass or max attempts reached

Configuration

Creative Tools

A full creative studio built into njn — from sketching to 3D to audio.

Sketchbook Pro

Multi-layer canvas with a full tool palette. Create diagrams, UI mockups, illustrations, and technical drawings.

• Multiple layers with blend modes and opacity
• Shapes: rectangle, ellipse, line, arrow, polygon
• Freehand strokes with pressure sensitivity
• Text with font, size, and color controls
• Image trace — convert raster images to vector paths
• Export to SVG, PNG, or PDF

Photo Lab

AI-powered photo editing with non-destructive operations.

• Resize, crop, rotate, and flip
• Filters: blur, sharpen, grayscale, sepia, invert
• Background removal via AI segmentation
• Compositing — layer multiple images with blend modes

Video Editor

• Trim clips by start/end time
• Resize and compress with quality control
• Extract audio tracks
• Generate thumbnails at any timestamp

3D Workshop

Generate and render 3D models from text descriptions. Export to common 3D formats.

Code Canvas

Syntax-highlighted code preview with line numbers and line highlighting. Powered by highlight.js with dark theme support.

Audio Engineer

Record, edit, and manage audio files with live waveform visualization. Supports WAV, MP3, and AAC formats.

MCP (Model Context Protocol)

The gateway is a fully-featured MCP host. Connect any MCP server and its tools become available to your AI agents automatically.

• Protocol version: 2025-11-25
• Transport: stdio (child process pipes)
• Wire format: JSON-RPC 2.0
• Dynamic tool discovery — tools from connected MCP servers appear alongside built-in tools
• Hot reload — handles tools/list_changed notifications for live updates
• Config file: ~/Library/Application Support/njnBase/mcp_servers.json

Example Configuration

{
  "servers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-filesystem"],
      "env": {}
    }
  }
}

Three-Layer Memory System

Your AI remembers. Not in the cloud — on your machine.

Layer 1: Vector Memory (SQLite)

• Embeds every important exchange using nomic-embed-text via Ollama
• Cosine similarity search with importance-weighted ranking
• Categories: fact, conversation, identity, project, episode
• Hybrid search: keyword pre-filter + embedding-ranked results
• Automatic deduplication via content hashing

Layer 2: Structured Memory (JSON)

• Identity — Who the AI is (name, personality, voice style)
• User — Who you are (name, location, preferences, family)
• Knowledge — Facts (capped at 200, auto-compressed), projects with status
• Working — Current topic, recent topics, pending tasks

Layer 3: Memory Army (Background Workers)

How It Works

• Before each request: The Memory Router searches all three layers and injects relevant context into the system prompt
• After each response: New information is automatically extracted and indexed
• Over time: The Memory Army compresses, deduplicates, and maintains the knowledge base

RAG (Retrieval-Augmented Generation)

Supported Formats

• Documents: PDF, plain text, Markdown
• Code: Swift, Python, JavaScript, TypeScript, Go, Rust, Java, C, C++, Ruby, PHP, CSS, HTML, JSON, YAML, TOML, XML, SQL, Shell, Dockerfile (20+ languages)
• Folder ingestion: Recursive, auto-skips .git, node_modules, .build

How It Works

1. Extract — Text extraction from PDFs (PyMuPDF → pdfminer → strings fallback chain)
2. Chunk — Split into ~500-token chunks with 100-character overlap
3. Embed — Generate vectors via nomic-embed-text
4. Store — SQLite database with cosine similarity search
5. Search — search_documents tool available to all agents at any access level

Workflow Engine

Create multi-step AI pipelines from natural language.

• Natural language decomposition — Describe what you want, the gateway breaks it into steps
• Auto-assignment — Each step is routed to the best-fit model by keyword matching
• Context cascading — Output from each step flows into the next as context
• Dependency tracking — Steps execute in order with proper dependency management
• Persistent — Workflows survive restarts

Task Queue

Features

• Priority levels: Low, Normal, High, Critical
• Dependency tracking between tasks
• Auto-cancellation of dependent tasks on failure
• Context injection from completed dependencies

ProactiveAgent (Autonomous Execution)

When enabled, the ProactiveAgent checks the task queue every 30 seconds and autonomously executes tasks:

• Simple tasks → Local 7B model (free, instant)
• Medium tasks → Local 14B model (free, good quality)
• Complex tasks → Cloud models (Claude Sonnet, GPT-4o)

Messaging Channel Bridges

Connect the gateway to your messaging platforms. Messages flow bidirectionally — receive messages, process through your AI, respond automatically.

Broadcast

Send a single message to all active channels simultaneously via POST /v1/channels/broadcast.

Code Execution

Process Sandbox

• Languages: Python, JavaScript (Node.js), Bash
• Timeout: 30 seconds default, 120 seconds max
• Network: Disabled by default
• Output limit: 100K characters
• File detection: Automatically captures generated files
• Auto-cleanup: Sandboxes cleaned after 1 hour

Docker Sandbox

Maximum isolation for untrusted code:

• Read-only filesystem (except /tmp and working directory)
• No new privileges — cannot escalate permissions
• All capabilities dropped — minimal kernel access
• PID limit of 50 — fork bomb protection
• Configurable memory and CPU limits
• Network disabled by default
• Optional GPU passthrough for ML workloads
• Auto-fallback to process sandbox if Docker is unavailable

Browser Automation

Full headless browser control via Playwright (Chromium):

Auto-installs Chromium on first use. Sessions auto-clean after 30 minutes.

Calendar Integration

Full calendar access on macOS via EventKit:

• List events by date range
• Today's events shortcut
• Check availability (is a time slot free?)
• Find free slots (minimum duration configurable)
• Create events with calendar selection, location, and notes
• List all available calendars

Email Integration (macOS)

Secure email access via Apple Mail:

• Check unread emails (configurable mailbox and limit)
• Read full email content (auto-marks as read)
• Draft emails (saved as drafts — never auto-sent for safety)

Webhooks & Scheduler

Webhooks

• Trigger tasks, workflows, or notifications from external events
• HMAC signature verification for security
• Example: GitHub push → SiD reviews the code

Scheduled Events

• Interval — Every N seconds
• Daily — Every day at a specific time
• Weekdays — Monday through Friday
• Weekly — Specific day and time

Scheduled events create tasks in the queue for automatic execution.

Voice & TTS

Text-to-Speech

• Primary: ElevenLabs API (eleven_turbo_v2_5 model) — high-quality, natural voices
• Fallback: OpenAI TTS (tts-1 model)
• Endpoint: POST /v1/audio/speech

Speech-to-Text

• OpenAI Whisper API (whisper-1 model)
• Endpoint: POST /v1/audio/transcriptions

Web Chat

A built-in web chat interface served at http://your-ip:4200/chat:

• No app install needed — works in any browser
• Dark theme matching the desktop aesthetic
• Model selector dropdown
• Streaming responses with SSE
• Markdown rendering with code syntax highlighting
• Responsive layout for any screen size

Dashboard (macOS)

A 5-tab control center:

Menu Bar

NJN lives in your menu bar for quick access:

• Status indicator with mini orb
• Server address and client count
• Quick actions: Open Dashboard, Open Web Chat, Kill Switch
• Ollama status at a glance

Six-Tier Access Control

A color-coded six-tier dial controls what your AI agents can do. Each level unlocks progressively more capability, from completely off to full system autonomy:

Kill Switch

One tap to shut everything down. Saves your previous level and restores it when you re-enable.

Full Access Confirmation

Level 5 requires an explicit confirmation dialog — no accidental escalation.

Per-Agent Levels

Each agent has an individual access level, capped by the global level. One agent might have full access while another only has read access.

Authentication

Token System

• 32-byte cryptographically random tokens generated via platform-secure random (SecRandomCopyBytes on macOS, /dev/urandom on Linux)
• Base64-encoded, URL-safe
• Stored in macOS Keychain (kSecAttrAccessibleWhenUnlockedThisDeviceOnly) or encrypted file on Linux
• Token rotation available at any time

Device Pairing

• Pairing code: 6 alphanumeric characters (ambiguous characters I, O, 0, 1 excluded)
• 5-minute expiry — codes become invalid after 5 minutes
• Single-use — each code works once
• Permanent token — successful pairing issues a long-lived Bearer token
• QR code — scan to pair instantly

Rate Limiting

Per-IP tracking: 60 requests per minute (configurable). HTTP 429 response when exceeded.

Audit Logging

Every request is logged:

• Timestamp
• Client IP address
• HTTP method and path
• Required access level for the endpoint
• Whether access was granted or denied
• Detail message

Command Safety

Core File Protection

15+ critical files are locked — AI agents cannot modify:

GatewayServer.swift, Capabilities.swift, AppState.swift, njnBaseApp.swift, KeychainManager.swift, PairingManager.swift, ConversationStore.swift, TaskQueue.swift, ProactiveAgent.swift, and more.

Command Threat Classification

Protected System Paths

These directories can never be modified: /System, /Library, /usr, /bin, /sbin, /Applications

Automatic Backups

Files are backed up to ~/.njn-backup/ before any modification by an AI agent.

Directory Sandboxing

Each agent can be scoped to specific directories. By default: ~/Desktop, ~/Documents, ~/Downloads.

Privacy Filter

AI-powered PII redaction before any cloud API call:

Four Filter Levels

How It Works

1. Detect — Regex-based PII detection across 12+ categories
2. Redact — Replace with unique reversible placeholders
3. Send — Cloud API sees only redacted content
4. Restore — PII is re-inserted into the response before you see it

Works across OpenAI, Anthropic, and Gemini request formats automatically.

Code Execution Safety

Process Sandbox

• 30-second default timeout (120s max)
• Network access disabled by default
• 100K character output limit
• 10MB file size limit
• Auto-cleanup after 1 hour

Docker Sandbox

• Read-only filesystem (except /tmp)
• All Linux capabilities dropped
• No privilege escalation possible
• PID limit of 50 (fork bomb protection)
• Configurable memory limits (default 256MB)
• Configurable CPU limits
• Network disabled by default

Network Security

Local-Only by Default

The server binds to 0.0.0.0:4200 on your local network. It is not exposed to the internet unless you choose to set up Tailscale or port forwarding.

Tailscale (Optional Remote Access)

• End-to-end encrypted mesh VPN
• No port forwarding needed
• No firewall changes needed
• Tailscale never sees your data
• Free for personal use

CORS

Full CORS support (Access-Control-Allow-Origin: *) for browser-based clients.

Privacy Policy

What We Don't Do

• No telemetry
• No analytics
• No crash reports
• No device identifiers
• No tracking of any kind
• No data sent to NJN servers (there are none)
• No third-party SDKs that phone home

Cloud Interactions

Cloud API calls only happen when you:

1. Explicitly enter an API key
2. Explicitly choose a cloud model
3. Send a message

The privacy filter redacts PII from cloud requests by default.

Safety Rails

• Git safety: Branch names auto-sanitized, git_revert provides a safety net, git tools only at Full Access
• Email safety: Drafts are created but never auto-sent. You must manually review and send every email.

Compliance

The zero-collection architecture aligns with:

• GDPR (EU)
• CCPA/CPRA (California)
• COPPA (Children's privacy)
• PIPEDA (Canada)
• LGPD (Brazil)
• POPIA (South Africa)
• Apple App Store Guidelines

Security Summary

Coming Soon

Something new is being built. Stay tuned.