/ sovereign agent harness

Discipline any AI agent. Cut the token bill by up to 70%.

PRISM wraps Claude Code, Codex, OpenCode — any agent: it forces your rules before the first line is written, routes across models and coding plans, compresses context hard, and reviews every MR against your own standards. Same model, measurably better work — at a fraction of the token cost.

You don't need all of PRISM — pick what solves your problem. The harness alone gives you steering files and team skills; prism-chat alone is a lean, fast way to talk to your models.

Install — one line Talk to your models: prism-chat See the six components 
curl -fsSL https://git.sovereign-society.org/prism/prism-harness/raw/branch/main/install.sh | sh

Works with the agent you already run. Free, sovereign, LSL-1.0.

curl | sh Meta-installer — six components, scaffolded, ~30s @prism/* bun add -g from the sovereign registry, ~10s pacman Arch / CachyOS local-repo meta-package podman One-in-all container from R2 — quadlet-ready services
77→93 benchmark points the harness alone moves — same model, different harness (independent testing)
up to 70% context cost cut by stacked compression: RTK → vision WebP@87 → Caveman
6 / 1 six composable components on one Bun runtime — bundles measured in KB
0 API keys in environment variables — file-based secrets, full redaction everywhere

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.

You want…You needYou can skip
Steering files, a real git workflow, team development skills prism-harness Everything else — the doctrine alone is enough to discipline your agent.
Route across providers and models, rotate plans, keep keys safe prism-route loop, sober, proxy, chat — unless you want their layers too.
Cut token bills and audit what eats your context window prism-proxy The rest — proxy works on its own as a loopback compressor.
Overnight memory; an agent that resumes tomorrow prism-loop The rest — loop is self-contained durable memory.
Enforce your standards on every MR review prism-sober The rest — sober is the review steering layer alone.
Just talk to your models — a lean, fast Hermes/OpenClaw-style chat, no agent in the loop prism-chat The harness and plugins — chat is a direct, efficient line to your models.

Prefer it explicit? prism-chat is the lightweight way to talk straight to a model — super fast, no agent, no doctrine required. Want your agent disciplined too? Add prism-harness.

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

Smarter agents — prism-harness

Twelve doctrine rules + templates scaffolded into your repo. Any visiting agent reads them first. AI-slop stops at the door.

One constitution for every agent you use.

Smaller bills — prism-proxy

Loopback proxy audits what eats your context window (ranked tool table) and compresses: RTK for tool bloat, real WebP vision for prose, Caveman for the rest. Errors, stacks, and results preserved.

See exactly what is eating tokens. Then cut it.

Multi-model routing — prism-route

KDL profiles, 5h/weekly plan rotation, failover tiers, file-based secrets from ~/.secrets/, Prometheus metrics. Agents never see a key.

Never leak keys in env. Rotate expensive plans automatically.

Overnight memory — prism-loop

Durable .prism/ memory and clean run boundaries. The agent resumes tomorrow where it stopped tonight.

Overnight work that actually remembers.

Enforced reviews — prism-sober

Byte-capped steering files carry your doctrine into every automated MR review. Your standards, not the reviewer's mood.

Your rules, enforced on every MR.

Chat without an agent — prism-chat

Terminal chat (ask/repl) and a local installable PWA riding the same gateway. Talk to your routed models directly.

For when you don't want an agent — just the model.

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 line, 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 — one line

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. Six components, one Bun, dist/*.js bundles measured in KB — auditable in an afternoon.
  • 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. Six components →

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.

Ship better agent work, for fewer tokens

Install PRISM now Read the FAQ