The Alkhemy mark: a dark cast iron letter A with a gold flame burning in its counter

Muninn · an Alkhemy product

What steered your agent.What it changed.

Muninn connects what steered an AI agent to what it changed, and signs the evidence: a content-free Context Receipt on every AI-authored pull request, before you merge.

One click installs it. Receipts start posting on your next AI-authored pull request. No terminal, no config.

Verified receipt
signature
ed25519 verified
governed
6 of 7 sources
shadow
1 ungoverned, flagged
sig
3BhEtDhWI67jXD99…
GitHub-verified identity·ed25519-signed receipts·Zero-trust, content-free·Runs at the edge

The problem

Your scanner reads the code. It never reads what told the agent to write it.

AI agents now open pull requests with real credentials, real tools and real authority. What steered each change lives in CLAUDE.md, AGENTS.md, rules files, memory and MCP config, and your review sees the diff without it.

Identity knows who the agent is. AppSec knows what the code contains. Muninn is the join between them: what steered the agent, and what it changed.

01

Context collisions

A CLAUDE.md line names a file this pull request deletes. Two rules files contradict each other. Muninn flags the collision across Claude, Cursor, Codex and AGENTS.md context in one pass.

02

Signed, content-free receipts

Every AI-authored pull request gets an ed25519-signed Context Receipt. Your contents stay in your CI. Change one byte and the signature breaks.

03

Admission lanes

Secret-shaped or injection-shaped memory is flagged before it can steer the agent. Doubtful memory is quarantined with a warning.

Next on the roadmap: checking what a change actually does against what the agent was asked to do.

How it works

From hidden context to a signed receipt.

Four beats, one section. Muninn governs the context your agent trusts without ever receiving your code.

Step 1

Your agent writes from hidden context

Session memory, a stale doc, a rule from ten prompts ago. None of it reviewed, all of it steering the diff. You see the pull request. You never see what told the agent to write it.

context.hiddenunreviewed
  • › ctx://memory/decisions.md#a91f
  • › ctx://retrieved/snippet#e40c provenance=?
  • › ctx://memory/notes.md#33d1 age=94d
  • › ctx://rules/repo.json#1a2b

Trust & security

Controls you can take to your security team.

Content-free by architecture. Every control here is built and tested, not a promise. Trust the math, not the vendor.

Content-free by architecture

Muninn never receives your raw code, file contents, matched strings, secrets, or memory objects. Receipts carry signed, content-free signals: risk classes, counts, timestamps, public PR references, and keyed-HMAC pointers in place of file paths. The opt-in Muninn Map works with repo-relative paths and counts, never contents.

GitHub-verified identity

Identity is established through GitHub App installation and key-binding, not a self-asserted email. The app that signs your receipts is the app you installed.

ed25519-signed Context Receipts

Every receipt is cryptographically signed. Change one byte and the signature breaks. Your tooling can verify it without trusting our word.

An offline verifier

Receipts will verify offline against a public key you pin, with no call to Muninn, GitHub, or your CI. The verifier is built and tested, and publishes at launch. You check the evidence, not the UI.

Governed is not the same as approved

A memory being in a repo does not mean anyone approved it to steer your code. Muninn separates governed context (committed, diffable) from trusted context (reviewed and blessed). When they collide, it shows the collision instead of picking a winner.

It explains before it stops

Muninn observes and explains by default. Hard stops apply only to deterministic rules you approved. If it did not observe your context, it says so. It never fails your build over something it could not see.

The difference

The same pull request, one receipt apart.

An AI opened this PR on context you never reviewed. Without Muninn, it merges. With Muninn, a signed receipt reveals the ungoverned context first.

Without MuninnMerged
fix(auth): migrate session store to Redis
#482 · claude-agent wants to merge into main
-store: new MemoryStore()
+store: new RedisStore(env.REDIS_URL)
~// per memory/decisions.md (94d old)

No receipt. The diff was reviewed; the context behind it was not. Ungoverned session memory, a decision reversed months ago, merged into main. Nobody caught it.

With MuninnReview required
fix(auth): migrate session store to Redis
#482 · claude-agent wants to merge into main
-store: new MemoryStore()
+store: new RedisStore(env.REDIS_URL)
~// per memory/decisions.md (94d old)
Context Receipt
verdict
needs review
finding
ungoverned context presented
source
session memory (unsigned)
sig
ed25519:9Kd2Fp…

caught before merge

The receipt reveals which context was governed and which was not. It does not read your code or claim to detect intent. It shows you the ungoverned context behind the diff, and signs it.

Pricing

Metered by the receipt, not the seat.

Start on Proof Run, free, no card. Install the GitHub App and receipts begin posting on your AI-authored PRs. Upgrades happen inside the dashboard once you are in.

Proof Run

The solo dev or team lead deciding whether this is worth paying for.

$0no card
Start free
  • 25 Context Receipts total (one-time)
  • 1 repository
  • 1 full context audit report
  • Remediation repair-plan preview (no apply)
  • 7-day receipt history
  • Receipts posted on your PRs

Builder

Start here

The indie hacker shipping fast with Claude Code, Cursor, Codex, or Copilot.

$19/ mo
Add the GitHub App
  • 500 Context Receipts / month
  • 3 repositories
  • 30-day receipt history
  • Full PR receipt comments + audit reports
  • Remediation preview + manual apply
  • Ungoverned exposure & influence rates, .muninnignore, email support

Team

Small teams and platform leads adopting AI responsibly.

$199/ mo
Add the GitHub App
  • 5,000 Context Receipts / month
  • 25 repositories, 10 users
  • 180-day receipt history
  • Everything in Builder
  • Team policies, shared approvals
  • Private receipt archive, priority support

Coming: required GitHub checks that can block a merge

Alkhemy

Get started

Two steps to governed context.

Install the GitHub App for signed Context Receipts on every pull request. Run one local check to see what is steering your agent, before it writes a line. Both are live today.

1

Add the GitHub App

One click. Muninn provisions the repo, opens the first pull request, and starts posting signed Context Receipts. No keys to paste, no config to write.

2

Run the local context check

One check on your own machine shows you exactly what is steering your agent, before it acts. Content-free by design: nothing about your code ever leaves. Included the moment you install, no account and no keys.

One install. Muninn does the rest and stitches everything together on the backend.

View the script first