Know what breaks when your AI stack changes.

Moonwire records the data, policies, prompts, models, tools, and code behind AI-generated artifacts. When one changes, it identifies the memories, decisions, and pending actions that may need review before reuse or execution.

See the 90-second recall demo →View GitHub →Documentation →
Artifact manifestContent stays with you
payment-decision:9281
DATAsupplier-risk:v182
POLICYpayment-policy:v7
PROMPTfinance-agent:v31
MODELfinance-model:2026-08
TOOLpricing:v12
CODEgit:abc123
CHANGEsupplier-risk  v182 → v183
DECISIONREVALIDATE
PENDING PAYMENTBLOCKED

Deterministic recall demo

Manifest. Change. Impact. Block.

No LLM key. No external service. In under 90 seconds, create a payment decision manifest, change one supplier-risk version, inspect the exact blast radius, and watch a critical pending payment refuse execution.

Run the demo →
Terminal demo: a supplier risk change makes a payment decision require revalidation and blocks a pending payment

Problem

Every durable AI artifact needs an ingredient label.

A decision can survive long after its data, policy, prompt, model, tool, or code version changes. Without a manifest, the application cannot reliably recall everything produced from the changed dependency.

When an ingredient changes, Moonwire performs the recall.

{
  "canonical_ref": "mw://acme/prompt/payment",
  "kind": "PROMPT",
  "version": "sha256:…",
  "metadata": {
    "owner": "finance-platform"
  }
}

No prompt or decision text is stored.

How it works

Label. Recall. Gate.

The graph engine remains evidence lineage. Typed dependencies expand it into deterministic AI change control without evaluating model reasoning or storing customer content.

1 · LabelAttach an atomic manifest to every durable artifact.MANIFEST
2 · RecallFind direct and transitive blast radius when one version changes.IMPACT
3 · GateRefuse important reuse or execution until external revalidation.BLOCK
transactional direct markdurable cycle-safe propagation

30-second code example

Record what produced the artifact.

Your application keeps the content. Moonwire receives references, kinds, exact versions, criticality, selectors, and lineage.

example.pyPython 3.10+
import os

from moonwire import Moonwire

with Moonwire(api_key=os.environ["MOONWIRE_API_KEY"]) as moonwire:
    with moonwire.execution() as run:
        run.evidence(
            ref="mw://acme/policy/refunds",
            kind="POLICY",
            version="v7",
            selector={"fields": ["refund_window_days"]},
        )
        result = my_agent(...)
        artifact = run.commit(
            type="decision",
            criticality="HIGH",
            external_id="payment-decision-9281",
        )

moonwire.require_valid(artifact.id)

Deliberately narrow

Moonwire vs observability vs evals

ObservabilityAsks what happened during an execution.
EvalsAsk whether an output satisfies a quality or correctness test.
TTL / cacheAsk whether one value is old or should be evicted.
MoonwireAsks what produced a persisted artifact and what depends on a changed input.
Complementary infrastructure. Moonwire tracks change impact; it does not claim to know truth or replace evals.

Fit

Should I use Moonwire?

Use Moonwire if

  • Generated outputs persist beyond one request.
  • Outputs depend on mutable data, policies, prompts, models, tools, or code.
  • A stale decision or pending action has meaningful consequences.
  • You need auditable dependency manifests and blast-radius analysis.
  • Regenerating everything constantly is impractical.

You probably do not need it if

  • Every response is fully ephemeral.
  • Every request fetches current dependencies and nothing is reused.
  • Dependency change has no meaningful consequence.
  • You already implement equivalent explicit lineage and invalidation.

Self-hosting

One service. One database.

terminalDocker Compose
$ git clone https://github.com/pycarrot/moonwire
$ cd moonwire
$ docker compose up -d --build --wait

✓ postgres  healthy
✓ moonwire  healthy
Your applications
SDK · CLI · REST
HTTP API
Worker
PostgreSQL
state · outbox · audit

Security and privacy

Infrastructure that minimizes what it knows.

API authenticationBearer keys are protected with individually salted Argon2id hashes, with expiry, revocation and documented rotation.
Project isolationEvery resource, version, artifact, edge, event and job is scoped to an authenticated project.
Metadata minimizationStrict body limits and JSON objects keep storage explicit. Customer payloads are never logged by default.
Content stays with youStore references, versions and hashes. Keep policy text, customer records and agent output in your own systems.

Documentation

Everything needed to evaluate and operate Pulse.

›_QuickstartRun the complete evidence-change flow.→⌘Core conceptsResources, versions, artifacts, edges and status.→APIAPI referenceOpenAPI 3.1 schemas and stable error contracts.→OPSSelf-hostingDeploy, observe, back up and recover.→SECSecurityThreat model, hardening and responsible disclosure.→

Open source · local first

Dependencies change. Know what needs attention.

Apache-2.0 licensed change-control infrastructure. Self-host it with PostgreSQL; keep prompts, policies, customer records, code, and generated outputs in your own systems.

View on GitHub →Read the docs →