Your knowledge travels.
Its evidence comes with it.

The portable-knowledge revolution: AKF.

A decision can outlive its chat session. Keep the conclusion, source revision, selected evidence and publication history together in a signed, readable bundle. A new agent can inspect where the knowledge came from.

1. CurateConclusion + evidence
2. PublishValidate + authorize + sign
3. TransferRecipient verifies its own trust
4. RetrieveBounded pages + exact citations

JARVIS/Mnemos owns authentication and governed publication. PRISM delivers the packet to your selected agent. A signed snapshot authenticates bytes; factual truth and freshness still need checking. Copying it grants no execution or publication rights.

See the worked transfer and inspect the evidence · Configure the Knowledge adapter

Models propose. Rules check. Evidence stays.

The implemented doctrine gate makes no model call. PRISM evaluates captured guidance; JARVIS admits execution under policy and records the result.

1. CaptureFresh guidance
2. CompareSelected baseline
3. AssertComplete; no added errors
4. HaltReceipts + audit

Repeatable evaluation uses the same captured inputs and evaluation identity. Fresh runs can see changed files; replay preserves a historical result. Incomplete evidence cannot qualify as a pass. Model reasoning and live external effects retain their own uncertainty.

Understand determinism · Run the doctrine example

What do you actually need?

Every PRISM component is independent. Start from your goal, install the minimal set that solves it, and skip the rest. You can always add more later — nothing requires the full suite.

The harness moves the benchmark — not just the model

Independent benchmarks show the same model scoring 77% and 93% on identical tasks depending on the harness it runs in. The model did not change — the system prompt, tool descriptions, and permission gating did. Models get dumber past ~50k tokens of context; a smart harness budgets context instead of stuffing it.

PRISM is that harness, made sovereign: doctrine your agent must read before it writes, compression that preserves every error and stack trace, routing that decides which model and which plan pays for each call. Your model choice stays yours. The discipline becomes ours.

What you get

GitSpawn-class defense: ships in every CLI

The Sept 2026 wave of malicious-git-config attacks (full writeup) showed that a repo delivered as a zip, USB stick, cloud-sync folder, or shared drive can carry core.fsmonitor = <attacker command> in its .git/config. Any subsequent git call triggers git to read the local config and run the attacker's command as the operator — before any sandbox, prompt, or approval gate fires.

PRISM neutralizes this at two layers today. A third, the pinned installer, is not available yet.

prism-chat: your lean, fast line to the models

Want a Hermes / OpenClaw–style chat that talks straight to a model — no agent in the loop, no doctrine, nothing heavy? prism-chat repl / ask is that: lightweight, fast, efficient. Point it at a gateway and it streams answers with session usage — the browser never touches a key.

# standalone lean chat — point at a gateway (default http://127.0.0.1:8788)
$ prism-chat repl --gateway http://127.0.0.1:8788 --dialect openai --model gpt-4o-mini

# or, with prism-route in front for routing + rotation + safe keys:
$ prism-route serve --profile frontier --bind 127.0.0.1:8788   # terminal 1
$ prism-chat repl --profile frontier                            # terminal 2
you> explain CRDTs in two sentences
prism> …

$ prism-chat serve   # → http://127.0.0.1:8789 (installable PWA)

prism-chat on the forge ↗

How it works — three steps

1. Pick what you need. Start from your goal (see the table above) and install the minimal subset — or --yes for everything. One installer, one shared Bun runtime.
2. Scaffold. prism-harness init drops the doctrine into your repo, or prism-route setup walks you through providers/models. Forge the agent's identity with prism-harness identity init.
3. Use it. Point your agent through prism-route serve → prism-proxy for routed, compressed, reviewed work — or skip the agent entirely with prism-chat for a direct line to your models.

Install

The eight-file identity canon: give the agent a soul

Doctrine tells the agent how to work. The identity canon tells it who it is: charter, soul, goals, milestones, heartbeat — eight files at ~/.prism/identity/. The agent's name is the last question of the forge, so by the time it gets one, the purpose already fits.

How the canon works →

Sovereign by construction

• No telemetry, no central control. Operator-local logs, loopback by default, plaintext-passthrough you can security-scan.
• Keys stay on disk. File-based secrets in ~/.secrets/, redaction on every human surface, zero env leakage.
• One runtime, small bundles. Eight components, one Bun, dist/*.js bundles measured in KB — auditable in an afternoon.
• GitSpawn-class defense in every CLI. core.fsmonitor payloads can't fire against a target you've prepared with prism-* scrub.
• Yours to keep. Distribution runs on the sovereign forge — no public registries. Prebuilt container images ship from R2 at pkg.getharness.app and run as systemd quadlets. Eight components →
• Knowledge you own. prism-mem carries your project brain as signed, plain-file AKF bundles — no vendor memory lease. Portable memory →

Honest boundaries

PRISM is a harness, not an agent: it does not generate code, and it is not a vendor platform or a model wrapper — models stay yours. That is the point. The harness is the set of tools, prompts, and operational discipline an agent is plugged into. Plug yours in.