⚠️ Migration Notice (2026-04-17): Runtime data relocated from ~/jarvis/runtime/ → ~/jarvis/runtime/. Existing installations: ~/.jarvis remains as a backward-compatible symlink through 2026-10-17 (D+180). Fresh installs: use ~/jarvis/runtime/ directly. See docs/A2-MIGRATION.md (upcoming).

🔧 Refactor Notice (2026-04-20): Modules career-* / job-* were renamed to profile-* / inbox-* in commit e74f168 to reflect a more generic, owner-agnostic abstraction. Legacy commit messages and closed issues may still reference the old names. Current HEAD is the canonical naming.

AI operations platform that manages itself 24/7
Discord Bot + RAG Knowledge Base + Insight Layer + Self-Healing Automation

Ask Jarvis anything — it analyses your behaviour patterns + daily auto-generated insight report

Dawn system health check (10 services) + L3 autonomous task approval workflow

"An AI assistant that audits your systems, analyses news, and writes code — while you sleep."

Message it on Discord and it chats. Send a voice message and it understands. Drop a file and it remembers. Overnight, 99 automation scripts run cron jobs. If a service dies, it self-recovers within 3 minutes. Every dawn, it analyses your behavioural patterns and responds knowing what you're focused on right now. Zero API charges — runs on a Claude subscription. 100% of your data stays on your machine.

In short: A personal AI operations platform. Runs 24/7, fixes itself when it breaks, gets smarter as you use it.

What sets Jarvis apart: It doesn't just remember — it acts. Memory + analysis + automation + self-healing in one system. Others stop at the memory layer; Jarvis uses memory to write code, recover services, and generate reports.

Cross-platform abstraction: lib/compat.sh auto-detects the OS and routes service commands (launchctl on macOS, pm2 on Linux/WSL2).

Claude Max = unlimited usage, best for 24/7 bot. Claude Pro = works fine, may hit rate limits under heavy use. Ollama = free, open-source AI that runs locally. Only needed for RAG (document search + memory). The Discord bot itself runs on Claude.

1. Claude Code CLI (the brain)

   npm install -g @anthropic-ai/claude-code
   claude   # opens browser to authenticate — log in with your Anthropic account

2. Node.js 22+ and Python 3.10+

   node -v   # should be 22+
   python3 --version

If you already have a token, skip to Step 2.

1. Go to Discord Developer Portal
2. Click "New Application" → name it (e.g., "Jarvis") → Create
3. Left sidebar → "Bot" tab → click "Reset Token" → Copy the token (save it!)
4. Scroll down → enable "Message Content Intent" toggle → Save
5. Left sidebar → "OAuth2" → "URL Generator":
   • Scopes: bot, applications.commands
   • Bot permissions: Send Messages, Read Message History, Attach Files, Use Slash Commands
6. Copy the generated URL → open in browser → invite the bot to your Discord server

git clone https://github.com/Ramsbaby/jarvis.git && cd jarvis

Open the project in Claude Code and run:

/onboarding

The onboarding wizard guides you through Steps 0–14 (idempotent — re-runnable safely):

Auto-update: When a new release is detected at 03:00 KST, Jarvis pulls latest code, syncs files, restarts the bot, and posts a notice to #🚀jarvis-update. Uses semver comparison (upstream > installed only).

Manual-update: Posts a release alert to #🚀jarvis-update and waits for you to update.

python scripts/setup_infra.py    # paste your Discord token when prompted

The setup wizard will:

• Check Node.js, create data directories
• Ask for your Discord bot token (from Step 1)
• Install dependencies and configure the bot

Detailed guide: infra/CLAUDE-SETUP-GUIDE.md — MCP servers, personas, context setup, and troubleshooting

This gives Jarvis the ability to search past conversations and documents.

# Install Ollama first (free, local AI for embeddings)
# macOS:
brew install ollama && ollama serve

# Linux:
curl -fsSL https://ollama.com/install.sh | sh && ollama serve

# Then run RAG setup:
python scripts/setup_rag.py    # downloads ~400MB embedding model, takes 2-5 min

macOS — auto-starts via LaunchAgent (setup_infra.py configures this)

WSL2 / Linux — use PM2:

npm install -g pm2
pm2 start infra/ecosystem.config.cjs
pm2 startup && pm2 save   # auto-start on boot

A 24/7 interface powered by Claude with streaming responses.

Discord voice messages are automatically transcribed via OpenAI Whisper (Korean + multilingual). The transcribed text is processed by Claude with full RAG context — speak naturally, get AI-powered responses.

Drop a file in Discord and it's automatically indexed into RAG. Your knowledge base grows as you chat.

Jarvis detects important information in conversations and auto-extracts it to long-term memory — preferences, facts, corrections. No manual /remember needed.

Each extracted fact is scored 1-5 by the LLM (Mem0 pattern). Only score ≥ 3 is stored — reduces memory bloat by 40-60%. Say "잊어줘" (forget this) to delete specific facts.

Every response includes contextual action buttons:

• Cancel — stop in-progress Claude tasks
• Regen — re-run the last query
• Summarize — get a summary of the response
• Approve / Reject — for L3 autonomous task approval workflow

• Each Discord user gets isolated memory (facts, preferences, corrections, plans)
• New users join via pairing code (6-digit, 10min TTL, owner approval)
• Family channels automatically filter out owner's private data (configurable sensitive domains)
• Per-channel personas — different personality per channel (personas.json)
• Message debouncing — consecutive messages batched (1.5s) into single Claude call

Three layers work together — LLM Wiki accumulates structured knowledge, RAG retrieves raw context, the Insight Layer understands behavioural patterns.

🗂️  LLM Wiki (daily digest)          📚 RAG Layer (per-query)          📊 Insight Layer (daily)
  profile.md / work.md /               semantic search across              "topic frequency shift detected"
  trading.md / projects.md             10,000+ indexed documents           "domain focus transition"
  (Stateful — pages updated,                    │                                    │
   not just appended)                           │                                    │
              │                                 │                                    │
              └─────────────────┬───────────────┘────────────────────────────────────┘
                                ▼
                       Claude responds with
                       full situational awareness

Inspired by Andrej Karpathy's LLM Wiki. Transforms raw conversation sessions into a Stateful, compounding knowledge base.

7 wiki categories (~/jarvis/runtime/wiki/pages/{userId}/):

How it works: Every night (03:00) the session summariser digests today's conversations via Claude Haiku → new facts are routed to the correct wiki page → pages are updated (not just appended) → context is injected into the next session's system prompt.

Two additional layers work together — RAG retrieves raw facts, the Insight Layer understands context.

📊 Insight Layer (daily, ~1.2KB)                 📚 RAG Layer (per-query)
  "topic frequency shift detected"                  semantic search across
  "domain focus transition"                         10,000+ indexed documents
              │                                              │
              └──────────────┬───────────────────────────────┘
                             ▼
                    Claude responds with
                    full situational awareness

Automated behavioural analysis, generated daily at 04:15:

Detects: topic frequency shifts, cross-domain correlations, entity momentum, daily activity patterns. Integrates Google Calendar for D-day awareness. Output loaded into every system prompt automatically.

Hybrid search: BM25 full-text + Ollama vector similarity (snowflake-arctic-embed2, 1024-dim).

See rag/README.md for details.

Jarvis doesn't just chat — it writes code.

1. Insight Extractor analyses task results and news, auto-extracts high-priority action items
2. Items are queued in SQLite task store with FSM state tracking (PENDING → RUNNING → SUCCESS/FAILED)
3. jarvis-coder.sh picks up queued tasks and executes them via Claude — automated commits, fixes, improvements
4. Skip patterns prevent recursive self-modification (manual tasks and self-referential items are filtered)

Automated system health check: 10 services monitored every 6 hours

Jarvis doesn't just run — it heals itself. 99 automation scripts, 11 LaunchAgents, 40+ cron jobs. Multi-layer self-recovery + systemic defense:

Harness (Anthropic 4-function pattern):

• Guides: Tiered prompt loading — Tier 0 (always, <3KB) / Tier 1 (keyword-triggered)
• Sensors: Session Handoff (structured state transfer) + Progressive Compaction (40K/60K/80K)
• Verification: Tool Call Ledger (per-invocation JSONL audit) + Error Ledger (silent error tracking)
• Correction: Failure Rule Engine (auto pattern learning + Bayesian confidence scoring)

Summon specialised teams via /team <name>:

Automated executive review system. 4 AI agents convene daily:

Output: context-bus.md (shared context) + decisions/{date}.jsonl + board-minutes/{date}.md

Two directories, one reason — code and your data live apart so updates can never touch your stuff.

• ~/jarvis/ — the recipe book (this git repo; replaced on every update)
• ~/jarvis/runtime/ — your fridge (tokens, chat history, RAG DB, personal configs; never touched by git pull)

Same pattern as ~/.ssh or ~/.aws — the tool is shared, your data is yours. A phone OS update doesn't delete your photos; a git pull here doesn't delete your memory. ~/jarvis/runtime/private/ (repo-ignored) is the correct home for personal helper scripts that a public repo shouldn't carry.

Since the A2 migration (2026-04-17), ~/jarvis/runtime/ is a symlink to ~/jarvis/runtime/ so the two paths resolve to the same files. Code-containing subdirectories (bin/, lib/, scripts/, infra/) are further symlinked into the repo so crons reference stable paths; everything else (config/, data/, logs/, state/, ledger/, private/, wiki/, rag/) is a real directory that holds only your data.

jarvis/
├── rag/                 # RAG module (LanceDB + Ollama + Insight Layer)
│   ├── lib/             # Core engine, query, paths
│   └── bin/             # Indexer, metrics, distiller, repair
├── infra/               # Infrastructure & automation
│   ├── discord/         # Discord bot + 30 handlers
│   │   └── lib/
│   │       ├── wiki-engine.mjs    # LLM Wiki CRUD + 7-category schema
│   │       └── wiki-ingester.mjs  # Claude Haiku session digest pipeline
│   ├── lib/             # Core libraries (MCP, task-store, insight-extractor)
│   ├── bin/             # Cron executables (jarvis-cron, jarvis-coder, bot-cron)
│   ├── scripts/         # Auditors, e2e tests, code review, deployment
│   ├── config/          # Tasks, personas, channels, monitoring
│   ├── agents/          # 8 AI team profiles
│   └── templates/       # Cron & LaunchAgent templates
├── scripts/             # Setup wizards
└── docs/img/            # Screenshots

Runtime wiki storage (~/jarvis/runtime/wiki/):

~/jarvis/runtime/wiki/
  schema.json            # Wiki structure rules
  pages/{userId}/
    profile.md / work.md / trading.md / projects.md
    preferences.md / health.md / travel.md

MIT

🇰🇷 한국어