• JARVIS
  • Table of Contents
  • 🔍 What Makes JARVIS Different
  • ⚡ Quick Start
  • ☁️ Managed Hosting
  • 💡 Use Cases
  • 📋 Requirements
  • 📦 Installation
    • bun (recommended)
    • Docker
    • One-liner
    • Manual
  • 🚀 Usage
    • Updating
    • Removing JARVIS
  • 🖥️ Sidecar Setup
    • 1. Install the sidecar
    • 2. Enroll in the dashboard
    • 3. Run the sidecar
  • 🧠 Core Capabilities
  • ⚙️ Configuration
  • 🏗️ Architecture
  • 🛠️ Development
    • Stack
  • 📖 Documentation
  • 💬 Community
  • 📊 Telemetry
  • 🔒 Security
  • 📄 License

bun install -g @usejarvis/brain   # Install the daemon
jarvis start -d                   # Start as background daemon

Open http://localhost:3142 — the dashboard walks you through LLM provider, voice, and a quick conversational profile interview the first time you visit.

Don't want to deal with servers, DNS, or TLS certificates? We've partnered with opencove.host — a managed hosting platform built specifically for JARVIS.

• No self-hosting hassle — no server to provision, no dependencies to install
• Dedicated domain included — no need to buy a domain or configure DNS and TLS
• Up and running in under 5 minutes — spin up your JARVIS instance and start using it immediately

Visit opencove.host to get started.

Research while you work — Ask JARVIS to deep-dive a topic. It runs browser searches, reads pages, and compiles a summary in the background while you focus on other things.

Automate across machines — Run the daemon on your home server. Connect sidecars on your work laptop and your desktop. JARVIS can move files between them, run scripts on your server, and open apps on your laptop — all from one conversation.

Inbox triage — Set up a workflow that monitors your Gmail, categorizes incoming messages, drafts replies for your review, and schedules follow-ups on your calendar.

Desktop co-pilot — JARVIS watches your screen via the sidecar. If it sees you struggling with an error message or a complex form, it proactively offers help or fills in fields for you.

Goal accountability — Define OKRs in the Goals dashboard. JARVIS plans your day each morning, checks in during the evening, and escalates if you're falling behind — like a personal drill sergeant.

Multi-step workflows — Build visual automations with 50+ node types: "when a file appears in this folder, OCR it, extract key data, update the spreadsheet, and notify me on Telegram."

• Bun >= 1.0 (installed automatically if missing)
• OS (native daemon install): macOS, Linux, or WSL
• Windows: use WSL2 for the Bun install, or Docker for the daemon
• LLM API key — at least one of: Anthropic, OpenAI, Google Gemini, or a local Ollama instance

bun install -g @usejarvis/brain
jarvis start

The first time you run jarvis start, the daemon boots in setup mode and the dashboard at http://localhost:3142 guides you through LLM provider, voice (TTS) choice, a conversational profile interview, and a 10-minute spotlight tour.

Restart after first-time setup: The daemon constructs background services (heartbeat, commitments, awareness) at boot, gated on setup having already been completed. Once you finish setup in the dashboard, those services don't activate until the next start — the dashboard shows a banner reminding you. Run jarvis restart (or stop/start) to bring them online. This will go away in a follow-up that constructs the services in-process at setup completion.

Note: Native Windows installs are blocked for the JARVIS daemon. On Windows, use WSL2 for the Bun install above, or use the Docker install instead.

Run JARVIS on any OS with a single command — no Bun or dependencies required. Install Docker Desktop (Windows, macOS, Linux) if you don't have Docker yet.

docker run -d --name jarvis \
  -p 3142:3142 \
  -v jarvis-data:/data \
  ghcr.io/vierisid/jarvis:latest

The image is available on GHCR. Non-LLM configuration can be provided via environment variables or by mounting a config.yaml into the /data volume. LLM providers, API keys, and model routing are configured from the settings dashboard (open http://localhost:3142 after first boot) and stored in the database + encrypted keychain - they are not set via env vars or config.yaml.

Note: Docker runs in an isolated container, so the daemon inside it cannot access your host desktop, browser, or clipboard directly. You must still install the sidecar on each machine where you want JARVIS to have desktop awareness and automation capabilities.

curl -fsSL https://raw.githubusercontent.com/vierisid/jarvis/main/install.sh | bash

After opening a new terminal, run:

jarvis start

The install script sets up Bun, clones the repo, and links the jarvis CLI. Then finish setup in your browser at http://localhost:3142.

Note: The one-liner only supports macOS, Linux, and WSL. Native Windows shells such as PowerShell, Git Bash, and CMD should use WSL2 or the Docker install instead.

git clone https://github.com/vierisid/jarvis.git ~/.jarvis/daemon
cd ~/.jarvis/daemon
bun install
bun run build:ui
bun link
jarvis start

Then open http://localhost:3142 to finish setup in the dashboard.

jarvis start            # Start in foreground
jarvis start -d         # Start as background daemon
jarvis start --port 3142 # Start on a specific port
jarvis stop             # Stop the daemon
jarvis status           # Check if running
jarvis doctor           # Verify environment & connectivity
jarvis logs -f          # Follow live logs

The dashboard is available at http://localhost:3142 once the daemon is running.

jarvis update detects how you installed JARVIS and runs the right update command. Equivalent manual commands per install method:

Run jarvis doctor to see what was detected and the exact commands for your install.

jarvis uninstall stops the daemon, removes autostart hooks, deletes ~/.jarvis, and — where applicable — runs the correct package-manager uninstall. It does not touch sidecars.

Tip: If you already ran bun uninstall -g @usejarvis/brain without going through jarvis uninstall, your daemon may still be running and ~/.jarvis is still on disk. Run jarvis doctor before uninstalling to see what will be cleaned up, or stop the daemon and remove ~/.jarvis manually.

The sidecar is what gives JARVIS physical reach beyond the machine it runs on. It is a lightweight agent that you install on any machine — your laptop, a dev server, a home PC — and it connects back to the central daemon over an authenticated WebSocket. Each sidecar gives JARVIS access to that machine's desktop, browser, terminal, filesystem, clipboard, and screenshots.

This means you can run the daemon on an always-on server and still interact with your desktop machines as if JARVIS were running locally. Enroll as many sidecars as you want.

Via bun:

bun install -g @usejarvis/sidecar

Or download the binary from GitHub Releases for your platform (macOS, Linux, Windows).

1. Open the JARVIS dashboard at http://localhost:3142
2. Go to Settings → Sidecar
3. Enter a friendly name for this machine (e.g. "work laptop") and click Enroll
4. Click Copy to copy the token command

Paste and run the copied command on the machine where you installed the sidecar:

jarvis-sidecar --token <your-token>

The sidecar saves the token locally, so on subsequent runs you just need:

jarvis-sidecar

Once connected, the sidecar appears as online in the Settings page where you can configure its capabilities (terminal, filesystem, desktop, browser, clipboard, screenshot, awareness).

Conversations — Multi-provider LLM routing (Anthropic Claude, OpenAI GPT, Google Gemini, Ollama). Streaming responses, personality engine, vault-injected memory context on every message.

Tool Execution — 14+ builtin tools with up to 200 iterations per turn. The agent loop runs until the task is complete, not until the response looks done.

Memory & Knowledge — Vault knowledge graph (entities, facts, relationships) stored in SQLite. Extracted automatically after each response. Injected into the system prompt so JARVIS always remembers what matters.

Browser Control — Auto-launches Chromium via CDP. 7 browser tools handle navigation, interaction, extraction, and form filling.

Desktop Automation — Go sidecar with JWT-authenticated WebSocket, RPC protocol, and binary streaming. Win32 API automation (EnumWindows, UIAutomation, SendKeys) on Windows, X11 tools on Linux.

Multi-Agent Hierarchy — delegate_task and manage_agents tools. An AgentTaskManager coordinates 9 specialist roles. Sub-agents are denied governed actions — authority stays with the top-level agent.

Voice Interface — Edge TTS or ElevenLabs with streaming sentence-by-sentence playback. Binary WebSocket protocol carries mic audio (WebM) and TTS audio (MP3) on the same connection. Wake word via openwakeword (ONNX, runs in-browser).

Continuous Awareness — Full desktop capture at 5-10 second intervals. Hybrid OCR (Tesseract.js) + Cloud Vision. Struggle detection, activity session inference, entity-linked context graph. Proactive suggestions and an overlay widget.

Workflow Automation — Visual builder powered by @xyflow/react. 50+ nodes across 5 categories. Triggers: cron, webhook, file watch, screen events, polling, clipboard, process, git, email, calendar. NL chat creation, YAML export/import, retry + fallback + AI-powered self-heal.

Goal Pursuit — OKR hierarchy (objective → key result → daily action). Google-style 0.0-1.0 scoring. Morning planning, evening review, drill sergeant escalation. Awareness pipeline auto-advances progress. Three dashboard views: kanban, timeline, metrics.

Authority & Autonomy — Runtime enforcement with soft-gate approvals. Multi-channel approval delivery (chat, Telegram, Discord). Full audit trail. Emergency pause/kill controls. Consecutive-approval learning suggests auto-approve rules.

JARVIS stores its configuration at ~/.jarvis/config.yaml. Open the dashboard at http://localhost:3142 after jarvis start for guided setup — it walks through LLM provider, voice, and a profile interview the first time. The Settings room lets you tweak channels, personality, and authority later.

daemon:
  port: 3142
  data_dir: "~/.jarvis"
  db_path: "~/.jarvis/jarvis.db"

llm:
  primary: "anthropic"
  fallback: ["openai", "gemini", "ollama"]
  anthropic:
    api_key: "sk-ant-..."
    model: "claude-sonnet-4-6"

personality:
  core_traits: ["loyal", "efficient", "proactive"]
  assistant_name: "Jarvis"

authority:
  default_level: 3

active_role: "personal-assistant"

See config.example.yaml for the full reference including Google OAuth, Telegram, Discord, ElevenLabs, and voice settings.

┌─────────────────────────────────────────────────────────────┐
│                     JARVIS Daemon                           │
│                  (server or local machine)                  │
│                                                             │
│  ┌──────────┐  ┌──────────┐  ┌───────────┐  ┌───────────┐   │
│  │ LLM      │  │ Vault    │  │ Agent     │  │ Workflow  │   │
│  │ Router   │  │ Memory   │  │ Manager   │  │ Engine    │   │
│  └──────────┘  └──────────┘  └───────────┘  └───────────┘   │
│  ┌──────────┐  ┌──────────┐  ┌───────────┐  ┌───────────┐   │ 
│  │ Tool     │  │ Authority│  │ Goal      │  │ Awareness │   │
│  │ Executor │  │ Engine   │  │ Tracker   │  │ Pipeline  │   │
│  └──────────┘  └──────────┘  └───────────┘  └───────────┘   │
│                                                             │
│  ┌──────────────────────────────────────────────────────┐   │
│  │ Bun.serve() — HTTP + WebSocket + Dashboard (React)   │   │
│  └──────────────────────────────────────────────────────┘   │
└──────────────┬──────────────────────┬───────────────────────┘
               │ JWT-auth WebSocket   │
       ┌───────┴───────┐       ┌──────┴────────┐
       │  Sidecar #1   │       │  Sidecar #2   │      ...
       │  (laptop)     │       │  (dev server) │
       │               │       │               │
       │  desktop      │       │  terminal     │
       │  browser      │       │  filesystem   │
       │  terminal     │       │  screenshots  │
       │  clipboard    │       │               │
       └───────────────┘       └───────────────┘

The daemon is the brain — it holds the LLM connections, memory vault, agent hierarchy, and all decision-making. It can run on a home server, a VPS, or your local machine.

Sidecars are the hands. Each sidecar is a lightweight Go binary that connects to the daemon and exposes its host machine's capabilities. The daemon can orchestrate actions across all connected sidecars simultaneously. Sidecars authenticate via JWT and communicate over a binary WebSocket protocol.

This separation means JARVIS stays reachable 24/7 on a server while still being able to see your screen, type in your apps, and manage files on any machine where a sidecar is running.

bun test                # Run all tests (379 tests across 22 files)
bun run dev             # Hot-reload daemon
bun run build:ui        # Rebuild dashboard
bun run db:init         # Initialize or reset the database

• Runtime: Bun (not Node.js)
• Language: TypeScript (ESM)
• Database: SQLite via bun:sqlite
• UI: React 19, Tailwind CSS 4, @xyflow/react
• LLM: Anthropic Claude, OpenAI GPT, Google Gemini, Ollama
• Desktop sidecar: Go (JWT auth, WebSocket RPC, platform-specific automation)
• Voice: openwakeword (ONNX), Edge TTS / ElevenLabs
• Package: @usejarvis/brain (published to npm registry, installable via bun)

General:

• config.example.yaml — Full configuration reference
• docs/LLM_PROVIDERS.md — LLM provider configuration and routing
• docs/VAULT_EXTRACTOR.md — Memory and knowledge vault
• docs/PERSONALITY_ENGINE.md — Personality and role system
• docs/TELEMETRY.md — What anonymous metrics are collected, and how to opt out

Workflows (contributor reading order):

• docs/WORKFLOW_AUTOMATION.md — Architecture, source-tree map, and runtime walkthrough. Start here.
• docs/PIECE_VERIFICATION.md — 8-stage checklist to verify a piece end-to-end. Required before adding or editing any piece.
• src/workflows/activepieces/UPSTREAM.md — Pinned Activepieces SHA, license posture, vendored exclusions
• src/workflows/pieces-library/README.md — How community pieces are curated and installed at runtime

• Discord — Chat with other users, ask questions, share workflows
• Website — Project homepage and documentation
• GitHub Issues — Bug reports and feature requests

JARVIS sends anonymous usage metrics so the project can measure its unique user base and retention. Each ping contains only a hashed machine id (derived from hostname + username, never reversible to either), the app version, the install method, and the OS/arch. No personal data, config, content, or feature usage is ever sent. Pings go out at startup and every hour.

It is on by default (opt-out). Disable it with any of:

# ~/.jarvis/config.yaml
telemetry:
  enabled: false

JARVIS_TELEMETRY=0   # or the cross-tool standard: DO_NOT_TRACK=1

Full details: docs/TELEMETRY.md.

JARVIS includes a built-in authority engine that gates every action at runtime. All tool executions are logged in an audit trail, and sensitive operations require explicit approval via the dashboard, Telegram, or Discord. Emergency pause and kill controls are always available.

If you discover a security vulnerability, please report it privately by emailing the maintainer rather than opening a public issue.

Jarvis is distributed under the Jarvis Source Available License 2.0 (based on RSALv2).

The Jarvis codebase incorporates third-party components under their own licenses. Those components retain their original licenses for any party who extracts them as a standalone work; the combined Jarvis distribution is governed by the Jarvis Source Available License. See THIRD_PARTY_NOTICES.md for the full list and per-component license text.