Memory + Orchestration

One Claude isn't enough.
Orchestrate a team.

SHIVA turns Claude Code into a team of specialised workers — with their own memory, budget caps and a full audit log.

CLI · Studio dashboard · Live orchestrator audit. Local first.

Terminal
$ curl -fsSL https://shiva.li/install | bash
$ shiva init
✓ 12 projects discovered
✓ SHIVA integrated into Claude Code
$ shiva start --as dirigent
⊕ dirigent online · 3 workers ready · budget 0 / 20
Documentation GitHub
Orchestration · CLI

Many Claudes. One conductor.

Let one Claude session dispatch work to other sessions across projects — with budget caps and a full audit log.

$ shiva workflow create my-flow --projects api,db,ui
$ shiva start --as dirigent

       [dirigent: your-session]
                 │
        ┌────────┼────────┐
        ▼        ▼        ▼
   [worker-1]  [worker-2]  [worker-3]
     api          db          ui

   ✓ budget 8 / 20 calls
   ✓ audit.jsonl streaming
Dispatch graph for a 3-project workflow

  • Dirigent + Workers

    One session conducts, others execute. Each worker stays in its own project with its own Claude.md and memories.

  • Cross-Project Context

    A worker in Project A can read memories from Project B. The conductor decides what each worker sees.

  • Budget + Audit

    Every shiva_send call is logged. A hard budget cap stops runaway loops before they cost real money.

Studio · Dashboard

The cockpit. In your browser.

A browser dashboard that mirrors the CLI you already know. Same identity, same density, with extras the terminal can't show.

┌─ SHIVA Studio › dashboard ───────────────  190×46 · cursor (50,17) ┐
│                                                                     │
│  $ shiva studio                                                      │
│  Choose a surface. Click, TAB, or press the letter shown.           │
│                                                                     │
│  ┌──────────────┬──────────────┬──────────────┐                     │
│  │ ▶ Sessions   │ » Workflows  │ ⊟ Secrets    │  [s] [w] [k]        │
│  │ Resume work  │ Orchestrate  │ Vault        │                     │
│  ├──────────────┼──────────────┼──────────────┤                     │
│  │ ◉ Memories   │ ■ Packages   │ ◇ Sandbox    │  [m] [p] [b]        │
│  ├──────────────┼──────────────┼──────────────┤                     │
│  │ ≡ Analytics  │ ↬ Hooks      │ ◯ Security   │  [a] [h] [y]        │
│  ├──────────────┼──────────────┼──────────────┤                     │
│  │ ◆ Settings   │ ⬡ Docs       │ › Help       │  [,] [d] [?]        │
│  └──────────────┴──────────────┴──────────────┘                     │
│                                                                     │
└─ click / TAB · Enter · ESC back · : palette · letters quick-jump ───┘
Dashboard home — 12-tile cockpit

  • 12-Tile Cockpit

    Same grid as the TUI — Sessions, Workflows, Memories, Secrets, all reachable in one keystroke. Press ? for the full shortcut overlay.

  • Live Audit

    Watch every shiva_send call stream into the dashboard with redaction indicators and a budget meter that goes red at 90%.

  • Session Spine

    Resume, launch as dirigent, pick workers — all from one row. The page mirrors the TUI session-launch flow exactly.

  • Inline editing

    Add a secret, memory, workflow or hook in place — no modal, no context loss. Cancel returns you exactly where you were.

MCP · V12

Claude orchestrates Claude.

SHIVA registers as an MCP server in Claude Code. Your dirigent session sees five new tools — shiva_send is the heart of it. No glue scripts, no shell wrappers.

Dirigent (Claude tool-call) 
tool: shiva_send
params:
  to:      worker-1
  prompt:  "Refactor api/auth.ts:
            extract token-validation into
            a separate service. Keep the
            existing tests green."
  budget:  3 calls
  timeout: 90s
Worker (reply via MCP) 
✓ worker-1 received task
✓ opened api/auth.ts
✓ extracted validateToken()
✓ 14 tests passing

reply: "Done. New file:
        api/services/token-validator.ts
        Diff +94 / -38."
cost:  1 of 3 calls used

Five tools, one MCP server

shiva_send · shiva_check · shiva_status · shiva_budget · shiva_audit — every one of them logged, redacted at the boundary, and bounded by the budget you set.

1-Minute Setup

Get Started in Three Commands

From zero to persistent memory in under a minute.

Terminal
# Installation
$ curl -fsSL https://shiva.li/install | bash
# Initialize SHIVA
$ shiva init
✓ Config created at ~/.shiva/config.json
✓ 12 projects discovered
✓ Claude Code hook installed
# Your first memory-aware chat
$ shiva remember "Auth nutzt JWT" --category solution
✓ Memory saved to CLAUDE.md...
✓ Auto-discovers all projects
✓ Works with existing Claude Code
✓ Zero configuration needed

Three Pillars. One Tool.

Memory · Orchestration · Audit — the three axes that move SHIVA from a memory tool to a multi-session platform.

Memory

What Claude needs to know, stays

Persistent memory across all sessions and projects. Preferences, architecture decisions, code conventions — Claude doesn't forget anything anymore.

Orchestration

One Claude becomes a team

A dirigent session tasks worker sessions in other projects — directly from Claude's tool-calls via shiva_send, each worker with its own memory.

Audit + Budget

Full transparency, hard limits

Every shiva_send call is logged with redaction indicators. A hard budget cap stops runaway loops before they cost real money. Local-first.

The Transformation

Three steps to eternal knowledge.

1

Give SHIVA Eyes

curl -fsSL https://shiva.li/install | bash

Install SHIVA globally. One command. Done.

2

SHIVA Sees Your Sessions

shiva init

SHIVA scans your projects and integrates automatically into Claude Code.

3

Sessions Become Knowledge

claude

Claude never forgets again. Persistent memory activated. Cross-project awareness enabled.

The SHIVA Difference

What you gain over Claude Code alone.

Feature Claude Code alone Claude + SHIVA
Persistent memory ✗ Every session starts empty ✓ Cross-session, cross-project
Project context ✗ Manually explain per session ✓ Auto-injected via hooks
Multi-session orchestration ✗ One session, one Claude ✓ Dirigent + workers via shiva_send
Cross-project workers ✗ Isolated per repo ✓ Worker tasks worker in another project
Audit trail ✗ No history ✓ JSONL stream with redaction markers
Budget cap ✗ Runaway loops cost real money ✓ Hard cap stops recursion

Enterprise-Grade Security

Privacy-first architecture. No compromises.

End-to-End Encryption

All data encrypted at rest with AES-256. Cloud sync uses TLS 1.3 with perfect forward secrecy.

Zero-Knowledge Architecture

We can't read your memories. Encryption keys never leave your device. Not even we can decrypt your data.

Compliance Ready

SOC 2 Type II compatible. GDPR compliant. Full data export and deletion capabilities on demand.

Security Audit Schedule

Next external security audit planned for Q2 2026 with a leading security firm. All findings will be publicly disclosed.

100% Local by Default

Your memories stay on your machine. No cloud sync unless you explicitly enable it.

Zero Telemetry

No analytics. No tracking. No data collection. We don't know what you're building.

Human-Readable Files

Plain JSON you can read, edit, and version control. No proprietary formats.

Open Source

Full source code available. Audit it. Fork it. Trust but verify.

∞ Sessions remembered
0 Data sent to cloud
100% Your ownership

Pricing

CLI is free. Cloud features for teams and power users.

Free

CHF 0/mo
  • CLI Tool
  • Local Memory
  • Unlimited Projects
  • Auto-Integration
Ready to get started?
Popular

Pro

CHF 9/mo
  • Everything in Free
  • Cloud Sync
  • Web Dashboard
  • Cross-Device
  • Priority
Get Started

Team

CHF 19/user/mo
  • Everything in Pro
  • Shared Context
  • Team Analytics
  • Admin Dashboard
Get Started
Pricing →

Ready to get started?

curl -fsSL https://shiva.li/install | bash && shiva init
Documentation