Skip to main content
Glama

Actual footage. Not a mockup.

Jarvis Orb — Persistent Memory MCP Server + AI Brain Visualizer

Not a tool. A presence.

It remembers your decisions. It tracks your world. It glows on your desktop, alive.

Stars Release License macOS Windows

Website · Download · Report Bug

English | 한국어


The Problem

Every session, your AI starts over. Your decisions, your preferences, your project context — gone. You explain yourself again. And again. And again.

  • "We decided to use SQLite." → Three days later, it suggests PostgreSQL.

  • "This PR was merged yesterday." → It doesn't know. It never remembers state.

  • "What was the architecture decision?" → Gone. The session ended.

Related MCP server: Brain-MCP

The Solution

Jarvis Orb gives your AI a persistent brain and shows its thought process as a living orb on your desktop.

jarvis-orb MCP server

Without Jarvis Orb

With Jarvis Orb

Context

Every session starts from zero

Carries over automatically

Decisions

Reversed decisions come back

Contradictions detected and filtered

State

"What's the status?" → guess

Exact state + transition history

Visibility

No idea what it's thinking

Every thought, live on your screen

Install

macOS (Apple Silicon) / Linux:

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

Requires Apple Silicon (M1/M2/M3/M4). Use the terminal command above for the smoothest install experience.

Windows (PowerShell):

irm https://raw.githubusercontent.com/thestack-ai/jarvis-orb/main/install.ps1 | iex

That's it. Brain starts. Orb floats. Claude Code connects.

Verify your install:

jarvis-orb --doctor

Supported Platforms

Platform

Brain (MCP)

Orb (Desktop)

macOS Apple Silicon (M1+)

Yes

Yes

macOS Intel

Yes

Yes

Windows x64

Yes

Yes

Linux

Yes

Not yet

Cursor / Windsurf Setup

Add to your MCP config (~/.cursor/mcp.json or equivalent):

{
  "mcpServers": {
    "jarvis-brain": {
      "command": "python3",
      "args": ["-m", "jarvis_brain.mcp_server"],
      "env": {
        "PYTHONPATH": "~/.jarvis-orb/lib:~/.jarvis-orb"
      }
    }
  }
}

Uninstall

# Remove Brain + data
rm -rf ~/.jarvis-orb

# Remove from Claude Code
claude mcp remove jarvis-brain

# Remove Orb app (macOS)
rm -rf "/Applications/Jarvis Orb.app"

# Remove PATH entry from ~/.zshrc or ~/.bashrc
# Delete the line: export PATH="$HOME/.jarvis-orb/bin:$PATH"

Brain Lite

Watch it think.

#

Feature

Description

01

4-Tier Memory

Episodic, semantic, project, procedural — auto-classified and ranked by recency

02

Temporal Scoring

30-day half-life decay. Recent memories surface first. Old context fades naturally

03

Contradiction Detection

Conflicting memories flagged. Superseded decisions marked stale. Only truth surfaces

04

Entity Tracking

Projects, PRs, decisions tracked as objects with full state transition history

05

Relationship Storage

People → projects → decisions connected as a lightweight knowledge graph

06

FTS5 Search

Full-text search across all memories with observation filtering

MCP Tools

memory_save      Save a memory (auto-classified into 4 tiers)
memory_search    Search with temporal scoring + contradiction filtering
memory_verify    Mark memories as verified, superseded, or contradicted
entity_create    Track a project, person, decision, or tool
entity_update    Update entity state (records transition history)
entity_query     Query entities by type or name
entity_relate    Create relationships between entities

Works with Claude Code, Cursor, and any MCP-compatible tool.


Orb

Every thought, visible.

The orb is not decorative. It shows you what the brain is doing, in real time.

Brain Event

Orb Response

Memory saved

Particles absorb into orb

Contradiction detected

Red/orange pulse wave

Entity state changed

Cyan flash + scale pulse

Search executed

Violet color shift

Context compressed

Shrink, brighten, expand

Team dispatched

Orb splits into sub-orbs

3MB desktop app. Always-on-top. Draggable. Click to see logs.


In Practice

Monday morning standup — "What did we work on last week?" Brain searches episodic memories with temporal scoring. Returns a ranked summary. No digging through chat history.

Mid-project contradiction — "We should use Redis for caching." Brain detects this contradicts a previous decision. Flags the conflict. The orb pulses red. You see it happening.

New session, no context loss — "Continue where we left off." Brain loads project state, recent decisions, and your preferences. No re-explaining.


Architecture

Claude Code / Cursor
     ↕  MCP (stdio)
Brain Lite  —  Python · aiosqlite · FTS5 · ~/.jarvis-orb/brain.db
     ↕  WebSocket
Orb  —  Tauri · Three.js · WebGL · 3MB · Always-on-top

3MB

App size. Not 150MB.

7

MCP tools. Memory, entities, search.

0

Cloud dependencies. Everything local.


Origin

Jarvis Orb was extracted from a working AI control plane — Jarvis — running 19 modules, a knowledge graph with 100+ entities, 500+ memories, and 22 agent teams. This is the lightweight, open-source version of that brain.

"I built a personal AI operating system. After months of using it, I realized the core — the brain and the visualization — should be available to everyone."


Roadmap

  • Orb Customization — Custom orb skins, color themes, animation profiles

  • Brain Pro — Advanced memory with full knowledge graph, multi-model routing, autonomous reasoning loop

  • Auto-update — Seamless in-app updates

  • Plugin System — Extend Brain with custom MCP tools

Contributing

PRs welcome. See CONTRIBUTING.md.

git clone https://github.com/thestack-ai/jarvis-orb.git
cd jarvis-orb

# Brain
cd brain && uv venv .venv && source .venv/bin/activate
uv pip install aiosqlite websockets mcp pytest pytest-asyncio
python -m pytest tests/ -v

# Orb
cd ../orb && pnpm install && pnpm tauri dev

License

MIT


Your AI will start remembering.

Website · Download · GitHub

Available Tools

7 tools
entity_createC

Create an entity (person, project, decision, tool, etc.).

Inputs: name (required), entity_type (required), state. Returns: result

entity_queryB

Query entities by type and/or name.

Inputs: name, entity_type. Returns: result

entity_relateC

Create a relationship between two entities.

Inputs: object_id (required), predicate (required), subject_id (required). Returns: result

entity_updateC

Update entity state. Records transition history.

Inputs: entity_id (required), new_state (required), reason. Returns: result

memory_saveC

Save a memory to the brain. Types: episodic, semantic, project, procedural.

Inputs: content (required), tags, source, project, +1 more. Returns: result

memory_verifyB

Verify, supersede, or contradict a memory. Actions: verify, supersede (old:new), contradict (a:b).

Inputs: memory_id (required), action. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.3/5.0

    Scored across 7 tools

    Disambiguation5/5

    Each tool targets a distinct operation: entity tools cover CRUD-like actions and relating, while memory tools handle saving, searching, and verifying. There is no functional overlap, ensuring an agent can easily distinguish them.

    Naming Consistency5/5

    All tools follow a consistent snake_case verb_noun pattern (e.g., entity_create, memory_save). The naming is uniform and predictable, making it easy to infer tool purpose from the name.

    Tool Count5/5

    With 7 tools covering two domains (entities and memories), the count is well-scoped. Each tool serves a necessary function, and the number is neither overwhelming nor insufficient for the apparent scope.

    Completeness4/5

    The tool set covers core operations for entities (create, read, update, relate) and memories (save, search, verify with supersede/contradict). Only deletion is missing, which is a minor gap but does not severely hinder core workflows.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      Provides AI with persistent memory management including short-term memory (FIFO queue), long-term memory (graph-based storage with associations), and thought process management with multiple cognitive modes for continuous learning and reasoning.
      24
      7 npm
      3
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Persistent memory for AI agents — organized by time and space. Important memories get promoted, noise decays naturally, and related knowledge clusters into a browsable topic tree. Fully automatic.
      28
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI agents to persist and retrieve memories via a personal knowledge graph, with tools for emotional intelligence, CRM, life management, social features, self-training, and autonomous insights.
      859 npm
      7
      MIT