rune

Rune

Encrypted shared memory for AI agents.

Rune gives every AI agent on your team the collective experience of the entire organization — automatically, privately, and without anyone searching for it.

  Without Rune                         With Rune
  ━━━━━━━━━━━━                        ━━━━━━━━━

  Developer: "Should we use MongoDB?"   Developer: "Should we use MongoDB?"

  Agent: "MongoDB is great for          Agent: "Your team chose PostgreSQL
         flexible schemas..."                   over MongoDB in March. ACID
                                                compliance was non-negotiable
  (generic advice, no team context)             for transaction integrity."

  Two weeks later: "Wait, the team      The developer never searched.
  already rejected MongoDB??"           The agent just knew.

Works with Claude Code, Codex CLI, Gemini CLI, and any MCP-compatible agent.

---

Quick Start

Install

Claude Code:

# From terminal (local clone)
$ claude plugin marketplace add ./
$ claude plugin install rune

# From inside a Claude Code session (remote)
> /plugin marketplace add https://github.com/CryptoLabInc/rune
> /plugin install rune

Gemini CLI:

# From terminal
$ gemini extensions install https://github.com/CryptoLabInc/rune.git

Codex CLI:

# From inside a Codex session
> $skill-installer install https://github.com/CryptoLabInc/rune.git

Configure

> /rune:configure        # Claude Code, Gemini CLI
> $rune configure        # Codex CLI

You'll need from your team admin:

• Vault endpoint + token

That's all. enVector Cloud credentials are delivered automatically via the Vault bundle.

Don't have these? See rune-admin for deployment, or examples/team-setup-example.md for a walkthrough.

That's It

Once configured, Rune works automatically. No commands to memorize. No queries to write. Just work with your agent as usual.

Your agent will:

• Capture significant decisions, trade-offs, and lessons during your work
• Recall relevant team knowledge when it matters — without being asked

---

What This Looks Like

Debugging that saves 4 hours:

Dev: "The payment service is timing out"

Agent: "A similar timeout was investigated last month — root
       cause was connection pool exhaustion under concurrent
       webhook processing. Fix was async batch processing
       with a 50-connection pool limit."

Knowledge from a teammate's past session, surfaced automatically.

Onboarding that just works:

New hire: "I'm thinking of using Redis for the job queue"

Agent: "Your team evaluated Redis vs SQS for the job queue
       in February. SQS was chosen because Redis required
       dedicated ops capacity the team doesn't have."

The new hire's agent already has institutional knowledge
they haven't been taught yet.

You don't "query" Rune. Your agent draws from it the way an experienced engineer draws from years of past projects — the relevant context just surfaces.

---

How Rune Is Different

Approach	Limitation	Rune
Built-in memory	Siloed per vendor. Your team's Claude memory and Codex memory never connect.	One shared memory across all agents. Vendor-independent.
RAG pipelines	Chunks documents into fragments. Destroys reasoning structure. Requires ongoing pipeline maintenance.	Agent judges significance and stores decisions, not document chunks. No pipeline to maintain.
Wikis & docs	Manual. Nobody updates the wiki after the meeting.	Captures automatically during work, not after.
Plaintext vector DBs	Your organizational knowledge is readable by the cloud provider.	FHE encryption — the cloud stores and searches only ciphertext. Mathematically guaranteed.

---

Architecture

  Agent Swarm (your team)              Cloud Infrastructure
  ━━━━━━━━━━━━━━━━━━━━━━              ━━━━━━━━━━━━━━━━━━━━

  Alice's Agent ─┐
  Bob's Agent ───┤── MCP ──► enVector Cloud (encrypted vectors)
  Carol's Agent ─┘               │
                            Rune-Vault (secret key holder)
                            decrypts similarity scores only

Capture: Agent judges significance → generates reusable insight → novelty check against existing memory → FHE encrypt → store

Recall: Semantic query → encrypted similarity scoring → Vault decrypts scores only → metadata retrieved and decrypted locally

Privacy: Zero-Knowledge Encryption

Every memory is encrypted before leaving your machine using Fully Homomorphic Encryption (FHE).

• enVector Cloud stores and searches only encrypted vectors — it cannot read your data
• Rune-Vault holds the secret key and decrypts only similarity scores — it never sees the content
• Plaintext never leaves your machine