Prismor

Self-hosted runtime control plane that observes, asks, or blocks an AI agent's tool calls before they execute — and shows it all in a local dashboard.

Stars
★ 583
Last updated
today
License
Apache-2.0
Primary language
Python

At a glance

How it runs
CLISelf-hosted serviceWeb app
Works with
Universal · cross-platformCodex · Claude Code · OpenAI API · Claude API
Cost
Free software; you pay for model usage
Setup effort
Low · running in minutes
You'll need
Python (pip)npm / pip / cargo / go package managers (for supply-chain gating)Shell / CLINetwork accessLocal filesystemMCP Server
Typical use
A security engineer onboarding a team to Claude Code starts with prismor mode apply dev-safe --observe, watches real traffic for two weeks, then flips the highest-risk rules to enforce.
Not a fit if
  • Teams expecting blocking out of the box without policy tuning
  • Teams unwilling to insert a proxy in the agent's model path
Website
prismor.dev ↗ set on GitHub
Maintenance
Commits in the last 30 dayslast commit 2026-11-20latest release v1.79.0 (2026-11-20)+13.7 ★/day over 7 days
Source review
61/100 · Some gaps

What does this agent do, and when should you use it?

Prismor is a self-hosted runtime security layer for AI agents, installed with pip and driven from the terminal. It wires native hooks or plugins into coding agents (Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot CLI, Kiro, OpenCode, OpenClaw, Hermes and more) so every tool call is normalized into one canonical event and judged by a single YAML policy engine before it actually runs. Where hooks are impossible it offers other doors into the same evaluator: an MCP Gateway that fronts every MCP server and injection-scans responses, framework SDK adapters for 13 production frameworks, an eval-server, and an LLM Proxy that governs an agent purely through its model traffic. Findings land in a local SQLite/JSONL session store, visible through the prismor dashboard web UI or the terminal, and backed by a hash-chained, Ed25519-signed audit trail. Everything starts in observe mode; nothing blocks until you flip individual rules to enforce.

Running prismor install-hooks --agent all writes hook-dispatch entries into each agent's own config (for example <workspace>/.claude/settings.json, .cursor/hooks.json, .codex/hooks.json) so Prismor receives PreToolUse, PostToolUse and UserPromptSubmit events. A tool-call dispatcher hands each event to the policy engine, which evaluates .prismor/policy.yaml rules that each carry their own mode: observe or enforce, layered org → project → repo with a non-overridable floor. Pre-execution checks include the semantic guard (prismor semantic-check, a regex pre-screen plus an LLM judge), egress control, MCP guardrails, tool tags, IAM, per-session scoped-agent rules and a Docker sandbox. Secret handling adds Sweep and Cloak placeholders, env guard and canary honeytoken files. Supply chain protection comes from prismor supplychain, which wraps npm, pip, pnpm, cargo and go installs and scores them on package age, maintainer count, install scripts and IOC matches (<30 allow, 30–59 warn, ≥60 block). Verdicts are persisted and surfaced through prismor dashboard, prismor traces, and verified with prismor trail verify.

  1. A security engineer onboarding a team to Claude Code starts with prismor mode apply dev-safe --observe, watches real traffic for two weeks, then flips the highest-risk rules to enforce.
  2. A platform team aliases npm and pip to prismor supplychain so an agent cannot install a package from a hijacked maintainer account or a flagged IOC, even when it is optimizing for velocity.
  3. A compliance owner preparing for an audit runs prismor attest verify on an Ed25519-signed bundle mapping controls to OWASP LLM/Agentic, NIST AI RMF and EU AI Act.
  4. Several agents share one workspace, so IAM gives each a named identity and a least-privilege profile instead of one blanket permission set.
  5. An agent has no hook protocol, so its model traffic is pointed at prismor proxy via ANTHROPIC_BASE_URL or OPENAI_BASE_URL and every proposed tool_use / tool_calls is judged by the same rules.
  6. Right after installation, prismor analyze-history replays on-disk transcripts through the live policy engine so you can see what would have been blocked before you enforce anything.

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Install / run
  • pip install prismor
  • pip install "prismor[pii]"
Config files
.prismor/policy.yaml

How do you install or deploy this agent?

Requires a Python environment (installed via pip); supply-chain gating additionally needs the npm / pip / cargo / go package managers present on the host.

pip install prismor
prismor setup

On PEP 668 systems the README points to docs/installation.md, which covers pipx, a Skill, curl and git-clone alternatives.

Install hooks, choosing scope and starting posture:

prismor install-hooks --agent all --scope project --mode observe

Configure the semantic judge non-interactively:

prismor setup --non-interactive --judge claude
prismor setup --non-interactive --judge codex
prismor setup --non-interactive --judge api --judge-model gpt-4o-mini

Optional PII detection is an extra install:

pip install "prismor[pii]"

How do you use this agent?

Pick a governance posture first, then open the local dashboard:

prismor mode list
prismor mode explain dev-safe
prismor mode apply dev-safe
prismor dashboard

Enforcement is per rule in .prismor/policy.yaml:

# .prismor/policy.yaml
settings:
  default_mode: observe        # global default for rules without their own mode
rules:
  - id: destructive-rm-rf
    mode: enforce              # this rule blocks; the rest still just observe

When a rule blocks something legitimate, the deny message prints the narrowest unblock command; gate package installs through the wrapper:

prismor allow destructive-rm-rf --pattern '<literal>'
prismor supplychain npm install express
prismor supplychain npm install @tanstack/react-router   # BLOCK: IOC match
prismor supplychain harden --dry-run

Verify the evidence and health-check the install:

prismor trail verify
prismor doctor

Three independent layers can restrict a session; the soft-disable path is:

prismor uninstall-hooks --agent claude --scope project
prismor uninstall-hooks --agent all --scope user
PRISMOR_LOCAL_DRY_RUN=1
prismor scope clear <session-id>

What are this agent's strengths and limitations?

Pros
  • One policy engine backs every enforcement surface — hooks, MCP Gateway, framework SDK adapters, eval-server and LLM Proxy — so a rule written once applies the same action however it arrives, and tests/test_surface_conformance.py fails the build if surfaces disagree on a verdict.
  • Breadth of interception: native hooks or plugins for Claude Code, Codex, Cursor, Gemini CLI, Copilot CLI, Kiro, OpenClaw, Hermes, OpenHands and others, plus config-scan coverage for Aider, Trae and similar.
  • Safe rollout is built into the model: everything observes by default, and the enforce install starts with nothing selected so a human explicitly picks what blocks.
  • Supply-chain checks wrap npm/pip/cargo/go with risk scoring and IOC matching, and prismor supplychain harden writes .npmrc / pip.conf / .cargo/config.toml so protection survives alias bypasses in CI or IDE plugins.
  • Evidence is verifiable rather than asserted: a hash-chained Ed25519-signed trail (prismor trail verify) plus a signed attestation bundle (prismor attest verify) and a dependency-free receipt verifier for SIEM or auditors.
  • Fully self-hosted: the dashboard binds 127.0.0.1 and session data lives in local SQLite/JSONL, so logs need not leave the machine.
Limitations
  • Nothing blocks out of the box — every rule starts in observe, so real protection requires deliberate per-rule selection and tuning.
  • Enforcement state is spread across three independent layers (hook install mode, PRISMOR_LOCAL_DRY_RUN, scoped-agent rules); scoped rules are hardcoded to enforce, so uninstalling hooks will not lift a scoped denial.
  • The semantic guard depends on an external LLM (Claude CLI, Codex CLI, or a litellm model plus key), adding latency and cost; without a judge only heuristics run.
  • Supply-chain gating only applies when the package manager is invoked through prismor supplychain or an alias; otherwise only the harden-written config files restrict it.
  • The surface area and documentation are large (CLI reference, integration matrix, layered policy, exemptions), so a new adopter needs time to build the full mental model.

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Prismor This agent 61 · Some gaps CLIFree + model costs ★ 583 today Python Codex · Claude Code · OpenAI API · Claude API
HOL Guard 80 · Good CLIFreemium ★ 1.1k today Rust Codex · Claude Code
Orca AI Incident Archive 60 · Some gaps — ★ 329 9d ago HTML —
Cordum Agent Control Plane 75 · Some gaps Self-hosted serviceFree ★ 507 3d ago Go Claude Code

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Some gaps
61/ 100 5-point scale 3.1 / 5
This review covers the source as of Nov 11, 2026. The project has shipped 5 stable release(s) since, which have not been re-reviewed. The score and verdict describe the reviewed version only. Recent releases ↓
Trust 17/29
Reliability 8/14
Adaptability 14/18
Convention 11/18
Effectiveness 7/13
Verifiability 4/8
Why each dimension lost points
Trust17 / 29 · 2.9/5

Evidence shows observe-by-default, explicit enforce selection, force-enforced self-protection rules, password-gated unlock window, dashboard bound to 127.0.0.1 with Host/CSRF checks, and Ed25519-signed audit trail — real least-privilege and confirmation mechanisms. Deductions: curl installer sends anonymous install telemetry (opt-out available), dashboard loads CDN/Google Fonts per FAQ, dependency security rests on a hard PyYAML check and OSV lookups with no lockfile or audit evidence in the packet, and source attribution relies on README badges plus a marketplace.json email with unverified publisher identity.

Reliability8 / 14 · 2.9/5

CLI fails loudly when PyYAML is missing, hook fail-open behavior is documented, block messages carry rule id and remediation command, and self-consistency across README/AGENTS/CLAUDE is good. Deductions: dependency availability covers only PyYAML and optional extras with no full pinned manifest; Windows cloak unsupported and Codex requires a one-time trust step, which are environment-specific reliability gaps.

Adaptability14 / 18 · 3.9/5

README and AGENT_INTEGRATIONS cover many agents and frameworks; SKILL.md gives a trigger→command→recovery decision tree; getting-started targets non-experts. Deductions: capability boundaries are asserted via modes but the modes doc is not in the packet; trigger precision relies on the SKILL.md table with no false-trigger data; environment fit has explicit unfinished items (macOS system install, Windows cloak).

Convention11 / 18 · 3.1/5

Full Apache-2.0 LICENSE, SECURITY.md with private disclosure channel, detailed per-platform install docs, and clear FAQ/glossary structure. Deductions: no CHANGELOG or versioning policy document (only an upgrade-compat note in README), maintenance responsibility rests on marketplace.json and SECURITY emails with unverified publisher, and information architecture is only partially represented in the sampled docs.

Effectiveness7 / 13 · 2.7/5

Output usability is solid: block messages include rule id and the exact prismor allow fix, and dashboard/CLI expose sessions and findings. Deductions: marginal value depends on rule quality with no hit-rate or false-positive data in the packet; cost-benefit is unquantified — per-call hook overhead, external dashboard assets, and optional LLM judge add cost without a stated performance budget.

Verifiability4 / 8 · 2.5/5

Docs are candid about their own limits (e.g. 'we could not find' phrasing, fail-open note, unsupported Windows items), showing some fact/inference separation. Deductions: many capability claims (17-agent interception, MCP mirror verified) rest on README tables and a generator script with no tests or logs in the packet; cross-source corroboration is thin and no independent verification is present.

Risks and how to mitigate them
  • The curl installer sends anonymous install telemetry; opt out with PRISMOR_NO_TELEMETRY=1 or DO_NOT_TRACK=1.
  • The dashboard loads a chart library and Google Fonts from CDNs, which can break on offline or restricted networks.
  • Hooks fail open: agents treat hook failure as non-blocking, so 'installed' can mean 'screening nothing'.
  • Cloak is unsupported on native Windows, and Codex screens nothing until its hooks are trusted once.
  • Publisher identity is unverified; verify PyPI package and GitHub release provenance before installing.
  • No full dependency manifest or lockfile appears in the packet; audit dependencies independently.
Evidence confidence: Low Reviewed Nov 11, 2026 Reviewed revision 44641100dc7e New commits since this review; the score may not cover them
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/prismor.svg)](https://followagents.com/en/agents/prismor)
<a href="https://followagents.com/en/agents/prismor"><img src="https://followagents.com/badge/prismor.svg" alt="FARS review"></a>

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. v1.79.0
    Release notes excerpt
    What's Changed * sandbox: say when the egress allowlist only logs; docs add egress mode enforce by @Ar9av in https://github.com/PrismorSec/prismor/pull/977 * telemetry: ship path from structured evidence under full capture by @Ar9av in https://github.com/PrismorSec/prismor/pull/980 * fix(staged-exec): cut untrusted_content false positives by @Ar9av in https://github.com/PrismorSec/prismor/pull/981 Full Changelog: https://github.com/PrismorSec/prismor/compare/v1.78.0...v1.79.0
    View on GitHub ↗
  2. v1.78.0
    Release notes excerpt
    What's Changed * sandbox: fail closed in enforce mode; only a person can turn it off by @Ar9av in https://github.com/PrismorSec/prismor/pull/975 * Context panel: limit source, model switches, subagents; drain the usage spool by @Ar9av in https://github.com/PrismorSec/prismor/pull/976 Full Changelog: https://github.com/PrismorSec/prismor/compare/v1.77.0...v1.78.0
    View on GitHub ↗
  3. v1.77.0
    Release notes excerpt
    What's Changed * feat: allowed models and spend budgets per session, agent, user, device by @Ar9av in https://github.com/PrismorSec/prismor/pull/952 * cloak: Vault/OpenBao, Infisical and AWS Secrets Manager sources by @Ar9av in https://github.com/PrismorSec/prismor/pull/953 * Org vault: sync secrets the console seals to this device by @Ar9av in https://github.com/PrismorSec/prismor/pull/954 * ci: Claude auto code review on PRs by @Ar9av in https://github.com/PrismorSec/prismor/pull/955 …
    View on GitHub ↗

FAQ

Will it block my agent immediately after install?
No. Every rule defaults to observe, which logs findings without blocking. Blocking starts only when you set a rule or settings.default_mode to enforce in .prismor/policy.yaml — and a policy rule set to enforce blocks regardless of the --mode the hooks were installed with.
Which agents can it actually intercept?
Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot CLI, Kiro, Crush, Goose, Grok Build, OpenHands, Qwen Code, Continue CLI, OpenCode, OpenClaw, Hermes and Antigravity via native hooks or plugins; Aider, Trae, Warp, Roo Code and similar are config-scan only; production frameworks include OpenAI Agents SDK, LangChain/LangGraph, CrewAI, Pydantic AI, AutoGen Core and Google ADK.
Do I need my own API key for semantic prompt-injection detection?
Not necessarily. The judge can run on a Claude Code or Codex CLI login you already have (--judge claude / --judge codex), or on any litellm model via --judge api with a key. Until you pick one, only the heuristic pre-screen runs.
Does my data leave the machine?
The core is self-hosted: policy, session store and audit trail are local and the dashboard serves on 127.0.0.1. Data leaves only through opt-in paths — the configured LLM judge, optional Live Telemetry to an enterprise control plane, or telemetry sinks you enable.
A legitimate action got blocked — how do I unblock it?
The deny message prints the narrowest fix, such as prismor allow <rule> --pattern '<literal>', or you can set the rule back to observe. Agents cannot edit Prismor's own config; a human must open a short password-gated window with prismor unlock.
Is Prismor free?
The software is free, but Prismor calls an AI model, and you pay that model provider for usage (or run a local model).
Is Prismor open source?
Yes. The source code is on GitHub (PrismorSec/prismor) under the Apache-2.0 licence.
Is Prismor safe to use?
FollowAgents' FARS review (Nov 11, 2026) scored Prismor 17/29 on trust and safety. None of the eight safety controls the review checks for was missing outright. The repository has changed since that review.
Is Prismor still maintained?
Yes. The latest commit on GitHub is from 2026-11-20, within the last 30 days. The latest release is v1.79.0 (2026-11-20).
Who makes Prismor?
Prismor is published on GitHub by the account PrismorSec. FollowAgents has not verified which person or company is behind that account.
What is Prismor's official website?
The project's GitHub repository lists https://prismor.dev as its website. That link is set by the repository owner; the source code itself is on GitHub (PrismorSec/prismor).
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts