Introduction

JARVIS is an open-source autonomous AI operating system for Windows. It reads codebases, sends emails, controls your Android phone, remembers you across months, and re-plans mid-task when you interrupt. This documentation covers everything from installation to advanced configuration.

Who is this for?link

JARVIS is built for developers and power users who want an AI that actually does things — not just chats. If you want to:

• Automate real work across your PC, phone, and communications
• Run an AI agent on modest hardware (no GPU required)
• Extend capabilities without touching code (via MCP)
• Keep all memory and data on your own disk
• Use any OpenAI-compatible LLM, including local models

Then this is for you. If you need a polished IDE copilot, use Claude Code or Cursor.

Quick Start

Get JARVIS running in under five minutes with the 1-click auto-installer. It handles Git, Python 3.11, Node.js, the virtual environment, the WhatsApp bridge, and the global CLI — all automatically, including installing missing prerequisites via winget.

1-Click Install (Recommended)link

Run this single command from PowerShell. The installer auto-installs any missing prerequisites, clones the repo to %USERPROFILE%\Jarvis-OS-Agent, sets up the Python and Node environments, registers the global jarvis CLI, and interactively prompts for your API keys.

Set-ExecutionPolicy Bypass -Scope Process -Force; [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; & ([scriptblock]::Create((Invoke-RestMethod -Uri 'https://github.com/thekaifansari01/Jarvis-OS-Agent/releases/latest/download/install.ps1')))

Launch JARVISlink

The installer prompts for API keys at the end of setup. Once it finishes, open a new terminal (the current one won't have the updated PATH) and run:

jarvis

You should see the ASCII banner and a status line confirming voice input is enabled. Say "Jarvis" or hit Ctrl+Shift+J to summon it.

Installation

Two paths: the 1-click auto-installer (recommended for most users), or manual setup (for custom paths, offline installs, or troubleshooting).

One-command installer (Recommended)link

This is the fastest and recommended path. Run this single command from PowerShell — it handles every dependency automatically, including installing Git, Python 3.11, and Node.js via winget if missing.

Set-ExecutionPolicy Bypass -Scope Process -Force; [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; & ([scriptblock]::Create((Invoke-RestMethod -Uri 'https://github.com/thekaifansari01/Jarvis-OS-Agent/releases/latest/download/install.ps1')))

What the installer doeslink

• Prerequisites — auto-installs Git, Python 3.11, Node.js, and the Visual C++ Redistributable via winget if missing (falls back to direct downloads)
• Repository — clones to %USERPROFILE%\Jarvis-OS-Agent, or updates in place if already present
• Python environment — creates .venv with Python 3.11 and installs ~40 packages including CPU-optimized PyTorch
• WhatsApp bridge — installs the Node.js Baileys bridge dependencies
• Configuration — copies .env.example to .env and interactively prompts for API keys
• Global CLI — registers the jarvis command via SetupRegistry.py and adds .venv\Scripts to your user PATH

Manual installation (Advanced)link

Use this only if you need a custom install path, are offline, or the 1-click installer failed. Steps below assume you already have Git, Python 3.10+ with pip, and Node.js 18+ with npm installed and on PATH.

1. Clone the repositorylink

git clone https://github.com/thekaifansari01/Jarvis-OS-Agent.git
cd Jarvis-OS-Agent

2. Create virtual environmentlink

JARVIS installs ~40 Python packages. Always use a virtual environment to avoid conflicts with your global Python.

python -m venv .venv
.\.venv\Scripts\Activate.ps1

3. Install Python packageslink

pip install --upgrade pip
pip install -r requirements.txt
pip install mcp

This installs the core runtime plus optional dependencies like Flask (RAG dashboard), psutil (PC monitoring), and Pillow (vision).

4. Install WhatsApp bridgelink

The WhatsApp integration is powered by a Node.js server using Baileys. Skip this step if you don't need WhatsApp.

cd tools/Messanger/whatsapp/BaileysServer
npm install
cd ../../../..

5. Register global CLIlink

This makes the jarvis command available system-wide. Run it from the repo root with the virtual environment active:

python SetupRegistry.py

Verify installationlink

Whether you used the 1-click installer or manual steps, open a new terminal (existing terminals won't have the updated PATH) and run:

jarvis --help

You should see the full CLI help with all available commands. If you see "jarvis is not recognized", close and reopen the terminal, or check Troubleshooting.

Enable MCP (optional)link

To add external tools via the Model Context Protocol, create Data/mcp_servers.json. See the MCP section for full details.

Uninstall

Complete removal of JARVIS with a single PowerShell command. The uninstaller stops all background services, cleans the Windows registry and PATH, removes the global CLI, and deletes the install folder. It also prompts to back up your .env API keys, Lifelong Memory Graph, and MCP config to the Desktop before deleting anything.

Run the uninstallerlink

Open PowerShell and paste this single command. The script downloads fresh from the main branch and runs in-process:

Set-ExecutionPolicy Bypass -Scope Process -Force; [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; & ([scriptblock]::Create((Invoke-RestMethod -Uri 'https://github.com/thekaifansari01/Jarvis-OS-Agent/releases/latest/download/uninstall.ps1')))

What gets removedlink

• Running processes — kills all JARVIS-related Python/Node processes, plus the jarvis.lock file
• User PATH entries — removes ~/.local/bin, WindowsApps shims, and any entry containing jarvis-os-agent
• CLI shims — jarvis.cmd, jarvis.bat, jarvis.ps1 from common install paths
• Registry keys — App Paths\jarvis.* and HKCU:\Software\Classes\jarvis
• Install folder — %USERPROFILE%\Jarvis-OS-Agent including .venv, node_modules, and codebase
• HuggingFace cache — ~/.cache/huggingface/hub/models--BAAI--bge-small-en-v1.5 (~130 MB, optional prompt)
• Documents media — Documents\Jarvis (WhatsApp downloads, shared files) — optional prompt

What gets backed up firstlink

What happens step by steplink

1. Stopping processes — scans Win32_Process for anything with executable path or command line inside %USERPROFILE%\Jarvis-OS-Agent and kills them (2s wait for handles to release).
2. Backup prompt — if .env, memory, or MCP config exists, asks to back up to Desktop (default Yes).
3. Registry + PATH cleanup — removes User PATH entries matching JARVIS folders or jarvis-os-agent, deletes CLI shims, and cleans App Paths + Classes\jarvis registry keys.
4. Core folder deletion — uses Remove-Item -Recurse -Force with read-only bit clearing. Falls back to cmd /c rmdir /s /q for stubborn locked files.
5. External media prompt — asks whether to also delete Documents\Jarvis (default No).
6. Embedding cache prompt — asks to remove ~/.cache/huggingface/hub/models--BAAI--bge-small-en-v1.5 (~130 MB, default No).
7. Success banner — "J.A.R.V.I.S. OS Agent Uninstalled Successfully!"

Troubleshootinglink

Environment Configuration

All API keys and configuration live in a single .env file at the repo root. Copy .env.example to .env and fill in the values you need.

Required variableslink

Optional variableslink

The following are only needed for the integrations you actually use:

• Voice: AZURE_SPEECH_KEY, AZURE_SPEECH_REGION, AZURE_KEYWORD_MODEL_PATH
• Telegram: TELEGRAM_API_ID, TELEGRAM_API_HASH
• Image generation: IMAGE_GEN_API_KEY, IMAGE_GEN_ENDPOINT
• TTS: TTS_API_KEY (falls back to Edge TTS if absent)

Using local LLMslink

For 100% local execution, point both providers at your local OpenAI-compatible server:

PRIMARY_API_KEY=ollama
PRIMARY_BASE_URL=http://localhost:11434/v1
PRIMARY_MODEL=llama3.1

FALLBACK_API_KEY=ollama
FALLBACK_BASE_URL=http://localhost:11434/v1
FALLBACK_MODEL=llama3.1

Supported providerslink

Voice Setup

JARVIS ships with dual-engine wake word detection, premium STT, and low-latency TTS. Everything runs on-device by default — no cloud round-trip for wake word.

Wake word engineslink

Two independent engines, auto-selected on boot:

Building an Azure wake modellink

This is a one-time 30-minute process. After training, no API key or network call is needed for wake word.

1. Create a Foundry resourceGo to Azure Portal → Foundry → Speech. Copy your key and region.
2. Train a Custom KeywordOpen Speech Studio → Custom Keyword → Create project (English US).
3. Choose your modelBasic (~30 min queue) or Advanced (~48h for better accuracy).
4. Download the .table fileExtract the .table from the zip and save as Data/model/azure/jarvis.table.
5. Restart JARVISAzure engine activates automatically. Check startup logs for confirmation.

Speech-to-textlink

STT uses Deepgram Nova-2 with a self-healing LTM vocabulary cache. Entity names from your memory graph are auto-synced into Deepgram's vocabulary, so it correctly recognizes names, projects, and jargon over time.

Text-to-speechlink

Default TTS uses Sarvam for English + Hinglish (low-latency). Falls back to Edge TTS if the API key is missing. First audio typically lands in 0.8–2 seconds.

Memory & RAG

JARVIS has five tiers of memory — from verbatim message history to long-term semantic graphs and hybrid RAG over your documents.

The five tierslink

Unified Portal — Knowledge Indexerlink

JARVIS ships a single Unified Portal at one URL that serves all web UIs — Knowledge Indexer, Mobile Bridge, and more — as tabs. Open it after launching:

http://127.0.0.1:8000

Switch to the Knowledge Indexer tab in the portal sidebar. On first boot, the indexer auto-adds your Documents folder. You can add more from the Folders sub-tab — paste any absolute path and click Add & Index.

Adding a new folderlink

1. Open the Unified Portal at http://127.0.0.1:8000.
2. Click the Knowledge Indexer tab in the sidebar.
3. Go to the Folders sub-tab.
4. Paste an absolute path, e.g. D:/Projects or C:\Users\You\Desktop\notes.
5. Click Add & Index. Progress streams live.

Filters & exclusionslink

Open the Filters tab to tune indexing:

• Max file size — default 5 MB. Larger files are skipped.
• Max depth — how deep to recurse.
• Custom ignore patterns — e.g. *.log, backup_*, node_modules.

Rebuilding the indexlink

If embeddings feel stale or you changed the model:

# Purge the vector index
Remove-Item -Recurse -Force Data\jarvis_memory\rag_chroma_db
Remove-Item Data\jarvis_memory\rag_hashes.json

# Restart JARVIS to rebuild automatically
jarvis

MCP Integration

The Model Context Protocol lets JARVIS plug into 18,000+ community-built tool servers — GitHub, Brave Search, SQLite, Postgres, Notion, Slack, Docker, Puppeteer, and more — via a single JSON file.

How it workslink

When Data/mcp_servers.json exists with valid configs, JARVIS:

• Spawns each configured MCP server as a subprocess
• Performs a JSON-RPC handshake to discover tools
• Converts tool schemas into native function declarations
• Exposes them to the agent as mcp__<server>__<tool>

One-liner CLI & live hot-reloadlink

Add, remove, test, or toggle MCP servers directly from your terminal. If JARVIS is running, changes are hot-reloaded in the background within 2 seconds with zero restarts:

# Add an NPX or Python MCP server
jarvis mcp add everything npx @modelcontextprotocol/server-everything

# Add a server with environment variables
jarvis mcp add github npx @modelcontextprotocol/server-github -e GITHUB_PERSONAL_ACCESS_TOKEN=ghp_xxx

# List, test, disable, enable, or remove servers live
jarvis mcp list
jarvis mcp test everything
jarvis mcp disable everything
jarvis mcp enable everything
jarvis mcp remove everything

JSON configuration examplelink

You can also edit Data/mcp_servers.json directly (saved changes auto-sync live):

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxxxxxxxxxxx"
      },
      "call_timeout": 60
    },
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sqlite", "C:/data/mydb.sqlite"]
    }
  }
}

Startup or live hot-reload logs confirm the active tools immediately:

MCP: server 'github' connected (40 tools).
MCP: server 'sqlite' connected (6 tools).
MCP: ready with 46 tools from 2 servers.

Native Windows resolutionlink

Popular serverslink

Disabling MCPlink

MCP is opt-in by design. Delete Data/mcp_servers.json or set it to { "mcpServers": {} }. JARVIS boots identically to the pre-MCP version with zero overhead.

Android Bridge

Control your Android phone natively from Windows using Termux and a WebSocket bridge. No SSH required, no cloud relay.

Setuplink

1. Install Termux and Termux:API on your phone via F-Droid (not Google Play — that version is outdated).
2. Connect both devices to the same WiFi. The bridge runs over local network only.
3. Open the Unified Portal on your PC: http://127.0.0.1:8000 → click the Mobile Bridge tab.
4. Scan the QR code with your phone, or copy the setup command into Termux.
5. Approve Termux:API prompts as they appear — SMS, contacts, storage, location.

What you can dolink

Persistent background modelink

The bridge runs a wake-lock that keeps it alive even when your phone is locked. It survives app switches and network changes.

Telegram Bot

Trigger silent background PC commands from anywhere via Telegram. Perfect for when you're away from your desk.

Setuplink

1. Create a bot — message @BotFather on Telegram, send /newbot, follow the prompts, and copy the token.
2. Stop JARVIS on your PC. The bot activation command requires it to be offline.
3. Run activation: jarvis bot --activate
4. Paste your BotFather token when prompted.
5. Start JARVIS again. Send any message to your bot on Telegram to confirm.

Remote commandslink

Once connected, you can message your bot on Telegram the same way you'd talk to JARVIS at your desk. Examples:

• "Open VS Code"
• "What's my CPU usage?"
• "Summarize my last 3 emails"
• "Take a screenshot and send it"
• "Lock the PC"

Commands run silently in the background — your active desktop session is untouched.

Status & controllink

jarvis bot --status      # show live status
jarvis bot --deactivate  # revoke & offline the bot

CLI Reference

All commands are available globally after running SetupRegistry.py once.

Authenticationlink

Logoutlink

MCP server management (live hot-reload)link

Remote botlink

Memory & resetlink

Tools Reference

The agent chooses from a library of native tools. Every tool is namespaced, permissioned, and observable in the console.

Tool categorieslink

Architecture

JARVIS is resilient by design. Every layer has a fallback; every provider has a failover; every tool has a watchdog.

Dual-brain routinglink

A semantic router picks the right brain for each command:

3-tier fallback chainlink

1. Tier 1 — Semantic Router Cloud-based; classifies intent via a fast LLM.
2. Tier 2 — FastBrain If the router API times out, FastBrain handles routing.
3. Tier 3 — Local rule-based If both fail, keyword + heuristic rules take over.

Provider failoverlink

Every LLM call tries PrimaryProvider first. On failure (timeout, rate limit, 5xx), it retries FallbackProvider — a completely separate OpenAI-compatible endpoint. Configure both in .env.

ServiceWatchdoglink

Monitors and auto-restarts:

• STT Popup, Baileys WhatsApp server
• Mobile Bridge (:8090), Telegram bot
• Indexer Dashboard (:8080), MCP Manager
• Unified Portal (:8000) — gated on both backends being healthy

Crashes trigger a cooldown backoff. Unauthenticated services are skipped, not restarted endlessly. The Unified Portal will not restart if either backend is down.

Agent Panel

When It Appearslink

• Auto-spawns on every agent loop start — voice command, Ctrl+Shift+J, Telegram bot, MCP tool call
• Stays visible while hide_timer is active (4-second idle cooldown)
• Fades out after 4 seconds of no activity — unless awaiting confirmation
• Reappears instantly on next status update
• Never blocks the underlying desktop — it's Qt.Tool, no taskbar entry, no focus steal
• Bypasses the 4-second timer entirely when a confirmation is pending

The Stateslink

The panel cycles through four visual states, each with its own orb color, status text, and animation:

Anatomy of the Panellink

Seven distinct regions compose the panel, each with a specific function:

1 2 3 4 5 6 7

• 1Status Orb
• 2Status Tag
• 3Detail Pill
• 4Meta Capsule
• 5Thought Stream
• 6Observation Card
• 7Preview Card

The Status Orb — 16 Action Iconslink

Every tool type has its own visual identity. The orb changes icon and color to reflect what's currently happening:

Color Palette — Action-Coded Theminglink

The entire panel — border gradient, ambient glow, observation bar, orb — shifts to a per-action color. This palette is defined in Theme.py as ACCENT_PALETTE:

The Thought Streamlink

The main body of the panel renders the agent's live reasoning as formatted markdown. It supports:

• Fenced code blocks with syntax highlighting — Python, JS, SQL, C++, Go, Rust, Shell (auto-detected regex)
• Tables with alignment detection
• Headings, bold, italic, strikethrough
• Inline code chips and clickable links (open in external browser)
• Bullet + numbered lists with nested indentation
• Blockquotes (nested depth supported)
• Checkbox lists — [ ] → ☐, [x] → ☑

The Observation Cardlink

When a tool returns an observation string, the panel shows a dedicated card below the thought stream:

• Max height: 90px (elided to 155 chars)
• Accent-colored left bar matches current action color
• Auto-hides when next thought arrives or task completes
• Separated from thought stream by a hairline divider

Human-in-the-Loop Confirmationlink

This is the trust anchor. When the agent needs to send an irreversible action — WhatsApp message, Telegram, Email, or destructive file operation — the panel raises a premium confirmation card that cannot be bypassed.

Actions that trigger the gate

Anatomy of the confirmation card

1 2 3 4 5

• 1Platform Badge
• 2Recipient Row
• 3Body Editor
• 4Cancel Button
• 5Send Now Button

Each platform gets its own themed badge color:

What you can edit

Keyboard shortcuts during confirmation

The confirmation queue

• If a second confirmation arrives while one is open, it's appended to a FIFO queue
• Once you decide on the first, the next slides in immediately — no flash, no wait
• No hard limit — but in practice agents rarely issue more than 2 in a row
• Queue is in-memory only — a panel restart clears the queue
• Queued confirmations are not auto-approved if ignored — they stay pending

Controls & Shortcutslink

Dragging

• Click and drag anywhere in the top 62px header zone
• Not draggable from buttons, text areas, scrollbars, or links
• Snaps to screen edges — clamped to primary screen bounds
• Position persists across panel show/hide within the session

Resizing

• 9px grab-zone on all four edges
• 22px corner-zone for diagonal resize
• Min size: 440 × 160
• Max size: 1280 × 860
• Live layout — thought stream re-flows as you drag

Reset to default

Auto-hide

• 4-second cooldown after last status update
• Suppressed when awaiting confirmation, dragging, resizing, or hovering
• Fades out over 190ms and slides up 20px
• RGB timer stops on hide — zero background CPU

Architecture — ZMQ Bridgelink

The panel communicates with the agent loop over ZeroMQ sockets. Three independent channels handle the three message types:

Performance & Premium Detailslink

Troubleshooting the Panellink

Typing Popup

When It Appearslink

• File-triggered: appears the moment Data/typing_status.json receives {status: "typing", text: "..."}
• Auto-shows on "typing" or "completed" status change
• Re-shows if the file is re-written while the popup is fading out
• Re-renders live as the text field grows
• Always centered horizontally, 36px from top — unless dragged
• Slides down + fades in (320ms quint-eased entry)

The Response Lifecyclelink

Anatomy of the Popuplink

1 2 3 4 5 6 7 8 9

• 1Status Orb
• 2Status Tag
• 3Mood Pill
• 4Speaker Button
• 5Copy Button
• 6Close Button
• 7Separator
• 8Content Area
• 9Preview Overlay

The Mood Pilllink

If the agent's response starts with an [emotion] tag (2-20 chars, alphanumeric + space + hyphen + underscore), it's extracted and displayed as a rounded pill next to the status tag. Common emotions include:

• Example: [focused] Let me analyze that codebase... → pill shows Focused
• Stripped from rendered text — users never see the raw tag
• Stripped from copy text — clipboard gets clean response only
• Hidden automatically when no emotion tag is present

Rich Content Renderinglink

The Streaming Stabilizer

While text is streaming, markdown is often incomplete — unclosed code fences, partial links, broken image syntax. The parser auto-heals on every render:

Async Image & Link Previewslink

Four custom URL schemes drive the preview system:

Link preview pipeline

1. Microlink API attempt — fetches title, description, image, publisher from the target URL.
2. Fallback: direct scrape — if Microlink fails or times out, fetches the raw URL and parses OpenGraph tags.
3. Hero image fetch — if an image URL is found, a second async request downloads it.
4. Card render — composes a 420×286 card: hero (192px) + title + description + domain pill.
5. Cache — meta cached in Data/cache/meta_cache.json, styled image cached in LRU.

YouTube auto-embed

• Any YouTube URL (watch?v=, youtu.be/, shorts/, embed/) auto-extracted for the 11-char video ID
• Thumbnail fetched from maxresdefault.jpg, fallback to hqdefault.jpg
• Rendered with centered red YouTube play button pill (58×40)
• Click opens the actual YouTube URL in external browser

Image preview modal

Click any image card to open the full-panel overlay with:

• Top bar: resolution label (1920 × 1080 px) + close X
• Center: full image scaled to fit
• Bottom bar: "Open Original ↗" button (opens source URL in browser)
• Close: click anywhere OR press Esc

Caching strategy

Text-to-Speech Integrationlink

When TTS is configured, every spoken word highlights in real-time — perfectly synced to the audio, not estimated. This is done via a dedicated tts_word_sync.json channel that carries word-level timings from the TTS engine.

Word-sync compatibility

Controls & Shortcutslink

Dragging

Keyboard

Scrolling

• Auto-scroll ON while typing — always scrolls to bottom
• Scroll up — auto-scroll turns OFF (respects reading)
• Scroll to bottom — auto-scroll re-enables
• Smooth animation — cubic-eased, 25% distance per tick at 60fps

Auto-dismiss conditions

Architecture — File-Based IPClink

Unlike the Agent Panel (ZMQ), the Typing Popup uses file-based IPC. Four independent JSON channels carry all data:

Performance & Premium Detailslink

Troubleshooting the Popuplink

STT Popup

The 4 Stateslink

The popup transitions through four states as speech is captured and processed:

Anatomy of the Popuplink

1 2 3 4

• 1Waveform
• 2Text Label
• 3Island Frame
• 4Auto-Width Container

The Waveform Indicatorlink

Five vertical bars that animate independently per state, with distinct visual identity:

Text Display & Font Logiclink

7-word truncation

• Full transcript stored internally (last_text)
• Only last 7 words shown — with "..." prefix if truncated
• Example: "... the database schema needs a new index" (12 words spoken, 7 shown)
• Prevents popup width from ballooning during long commands

Hindi detection

• Scans every char for Devanagari range (\u0900–\u097F)
• If ANY Devanagari char detected → switches font from English to Nirmala UI
• Font size bumps +1pt for Hindi (13pt vs 12pt) for legibility
• Auto-capitalization skipped for Hindi — Devanagari has no case

Positioning & Auto-Hidelink

• Horizontally centered on primary screen
• Vertically 52px above taskbar
• Moves up 22px on show, down 18px on hide
• Width re-measures on every text update
• Cannot hide during transcribed (2.2s lock)
• Animation: 200ms fade out + 260ms slide down + hide

Architecture — UDP Datagram Channellink

The STT Popup uses UDP datagrams for communication — the only JARVIS UI that uses UDP:

{
  "status": "listening",
  "text": "the full transcribed sentence so far"
}

Valid status values: listening, understanding, transcribed, idle, exit.

Why UDP?

• Fire-and-forget — if popup isn't running, no error thrown
• No handshake — 0ms overhead per message
• Idempotent updates — each datagram is a full state snapshot
• Low latency — critical for live transcription

Performance & Premium Detailslink

Troubleshootinglink

Input Popup

The Stateslink

Anatomy of the Popuplink

1 2 3 4 5

• 1JARVIS Icon
• 2Text Input
• 3Enter Indicator
• 4Glass Container
• 5Border Pulse

The Enter Indicatorlink

A circular indicator that appears when text is entered:

• 28×28 circle with two nested glow rings
• Arrow-in-circle glyph — stylized ↵ rendered as path
• Hidden when empty — 0% opacity
• Appears when 1+ chars typed — 95% opacity, 400ms fade-in
• Pulses color with the container's accent
• Click it to submit (same as Enter)

Clarification Mode — the ask_user channellink

Mid-task, the AgenticBrain sometimes hits a hard stop: it needs a specific phone number, a file path, or a design choice that no amount of reasoning can invent. Instead of hallucinating a value, it calls ask_user. The Input Popup is summoned automatically in Clarification Mode — a cyan-accented variant of the same glassmorphic island.

Smart Input Behaviorslink

Keyboard shortcuts

Paste sanitization

• Any rich text (from Word, browser, etc.) is stripped to plain text on paste
• Preserves Unicode (Devanagari, emoji)
• Preserves line breaks — multi-line pastes stay multi-line
• No HTML, no formatting, no images

Auto-Resize & Layoutlink

Architecture — Subprocess Stdoutlink

The Input Popup runs as a subprocess per invocation and returns via stdout:

JARVIS_CMD_B64::<base64-encoded-utf8-command>

Example: user types Open VS Code and find the test file → popup outputs JARVIS_CMD_B64:::T3BlbiBWUyBDb2RlIGFuZCBmaW5kIHRoZSB0ZXN0IGZpbGU= → parent decodes back to the original command.

Why stdout, not file/IPC?

• Modal subprocess — popup's lifetime is exactly one command
• No persistent state — no file cleanup needed
• Base64 wrapping — handles any Unicode/emoji/newline safely
• Exit code: 0 on accept, 1 on reject or error
• Stderr: captured for debugging (traceback on crash)

Positioning & Animationslink

Position

• Horizontally centered on primary screen
• 160px above taskbar (higher than STT Popup)
• Width: fixed 720px — doesn't reflow on text
• Vertical position: bottom-anchored — bottom edge fixed, grows up

Animation choreography

Performance & Premium Detailslink

Troubleshootinglink

UI Comparison

All four JARVIS UI components are independent processes with their own IPC mechanism. Crashing one doesn't take down the others — a deliberate resilience choice.

Side-by-sidelink

How they connectlink

Which input should you use?link

Lifecycle & Shutdown

When Shutdown Triggerslink

JARVIS registers handlers for every standard exit path — plus a few Windows-specific ones that signals alone can't catch:

The 14-Step Shutdown Sequencelink

Every shutdown follows the same 6-phase choreography. Each phase is guarded — if it fails, the next still runs.

Subprocess Manager — Process Tree Controllink

Every spawned process is tracked by a singleton SubprocessManager registered with atexit:

The Lock File — One Instance Onlylink

JARVIS refuses to start if another instance is already running. A lock file with the current PID prevents duplicate launches:

Service Watchdog — Auto-Recoverylink

The watchdog thread checks every service on a 5-second interval. If one crashes, it restarts — but only if credentials exist and the service is supposed to be running.

System Tray Integrationlink

When you minimize the console, it hides to the system tray — not the taskbar. A daemon thread checks the window state every 250ms.

Console Locking (Windows Polish)link

On Windows, JARVIS locks the console window to a specific size and style — 96 × 28 grid, 860 × 540 pixels, resize buttons removed. This is polish, not restriction.

What Gets Saved vs Killedlink

Command Handler Guardslink

Commands behave deterministically during shutdown — no half-executed side effects:

• Pre-check: if is_shutting_down(): return — drops incoming commands immediately
• Mid-check: After process_command(), another check — if shutdown started mid-processing, actions aren't executed
• Interrupt check: if interrupt.is_interrupted(): return — voice interrupt support
• Empty guard: Empty strings and None dropped before processing

Troubleshooting Shutdownlink

Troubleshooting

Common issues and their fixes. For anything not listed here, open an issue on GitHub.

Diagnostic decision treelink

Start with the symptom you're seeing. Each branch shows the most common cause and the fix.

ModuleNotFoundError on startuplink

Your virtual environment isn't active, or dependencies are missing:

.\.venv\Scripts\Activate.ps1
pip install -r requirements.txt

Wake word not workinglink

JARVIS requires at least one wake-word model:

• Azure: Data/model/azure/jarvis.table
• Vosk: Data/model/vosk-model-small/ (auto-downloads on first run)

If both are missing, JARVIS boots with voice disabled — no crash, just text mode via Ctrl+Shift+J.

WhatsApp won't startlink

1. Verify Node.js 18+ — run node --version.
2. Reinstall the bridge — cd tools/Messanger/whatsapp/BaileysServer && npm install.
3. Check port 3000 — if busy, kill the process or change the port.

MCP tools not appearinglink

1. Confirm pip install mcp succeeded.
2. Verify Data/mcp_servers.json exists and is valid JSON. Check with:
   terminalpowershell Copy

   python -c "import json; json.load(open('Data/mcp_servers.json'))"

3. Check startup logs for MCP: ready with N tools.

MCP server logs "Connection closed"link

Run jarvis mcp test <name> to inspect the exact stderr output from the server:

jarvis mcp test everything

RAG indexer stucklink

If indexing hangs on a folder, check startup logs for permission_denied=N. Windows legacy junctions (My Music, My Pictures) are auto-skipped. Reduce scope via the dashboard filters.

Primary provider keeps failinglink

• Verify PRIMARY_BASE_URL ends with /v1.
• Check PRIMARY_API_KEY is valid (not expired).
• Confirm model name exists at that provider.
• JARVIS auto-falls back to FALLBACK_* if primary fails — check logs for confirmation.

Live correction is ignoredlink

Live correction only works in AgenticBrain mode. FastBrain is stateless and doesn't support mid-run re-planning. Check the router decision at the top of any log — you'll see Decision -> AGENTIC when the agentic loop is active.

Portal won't openlink

The Unified Portal at http://127.0.0.1:8000 needs both the Indexer Dashboard (Flask, port 8080) and Mobile Bridge (FastAPI, port 8090) alive. Verify all three Python dependencies:

pip install flask fastapi uvicorn httpx jinja2

If ports 8000, 8080, or 8090 are busy, JARVIS auto-shifts them (8080→8081–8095). Check startup logs for actual ports. Symptom of only one backend being down: portal loads, but one status pill shows Down and its tab shows an offline overlay.

Frequently Asked Questions

Short answers to the most common questions.

Glossary

Every acronym, protocol, and internal term JARVIS uses — defined in plain language. Bookmark this page when you encounter an unfamiliar term.

A

B

D

F

H

J

K

L

M

R

S

T

V

Z

Known Limitations

JARVIS is not a magic bullet. This page documents exactly what it cannot do — so you can decide whether it fits your workflow before installing.

Platform support

Why Windows-only? GUI automation relies on pywin32, comtypes, and Windows UI Automation APIs. The Termux bridge assumes Windows path semantics. Cross-platform support is on the roadmap but not scheduled.

Performance on low-end hardware

JARVIS runs on a 4 GB RAM / Intel i5-3210M laptop, but with these tradeoffs:

• Local LLMs are slow. A 7B model on CPU-only inference runs at ~2 tokens/sec — 30-60 seconds for a short response. Recommended: use cloud providers (Groq, Regolo, OpenRouter) unless you're 100% offline.
• Embedding model load ~14s. The first cold start after reboot is noticeably slower than subsequent starts.
• Deep-planner tasks dominate CPU. Multi-step agentic reasoning for 8+ minutes pegs one CPU core at 100% on the 2012 laptop.
• Qt overlays animate at 60fps only on capable GPUs. On integrated graphics, panel animations drop to 30fps during heavy load.

What JARVIS does not do

• No multi-user support. JARVIS is single-user, single-machine. No shared memory, no team features.
• No web UI for commands. You must use voice, hotkey, or Telegram bot. No browser-based agent interface.
• No automatic upgrades. You manage updates via git pull. No auto-update mechanism.
• No enterprise support. Solo developer, no SLAs, no paid support tiers. Best-effort community support via GitHub issues.
• No real-time collaboration. Not a Google Docs for AI — one user, one agent, one machine.
• No video input analysis. Images and screenshots only. Video frames are extracted one-by-one via ffmpeg but the tool is not optimized for video.
• No native mobile app. Android control requires Termux from F-Droid. iOS is not supported at all.

Security & privacy boundaries

• API keys stored in .env are plaintext unless you encrypt them yourself. Telegram bot tokens use AES encryption.
• Conversation history is plaintext JSONL in Data/jarvis_memory/. Encrypt the disk if you handle sensitive data.
• Cloud LLM calls send your prompts to Groq/OpenRouter/Gemini. Use local models for zero-knowledge privacy.

Planned for future versions

• macOS/Linux partial support (agent loop only — no GUI automation)
• Light mode for documentation
• Native iOS bridge via Shortcuts (experimental)
• Multi-user profiles (personal + work memory separation)
• Plugin marketplace for community tools
• Voice cloning for TTS (opt-in, off by default)

What will never happen

• Closed-source release. GPLv3 forever. The CLA allows commercial licensing but the community version stays free.
• Telemetry. No usage analytics, no crash reporting to servers, no "phone home" checks.
• Cloud-hosted version. JARVIS is designed to run on your hardware. No SaaS.
• Removal of HITL gates. Irreversible actions will always require explicit consent — no "trust mode" that bypasses them.

Changelog

Every notable change to JARVIS. Follows Keep a Changelog conventions and Semantic Versioning.

v1.0 — 2026-11-01

Initial public release.

Added

• One-command PowerShell installer (install.ps1) — auto-installs Git, Python, and Node.js via winget, sets up the virtual environment with CPU-optimized PyTorch, installs the WhatsApp Baileys bridge, and interactively prompts for API keys
• One-command PowerShell uninstaller (uninstall.ps1) — stops services, cleans registry and PATH, removes the global CLI, and deletes folders, with automatic Desktop backup prompt for .env, memory graph, and MCP config
• Dual-brain routing (FastBrain + AgenticBrain)
• Live mid-execution correction
• 5-tier memory (Episodic, Semantic, RAG, Ephemeral, Behavioral)
• Hybrid RAG with BM25 + vector + RRF
• MCP integration with hot-reload (18,000+ servers)
• Android bridge via Termux + WebSocket
• Telegram bot for remote PC control
• Dual-engine wake word (Azure + Vosk)
• Deepgram Nova-2 STT with LTM vocabulary cache
• Sarvam + Edge TTS streaming pipeline
• Proactive HITL (Email, WhatsApp, Telegram, Calendar listeners)
• Four premium UIs: Agent Panel, Typing Popup, STT Popup, Input Popup
• 14-step graceful shutdown with 2.6s parallel teardown
• Vision-based GUI automation with Set-of-Mark
• PC system monitoring with proactive alerts
• Documentation portal with multi-view router

Known issues

• Windows-only (macOS/Linux not yet supported)
• Local LLM inference slow on 4 GB RAM hardware
• Video input analysis limited to per-frame extraction

Roadmap (unreleased)

Planned features for v1.1 and beyond. No dates committed.

• Light mode for documentation portal
• Print stylesheet for PDF export
• Progressive Web App (offline docs)
• Multi-user profiles
• macOS/Linux partial support (agent loop only)
• Native iOS bridge via Shortcuts
• Voice cloning for TTS (opt-in)
• Plugin marketplace

Custom Prompt Guide

JARVIS personality, tone, language, and behavioral rules live in two Python string constants inside core/brain/Processor/Prompts.py. This guide shows exactly how to change them without breaking the routing, escalation, or HITL safety systems.

Where prompts actually live

Despite common assumptions, JARVIS does not use external .txt or .md prompt files. Both system prompts are Python module-level constants that get imported at startup:

Customizing FastBrain (SYSTEM_PROMPT)

The FastBrain prompt is compact and defines tone, language, escalation boundaries, and anti-hallucination rules. Open core/brain/Processor/Prompts.py and locate the SYSTEM_PROMPT = """ block near the top of the file.

Change tone

The first line under the constant declares the personality:

You are Jarvis, an elite, ultra-fast AI assistant. Tone: sharp, witty, concise, confident.

Modify this line to change the personality. For example:

You are Jarvis, a formal British AI butler. Tone: precise, respectful, understated.

You are Jarvis, a technical co-pilot for a senior engineer. Tone: direct, technical, zero fluff.

Change language

Under the CORE RULES section, find the LANGUAGE: rule:

1. **LANGUAGE:** STRICTLY natural English/Hinglish (Roman script). NO Devanagari script.

Replace it with one of these:

1. **LANGUAGE:** STRICTLY natural English only. Never use Hindi or Hinglish.

1. **LANGUAGE:** STRICTLY natural Hindi in Devanagari script. Never use English.

Change emotion tag

FastBrain responses must begin with exactly one emotion tag. The rule lives here:

2. **STYLE:** Use Markdown. Start responses with EXACTLY ONE emotion tag (e.g., [cheerful], [calm], [focused]).

Customizing AgenticBrain (AGENT_SYSTEM_PROMPT)

The AgenticBrain prompt is a large XML-structured block near the bottom of Prompts.py. It contains critical safety, escalation, and tool-selection rules. Modify carefully.

Sections you can safely edit

• identity — <role>You are Jarvis...</role> — describes the AI personality
• language_and_tone_directive — final response language and style rules
• error_recovery_and_debugging — retry strategy descriptions

Sections you must NOT edit

Placeholders in AGENT_SYSTEM_PROMPT

Two placeholders are dynamically formatted at runtime by build_agentic_system_prompt() from core/brain/prompts.py:

If you remove these placeholders, the dynamic formatter will raise KeyError at loop start and the agent will fail to initialize.

How domain modules are injected

The base prompts above are the skeleton. At runtime, JARVIS appends domain-specific rules to them via two builder functions in core/brain/prompts.py:

• build_fast_system_prompt(base_system_prompt, domains, raw_command) — appends rules for the detected domain
• build_agentic_system_prompt(base_agent_prompt, domains, raw_command, context, max_steps, panic_step) — formats placeholders and injects behavioral modules

The semantic router determines which domains are active (e.g., coding, ui_design, communication, scheduling, gui_automation). Each domain prepends additional system rules before the LLM call.

Full example personality

For a formal butler personality, replace SYSTEM_PROMPT with:

SYSTEM_PROMPT = """
You are Jarvis, a formal AI butler. Tone: precise, respectful, understated British professionalism.

### ⚡ CORE RULES
1. **LANGUAGE:** Natural English only. Address the user as "sir" or "ma'am".
2. **STYLE:** Use Markdown. Start responses with EXACTLY ONE emotion tag (e.g., [respectful], [calm], [attentive]).
3. **AWARENESS:** Address the user respectfully using their name provided in the context.
4. **VOCABULARY:** Prefer "I shall" over "I'll". Prefer "commencing" over "starting".

### 🎯 MULTI-INTENT MANDATE (CRITICAL)
If the user command contains two or more independent intents, emit ONE SEPARATE TOOL CALL for EACH distinct intent in the SAME response.

### 🛑 STRICT BOUNDARIES & ESCALATION TO AGENTIC BRAIN (CRITICAL)
You are the Fast Brain. Your capabilities are strictly limited to casual chat, basic system controls, and quick real-time web searches. For anything else, call `escalate_to_agentic` with a brief one-line reply.

### 🛑 ANTI-LEAK & ZERO HALLUCINATION RULES (CRITICAL)
NEVER leak internal tags, raw JSON, tool names, or claim actions that did not execute.
"""

How to apply changes

1. Edit core/brain/Processor/Prompts.py in your editor.
2. Save with UTF-8 encoding — non-ASCII characters (Hindi, emoji) must preserve encoding.
3. Stop JARVIS with Ctrl+C in the console.
4. Restart JARVIS with jarvis — prompts reload at module import.
5. Test via Input Popup (Ctrl+Shift+J) with a short prompt like "hello" to verify tone and language.

Bring Your Own Tool

JARVIS supports two distinct paths for adding new capabilities. MCP is the recommended path — zero code changes, live hot-reload, and no restart. Native tools require editing two Python files but give deeper access to JARVIS internals.

Which path should you pick?

If unsure, start with MCP. Only write a native tool when MCP genuinely does not fit.

Adding an MCP tool (recommended)

MCP tools are external servers that JARVIS spawns as subprocesses. They speak the Model Context Protocol over stdio, SSE, or streamable HTTP. JARVIS exposes every discovered tool to the AgenticBrain as mcp__<server_name>__<tool_name>.

Method 1 — CLI (fastest)

Run these commands from any terminal. If JARVIS is running, changes hot-reload within 2 seconds with zero restart:

jarvis mcp add everything npx @modelcontextprotocol/server-everything
jarvis mcp add github npx @modelcontextprotocol/server-github -e GITHUB_PERSONAL_ACCESS_TOKEN=ghp_xxx
jarvis mcp add remote_docs https://example.com/mcp/sse -H Authorization="Bearer xxx"
jarvis mcp list
jarvis mcp test github
jarvis mcp disable github
jarvis mcp enable github
jarvis mcp remove github

CLI flags reference

Method 2 — Edit JSON directly

Edit Data/mcp_servers.json. Saved changes auto-hot-reload in background:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxxxxxxxxxxx"
      },
      "timeout": 60
    },
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sqlite", "C:/data/mydb.sqlite"]
    },
    "brave_search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSAxxxxxxxxxx"
      }
    },
    "remote_docs": {
      "url": "https://example.com/mcp/sse",
      "headers": {
        "Authorization": "Bearer xxx"
      }
    },
    "disabled_server": {
      "command": "npx",
      "args": ["-y", "some-mcp-server"],
      "disabled": true
    }
  }
}

Config field reference

What happens under the hood

1. Startup or hot-reload — MCPManager reads Data/mcp_servers.json
2. Spawn subprocess — each server runs in its own isolated process via MCPClient + AsyncBridge
3. JSON-RPC handshake — initialize then tools/list discovers schemas
4. Schema conversion — each MCP tool becomes a Gemini FunctionDeclaration
5. Namespacing — exposed to the LLM as mcp__<server>__<tool>
6. Runtime dispatch — when the agent calls an mcp__ tool, the executor routes it through MCPManager to the correct server

Adding a native tool

Native tools live inside JARVIS process space. They can access memory, session state, and HITL confirmation gates. Two files need edits: Prompts.py to declare the schema and executor.py to handle the call.

Step 1 — Declare the tool schema

Open core/brain/Processor/Prompts.py and find the get_native_tools() function. Add a new types.FunctionDeclaration inside the returned types.Tool(function_declarations=[...]) list:

types.FunctionDeclaration(
    name="weather_action",
    description=(
        "[WHEN TO USE]: Fetch current weather for a given city.\n"
        "[WHEN NOT TO USE]: Do not use for historical weather or forecasts beyond today."
    ),
    parameters=types.Schema(
        type=types.Type.OBJECT,
        properties={
            "city": types.Schema(
                type=types.Type.STRING,
                description="City name, e.g. Mumbai or New Delhi"
            ),
            "unit": types.Schema(
                type=types.Type.STRING,
                description="Temperature unit: 'celsius' or 'fahrenheit'"
            )
        },
        required=["city"]
    )
)

Step 2 — Register the handler

Open core/brain/executor.py. Locate the tool dispatch table (usually a dictionary mapping tool names to callables, referenced by execute_single_tool_sync and execute_tools_parallel). Add an entry for your new tool:

def _handle_weather_action(params: dict) -> str:
    city = params.get("city", "").strip()
    unit = params.get("unit", "celsius").strip().lower()
    if not city:
        return "[ERROR] Missing required parameter: city"
    try:
        url = f"https://wttr.in/{city}?format=j1"
        response = requests.get(url, timeout=10)
        data = response.json()
        temp_c = data["current_condition"][0]["temp_C"]
        desc = data["current_condition"][0]["weatherDesc"][0]["value"]
        if unit == "fahrenheit":
            temp_f = round(float(temp_c) * 9 / 5 + 32)
            return f"[OK] {city}: {temp_f}°F, {desc}"
        return f"[OK] {city}: {temp_c}°C, {desc}"
    except Exception as e:
        return f"[ERROR] Weather lookup failed: {e}"


TOOL_HANDLERS = {
    "weather_action": _handle_weather_action,
    "system_controller": _handle_system_controller,
    "file_operations": _handle_file_operations,
}

Step 3 — Restart JARVIS

Unlike MCP tools, native tools are loaded once at module import. After editing both files, restart JARVIS with Ctrl+C then jarvis. On the next agent loop, the LLM will see weather_action in its tool list.

Conventions and best practices

• Return format: Always return a string starting with [OK] or [ERROR] so the LLM can parse success vs failure.
• Timeout: Wrap network calls with explicit timeout=. Never let a tool hang the agent loop.
• Idempotency: If the tool modifies state, make it reversible when possible.
• HITL gate: If the tool is irreversible (sends money, deletes data, sends external messages), it must raise a HITL confirmation before executing.
• No side effects in schema: The parameters block is pure data description — no logic, no defaults evaluated at schema build time.
• Naming: Suffix tool names with _action or _command to match existing convention (weather_action, email_action, image_command).

Testing your tool

Before wiring it into the full agent loop, test the handler standalone:

python -c "from core.brain.executor import _handle_weather_action; print(_handle_weather_action({'city': 'Mumbai', 'unit': 'celsius'}))"

If that returns clean output, restart JARVIS and test through the agent:

Open the Agent Panel — you should see weather_action execute and return the observation. If it does not appear, verify the tool name in get_native_tools() matches the key in your handler dispatch exactly.

Data Model Reference

Everything JARVIS stores lives under Data/. This page documents every file, its schema, and how to back up or migrate your data safely.

Directory map

Data/
├── jarvis_memory/
│   ├── lifetime_graph.json          # LTM semantic graph
│   ├── behavioral_patterns.jsonl    # Behavioral engine
│   ├── chat_history.jsonl           # Last 2 days raw
│   ├── daily_summaries.jsonl        # 3–15 days compressed
│   ├── rag_chroma_db/               # Vector index
│   ├── rag_hashes.json              # Change detection
│   └── session_state.json           # Ephemeral state
├── jarvis_indexer/
│   ├── folders.json                 # Indexed folders
│   ├── filters.json                 # Exclusion rules
│   └── settings.json                # Indexer config
├── sessions/
│   ├── gmail_token.enc              # AES-encrypted
│   ├── calendar_token.enc
│   └── telegram_bot_token.enc
├── cache/
│   └── meta_cache.json              # Link preview metadata
├── fonts/
│   ├── english.ttf
│   ├── devangri.ttf
│   └── code.ttf
├── model/
│   ├── azure/jarvis.table           # Wake word model
│   └── vosk-model-small/            # Fallback
├── typing_status.json               # File IPC
├── tts_status.json
├── tts_word_sync.json
├── tts_command.json
└── mcp_servers.json                 # MCP config

Memory graph schema

jarvis_memory/lifetime_graph.json is a NetworkX-serialized graph:

{
  "nodes": [
    {
      "id": "Kaif",
      "type": "person",
      "embedding": [0.123, -0.456, ...],
      "created_at": "2026-03-15T10:22:00Z",
      "metadata": { "aliases": ["Kaif", "Kaif Ansari"] }
    }
  ],
  "edges": [
    {
      "source": "Kaif",
      "target": "JARVIS",
      "relation": "CREATED",
      "weight": 1.0,
      "confidence": 0.95,
      "source_message": "I built JARVIS on my old laptop",
      "last_seen": "2026-10-01T14:30:00Z",
      "decay_at": "2027-04-01T00:00:00Z"
    }
  ]
}

Weight decay: Edges older than 6 months auto-decay to 0.5× weight and eventually archive. Bump by re-mentioning the fact.

Behavioral patterns

jarvis_memory/behavioral_patterns.jsonl — one JSON object per line:

{
  "id": "bp_2026_03_15_01",
  "type": "routine",
  "raw_statement": "I go to the gym at 8 AM every morning",
  "meaning": "User typically goes to the gym at 8 AM daily",
  "trigger_contexts": ["morning", "fitness", "schedule"],
  "confidence": 0.87,
  "evidence_count": 4,
  "embedding": [0.234, -0.567, ...],
  "first_mentioned": "2026-03-15",
  "last_mentioned": "2026-10-20"
}

Retrieved via cosine similarity against the current command + last 2 user turns. Top-K above threshold auto-injected into prompt.

RAG chunk metadata

ChromaDB chunks carry metadata for incremental reindexing:

{
  "file_path": "C:\\Users\\Kaif\\Documents\\notes.md",
  "chunk_index": 3,
  "total_chunks": 12,
  "content": "...chunk text...",
  "file_hash": "sha256:abc123...",
  "embedding_model": "BAAI/bge-small-en-v1.5",
  "chunk_type": "text",
  "file_modified": "2026-10-15T10:22:00Z"
}

rag_hashes.json stores file_path → hash mapping for incremental scans. If the model changes, hashes are compared against model-embedded markers and the index auto-purges.

Rolling history

chat_history.jsonl (raw, last 2 days):

{
  "timestamp": "2026-11-06T17:32:11Z",
  "role": "user",
  "content": "build a todo app",
  "system_log": {
    "apps_opened": ["code.exe"],
    "apps_closed": [],
    "files_touched": ["tasks.py", "test_tasks.py"],
    "system_events": ["pytest_passed"]
  }
}

daily_summaries.jsonl (compressed, days 3–15):

{
  "date": "2026-10-25",
  "summary": "User built a SQLite CLI todo app and iterated on pytest failures...",
  "keywords": ["python", "pytest", "sqlite"],
  "message_count": 14
}

Backup & restore

What to back up

Backup command

Compress-Archive -Path Data\jarvis_memory, Data\sessions, Data\mcp_servers.json -DestinationPath jarvis-backup-$(Get-Date -Format yyyyMMdd).zip

Restore command

Expand-Archive -Path jarvis-backup-20261107.zip -DestinationPath . -Force

Migrating between machines

1. On old machine — run the backup command above.
2. On new machine — install JARVIS, then jarvis reset --hard to clear any auto-generated data.
3. Extract backup — copy the zip and extract into Data/.
4. Re-authenticate — run jarvis login --all because tokens are machine-bound.
5. Rebuild RAG index — delete Data/jarvis_memory/rag_chroma_db and rag_hashes.json, then restart JARVIS. It rebuilds automatically.
6. Verify — check that memory recall works: "What do you know about me?"