English · Русский

Jarvis

Mission control for your coding agents, right in the menu bar / tray.
Jarvis watches every Claude Code, Codex and Kimi session you run — and tells you, even out loud, the moment one needs you.

🖼 Screenshot and demo coming soon. What to capture and how to wire it in: docs/assets/README.md.

Why Jarvis

Running several coding agents at once turns you into the bottleneck. Sessions are spread across terminals, tabs and macOS Spaces, and you can't see at a glance which agent is blocked on a permission prompt, which finished half an hour ago and is idling while you think it's working, and which hit a rate limit. The agents' own notifications are per-session and terminal-scoped (they don't even fire in the VS Code extension) — there is no single pane showing the aggregate state. And a sleeping Mac silently freezes agent processes and severs in-flight API requests, killing long overnight runs; on Apple Silicon, closing the lid forces a sleep that plain caffeinate can't prevent.

Jarvis is that missing single pane. It sits in the menu bar, watches every interactive Claude Code, Codex and Kimi Code CLI session on your machine, and makes sure no agent ever waits on you silently:

• you see the aggregate state at all times (live counters in the menu bar, a Raycast-style panel on ⌘J / Ctrl+J);
• you hear it — toast notifications that render over fullscreen apps, and an optional local voice that speaks session events out loud;
• you act without hunting for the right terminal — reply straight into any session, switch its model or reasoning effort, and let Jarvis keep the Mac awake through the night.

Highlights

• 🖥 Multi-session monitor — every Claude Code, Codex and Kimi session across every terminal, with live ⏸ waiting · ⚙ working counters in the menu bar.
• 🔔 Toasts over fullscreen — "needs permission" is visible even inside a fullscreen app, with customizable content (branch, model, effort, tokens, duration).
• 🎛 Always-on-top hotkey panel (⌘J on macOS, Ctrl+J on Linux) — open, glance, act, dismiss (Raycast-style); never steals focus.
• ↩️ Reply into any session — type back into a session via tmux even if its window is minimized or on another Space; a / command palette included.
• ⚙️ Remote control — switch model (Opus / Sonnet / Haiku) and reasoning effort from the panel; answer multi-choice agent questions with native pickers.
• 🛰 Remote sessions — agents running on a VPS show up in the same list, over your own SSH; a thin node buffers events while the laptop sleeps (docs/remote.md).
• 🔁 Loops and pipelines — overnight routines the agent runs on its own, with an exit condition and hard walls. Bigger work is assembled as a graph: scout → edit → test, a fork into parallel branches (each in its own git worktree), a per-item fan-out over a list computed at runtime, and a join that merges them back. The graph exports to BPMN 2.0, is edited in Camunda Modeler and comes back without losses (docs/pipelines.md).
• 📊 Usage, costs and limits — token and cost tracking per model and project; when a session hits the usage limit, Jarvis shows when it resets and can auto-resume it.
• AI workflow analytics — configurable local Claude/Codex and normalized event sources, explainable harness scores, tool failures, prompt signals, Git attribution with explicit unknowns, and outcome-based model/time/cost comparisons (guide, Russian, configuration and adapters, industry research).
• 🗣 Jarvis speaks — a local TTS voice reads out what a session did or what it's waiting for (Russian-first for now).
• 🎤 "Hey Jarvis" voice assistant (experimental) — say the wake word and talk to your sessions: route a reply by voice, ask what an agent did, control media/volume, ask a general question.
• 🎙 Dictation — push-to-talk (F8): speech is transcribed locally (Whisper / Qwen3) and inserted into the active session; full dictation history with re-transcription.
• ☕ Keep the Mac awake — anti-sleep (a caffeinate equivalent) plus a guarded closed-lid mode for overnight runs.
• ✅ Read-only task board — live TodoWrite progress (done / in-progress / queued) per session.
• 📦 Model manager — download, delete and hot-swap the local TTS/STT/wake-word models from settings; guided first-run onboarding.
• 🧩 Capabilities are plugins — keep-awake, clamshell and whatever comes next all sit on one contract: a manifest declares settings, tray items and permissions, and the core renders the UI from it. Your own integrations run as separate processes in any language — docs/plugins.md.
• 🔒 Event-driven & private — built on the agents' own hooks (no screen scraping), everything runs locally, no telemetry, removable with one command.
• 📟 Terminal and phone too — the same fleet from a TUI (jarvis-cli) or from Android (jarvis-mobile); see the stack.

Boundary: Jarvis is a monitor and a remote, not an orchestrator. It does not spawn agents and does not own the plan; it complements orchestrators (Claude Squad, Conductor, Crystal, native Agent Teams) and the sessions you already run.

The Jarvis stack

The panel is one of three ways into the same fleet — not a client/server split. Each program talks to the agents' own hooks, and the ones on one machine share one data directory (~/.jarvis): a loop started in the terminal shows up in the panel, and a bundle started in the panel is driven from the terminal. The phone is deliberately narrower — sessions, chat and replies, nothing else.

The panel and the CLI are two faces of one local state, so use whichever is in front of you. The phone never touches ~/.jarvis — it talks to jarvis-node over your own SSH, which is exactly what lets it work while the laptop is closed (docs/remote.md). The node is also what the panel and the CLI reach for when an agent runs on a VPS.

Who it's for

Jarvis is a power-user tool. It pays off once you cross the pain threshold of 3+ parallel agent sessions:

• Solo developers running an agent fleet — several Claude Code / Codex / Kimi sessions across projects, where checking each terminal by hand eats the very time the agents were supposed to save.
• Overnight and long unattended runs — big refactors, test-fix loops, batch migrations on a MacBook: Jarvis keeps the Mac awake (even lid-closed) and auto-resumes sessions when the usage limit window resets.
• People who like to stay heads-down — you keep writing code or reading while agents grind; Jarvis interrupts you only when one of them actually needs a decision, with a toast or a spoken line.
• Small teams standardizing agent workflows — Jarvis is fully local per machine (no server, no accounts), so every developer just installs it and gets the same visibility.

It's probably not for you if you run one session in one terminal (native notifications may be enough), or if you're looking for something to spawn and plan agents — pair Jarvis with an orchestrator for that.

Install

Platforms. macOS and Linux. macOS is the primary target and the only one with prebuilt releases; on Linux you build from source — setup and the list of platform differences live in docs/linux.md.

macOS — from a release (recommended)

1. Download Jarvis_x.y.z_aarch64.dmg from the releases page.

2. Open the DMG, drag Jarvis into Applications, launch it.

3. First launch: the build is ad-hoc signed (no Apple Developer ID yet, not notarized), so macOS will warn about an unidentified developer. Right-click the app → Open → Open. If macOS claims the app is "damaged", clear the quarantine flag:

   xattr -dr com.apple.quarantine /Applications/Jarvis.app
   

4. On first launch Jarvis offers to set up the Claude Code / Codex / Kimi integration and download voice models — click «Настроить» ("Set up"); progress is shown step by step in the window.

The app checks for updates itself (built-in updater). You can reinstall the integration anytime: menu bar → "Reinstall integration…".

Linux — from source

# Debian / Ubuntu — see docs/linux.md for Fedora and Arch
sudo apt install tmux libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev \
                 librsvg2-dev libasound2-dev libxdo-dev patchelf cmake

# Arch (the port's main bench: Arch + Sway)
# sudo pacman -S tmux webkit2gtk-4.1 gtk3 libayatana-appindicator librsvg \
#                alsa-lib patchelf cmake wtype wl-clipboard playerctl

npm ci
npm run setup          # hooks into ~/.claude/settings.json
npm run start:linux    # build and launch
npm run bundle:linux   # optional: .deb / .AppImage / .rpm

On Wayland (Sway, Hyprland, GNOME) global shortcuts belong to the compositor, not to the app: bind them there — bindsym $mod+j exec jarvis --toggle — and add the window rules from docs/sway/jarvis.conf, otherwise the panel arrives as an ordinary tile. On X11 the panel hotkey is Ctrl+J: Super belongs to the desktop environment (GNOME uses Super+1..4 for the dock). Full list of differences and of the optional helpers (playerctl, wmctrl, xdotool) — docs/linux.md.

Requirements:

• macOS 11+ on Apple Silicon (M1 or newer) — the prebuilt DMG is aarch64-only; Intel Macs build from source (below). Or Linux with WebKitGTK, GTK 3 and an appindicator-capable tray;
• tmux — required for replying into sessions and the remote (brew install tmux / apt install tmux);
• Claude Code (CLI), Codex (CLI) and/or Kimi Code CLI — the agents Jarvis monitors; each integration is wired up automatically when the corresponding binary (claude, codex, kimi) is found on the system.

npm ci
npm run setup     # install hooks into ~/.claude/settings.json (backed up, idempotent)
npm start         # build and launch the daemon + menu bar (◇ top-right) against the dev profile (~/.jarvis-dev)

echo '{"session_id":"t1","cwd":"'$PWD'"}' | ~/.jarvis/bin/jarvis-hook claude session-start
echo '{"session_id":"t1","cwd":"'$PWD'","prompt":"add tests"}' | ~/.jarvis/bin/jarvis-hook claude prompt
echo '{"session_id":"t1","cwd":"'$PWD'","message":"Claude needs your permission to use Bash"}' | ~/.jarvis/bin/jarvis-hook claude notification
echo '{"session_id":"t1","cwd":"'$PWD'"}' | ~/.jarvis/bin/jarvis-hook claude stop

Features

🖥 Session monitoring

A registry of every interactive Claude Code / Codex / Kimi session: status (idle / working / waiting / finished / hit the limit), project, branch, model, activity. The menu-bar counter (◇ ⏸N ⚙M) is the cross-terminal summary; the hotkey panel is the detailed view.

🔔 Notifications & 🎛 the hotkey panel

Jarvis's own toast notifications render over fullscreen; the panel (alwaysOnTop) does not steal focus. The global hotkey (⌘J on macOS, Ctrl+J on Linux) opens the panel centered on screen — Esc, a click outside, or the hotkey again closes it.

🎨 Look: theme and paint

The interface is a sheet of paper: one opaque surface, one accent colour, and monochrome status dots (working — filled, finished — outline only, waiting — accent, rate-limited — dim, asleep — pale). The bottom strip carries a waveform and the line "say «jarvis» — I'm listening"; on the right, a subscription-limit meter with the window until reset.

↩️ Reply into a session & ⚙️ the remote

In a session's chat the Reply field inserts text straight into the session's terminal — even if the window is minimized or on another Space. Below it sits the remote: Model segments (Opus / Sonnet / Haiku) and Effort (auto / low / med / high / xhigh) send a slash command (/model sonnet, /effort high) into the live session. When an agent asks a multiple-choice question, the panel renders native pickers (multi-select included) instead of making you type numbers into a terminal.

🤝 Claude Code, Codex and Kimi, side by side

If codex is found during setup, Jarvis wires it up too: hooks in ~/.codex/hooks.json and a codex shim using the same tmux mechanism. Interactive Codex sessions appear in the panel with a codex badge and get the same treatment — status, toasts, voice, chat, reply-into-session, and a resume command (codex resume <session_id>).

The third agent is Kimi Code CLI (kimi, Moonshot AI) — same deal: a kimi shim on the same tmux mechanism, a kimi badge in the panel, status, toasts, voice, chat, reply-into-session and a resume command (kimi -S <session_id>). Hooks live elsewhere, though: Kimi keeps them in [[hooks]] sections inside ~/.kimi-code/config.toml (the home is overridable via KIMI_CODE_HOME). That file is the user's shared config — providers, models, permission rules — so Jarvis edits it as a managed block between markers, takes a backup first and runs kimi doctor after writing; if the config doesn't pass the check, the backup is restored.

🛰 Remote sessions (an agent on another machine)

An agent running on a VPS or an office workstation appears in the same list as your local ones — same statuses, toasts, voice, chat, reply-into-session and remote, with the node's name as a badge. A thin node (jarvis-node) lives on that machine: it receives the agents' hooks locally and buffers the events, so a closed laptop doesn't lose the night. Jarvis reaches it over your own SSH (ssh -N -L onto a unix socket) — the node opens no ports and Jarvis creates no new secrets. The same node is what jarvis-cli (jarvis -m vps …) and the Android client talk to, so a VPS agent is reachable from a terminal or a phone with nothing extra installed on it.

Set up straight from the panel: Settings → «Удалённые» → enter the ssh host → "Проверить машину" (shows what's there) → "Установить". Jarvis delivers the node itself, wires the agents' hooks and sets up autostart, showing each step as it goes. If ssh doesn't let it in yet, the panel offers the public key to add on that side. Same thing from a terminal — jarvis-setup remote add vps [email protected].

The remote machine needs SSH access, curl (used by the hooks, and to fetch the node) and tmux — the latter only for replying into a session and the remote control. Setup, what it looks like in the UI, diagnostics, security and boundaries: docs/remote.md.

📊 Usage, costs and limits

Jarvis tracks token usage and estimated cost per session, model and project, and understands the rolling usage-limit window. When a session hits the limit, the panel and the voice line tell you when it resets — and, with auto-resume enabled, Jarvis picks the session back up the moment the window opens.

🗣 Voice: Jarvis speaks (TTS)

After a session event Jarvis briefly says out loud what happened, via a local TTS engine — currently in Russian. The text is assembled from structural signals by template; numbers are spelled out with correct grammatical agreement.

• turn finished → "Pixela: four of six tasks, now docker-compose" (board present) · "Recru is done, three files changed" (diff present);
• waiting on you → priority: "Pixela is waiting — needs permission for Bash"; hit the limit → "Pixela hit the limit, resets in two hours".

"voice": { "engine": "silero", "mute": false,
           "events": { "stop": true, "notification": true, "stopFailure": true } }

🎤 "Hey Jarvis" — the voice assistant (experimental)

Say the wake word and talk — no keyboard, no window switching:

• route a reply by voice — Jarvis figures out which session you're addressing by content (and shows a picker when unsure), stages the text, and sends it;
• ask what happened — "what did the ticketing session do?" gets a spoken summary;
• quick OS commands — media play/pause/next, system volume, open an app;
• general questions — handed to a separate local assistant agent that can search the web and answers out loud.

Replies are half-duplex: Jarvis pauses listening while it speaks, and notifications wait while you're talking. Wake-word detection (openWakeWord) is included in release builds but off by default — enable it in the panel; the detector model is downloaded on demand (non-commercial license — see License). There is no speaker verification yet — anyone in the room can say the wake word.

🎙 Dictation (push-to-talk STT)

Hold F8, speak, release — your speech is transcribed locally and inserted into the active session. The default engine is Qwen3-ASR via an MLX sidecar; Whisper (whisper.cpp, Metal) is built in as an alternative. Mixed Russian/English speech — including inline code terms — is handled.

☕ Keep awake · ⌒ Clamshell (power plugins)

A sleeping Mac means frozen agent processes and severed API requests. Two pluggable power plugins (toggles in settings), UX modeled on Raycast Coffee and Amphetamine:

• ☕ Keep awake — vetoes idle sleep via a power assertion (IOPMAssertion, like caffeinate): indefinitely, for a duration (15m…8h), while a process lives, or auto — while agents are working.
• ⌒ Clamshell — closed-display mode (pmset disablesleep): the Mac keeps running with the lid shut. On Apple Silicon this is exactly what plain caffeinate can't do.

✅ Task board (observer)

Sessions running a multi-step plan (TodoWrite) show an "N/M tasks" ring → a "Tasks" slide-over: an aggregate, a progress bar, a list with statuses, and where possible the model and duration of the correlated subagent. The board is live: the next TodoWrite redraws it on its own.

📦 Model manager

All local models — TTS voices, STT engines, the wake-word detector — are managed from a single "Models" section in settings: status, size on disk, download, delete, and hot-swapping the active STT engine without restarting the daemon. First-run onboarding offers a model checklist with unified download progress. Nothing is bundled with the app; weights are fetched from their upstream sources into ~/.jarvis/.

Jarvis vs neighbors

The closest in spirit are menu-bar monitors; their edge is zero setup. Jarvis answers with accuracy (hooks, not guessing), reply-into-session plus a remote, voice, and power management.

How it works

claude / codex / kimi (any terminal)
  └─ native hooks (~/.claude/settings.json · ~/.codex/hooks.json · ~/.kimi-code/config.toml)  ← installed by setup
       └─ ~/.jarvis/bin/jarvis-hook        ← fail-silent shim, 0.3 s curl
            └─ unix socket ~/.jarvis/run.sock
                 └─ Rust daemon (Tauri) = session registry + effects
                      ├─ toasts over fullscreen · hotkey panel (always-on-top)
                      ├─ tmux reply & remote · TTS/STT sidecars · power plugins
                      └─ menu-bar counter: ⏸ waiting · ⚙ working

The frontend (panel ui/index.html + ui/renderer.js, toasts ui/toast.*) runs in the system WKWebView; the window.jarvis contract is implemented by a thin adapter ui/bridge.js over Tauri IPC. The main process is Rust (src-tauri/src/): a unix socket on axum, the registry-reducer with effects, tmux, transcripts, usage/history, voice, STT, wake-word, the power plugins. State, settings and stats live in ~/.jarvis/ in stable formats.

Principles: no screen reading (structured events only) · fail-silent hooks (they never break the agents) · everything local, no telemetry · remove everything with one command (npm run teardown). The increment-by-increment development history — specs, plans, mockups — is in docs/superpowers/.

Tips & recommended setup

• Install tmux (brew install tmux / apt install tmux) — without it Jarvis still monitors and notifies, but can't reply into sessions or drive the remote. In iTerm2 sessions get native tabs (tmux control mode).
• Pair with an orchestrator. Claude Squad, Conductor, Crystal, native Agent Teams — they spawn and plan; Jarvis watches everything they (and you) run interactively, in one place.
• Overnight runs: enable Keep awake → auto (awake while agents work) and let the clamshell guard handle the lid; enable auto-resume so a limit reset doesn't strand the run.
• Office-friendly voice: the "speak only into a Bluetooth headset" toggle keeps summaries out of the room's speakers.
• The panel hotkey clashes with Chrome's Downloads and VS Code's panel toggle — rebind it in settings if you use those.
• Commercial use: the default voice and wake-word models are non-commercial; switch to the commercial-clean set (Silero v5_cis_base, Whisper/Qwen3, own or no wake-word) — see THIRD-PARTY-NOTICES.md.
• A session started outside the shim shows as "outside tmux" — restart it via claude --resume <session_id> to make it controllable.

Roadmap

Jarvis is a solo-maintained pre-1.0 project; this is a direction, not a promise. The best way to influence it is an issue.

Voice assistant → hands-free mission control

• Create a new session by voice ("Jarvis, start an agent in ~/myproject") — today voice only routes into existing sessions.
• Acoustic barge-in: interrupt Jarvis mid-sentence without the mic picking up its own speech (echo cancellation via macOS VoiceProcessingIO).
• Streaming word-by-word dictation (today transcription happens on release).
• Persistent assistant memory across conversations; a dedicated conversation-history view.
• Speaker verification for the wake word (today anyone in the room can trigger it).
• A full voice HUD.

Agent platform

• Ship the agent-chat UI on top of the capability platform — the security gate and the jarvis-mcp MCP bridge are already in place.
• A plugin system (manifests, sandboxing, signing) and deeper security layers (span-level provenance, egress control).
• Exposing Jarvis capabilities as an MCP server for external clients.

Engines & models

• Fully native TTS — dropping the Python sidecar (Piper via ort, or Silero via ort with native Russian stress handling).
• Quantized STT models (4-bit Qwen3) once accuracy is validated; production-grade noise suppression (the current toggle is alpha).

Codex parity — limit tracking with auto-resume and exact (not estimated) usage numbers for Codex sessions.

Distribution & polish

• Proper Developer ID signing and notarization (today's builds are ad-hoc signed).
• A hero demo GIF and screenshots; a prebuilt Intel DMG if there's demand.
• 1.0: freeze the hook contract and the on-disk formats.

Exploring — English UI and English spoken summaries (the interface and voice are currently Russian-first).

Explicitly out of scope: spawning/orchestrating agents (by design — see the boundary note), Windows, and the Mac App Store (its sandbox is incompatible with hooks and tmux). Linux is supported — see docs/linux.md; a few macOS-only capabilities (clamshell mode, the Accessibility focus snapshot) have no counterpart there and report themselves as unavailable.

Status & limitations

A pre-1.0 MVP, developed in the open. Deliberate boundaries and known issues:

• macOS and Linux (Linux from source; some capabilities differ — docs/linux.md); Claude Code (CLI), Codex (CLI) and Kimi Code CLI are supported — interactive sessions only (headless claude -p / codex exec don't fire hooks — not monitored; kimi -p does fire them, but such runs live outside tmux and can't be controlled); the remote and reply need tmux.
• The UI and voice are currently Russian-first. Monitoring, notifications, dictation and the remote work regardless of your language; English localization is on the roadmap.
• Effort can't be read from outside → the panel keeps optimistic state.
• Hook schemas drift between agent versions. If events stop arriving after a claude update, compare against the current hooks docs and fix EVENTS/the format in src-tauri/src/bin/setup.rs.
• A hard-killed terminal (no SessionEnd) leaves a session hanging — the panel's "Clear" button removes done/idle ones.
• Wake-word ("Hey Jarvis") is experimental: no speaker verification, detector model is non-commercial (see License), off by default. The dev build (npm start) includes the feature flag but the detector stays inert until enabled in the panel.
• Agent chat (the capability platform, MCP bridge jarvis-mcp) — the bridge exists, the UI isn't shipped. In progress.

Versioning

Pre-1.0 (SemVer 0.x): the hook contract and the on-disk formats (~/.jarvis/) may change. 0.MINOR bumps for features/breaking changes, 0.x.PATCH for fixes. 1.0 will freeze the hook contract and the state format. Updates never touch your data: everything user-owned lives in ~/.jarvis/, outside the app bundle — see docs/release/versioning-and-migration.md.

Contributing

Issues and PRs are welcome! See CONTRIBUTING.md for how to build, test, and open a PR. By participating you agree to the Code of Conduct. Report vulnerabilities privately via SECURITY.md. Specs and per-increment plans live in docs/superpowers/.

Direct pushes to master are disabled — changes land only via Pull Request with green CI.

License

Jarvis's code is licensed under the MIT License © 2026 Sergey Chernyshev.

Model weights are downloaded, not part of the repo, and keep their own licenses — these restrict use of the corresponding feature independently of the MIT code:

⚠️ The default voice (v4_ru) and wake-word (hey_jarvis) are non-commercial. For commercial use: voice → Silero v5_cis_base (MIT); wake-word → train your own or disable it; STT → Whisper or Qwen3. The full breakdown and third-party obligations are in THIRD-PARTY-NOTICES.md (including the BSD-3 attribution for mediaremote-adapter).

Non-affiliation. Jarvis is an independent open-source project. It is not affiliated with, or endorsed by, Anthropic, PBC; "Claude" and "Claude Code" are trademarks of Anthropic, used nominatively (to describe compatibility). It is likewise not affiliated with OpenAI or with Moonshot AI; "Codex" and "Kimi" are referenced nominatively. Jarvis works on top of the agents' official hooks. The project is also unaffiliated with Marvel/Disney; any resemblance to the fictional "J.A.R.V.I.S." is unintentional.