Prism Coder
Give your AI agent memory that lasts. Persistent sessions, knowledge graphs, and offline tool-routing — fully local and free.
Prism Coder is an MCP server that gives Claude, Cursor, and other AI tools long-term memory that survives across sessions. It ships with the open-weight prism-coder model fleet (2B–27B) for fast, offline tool-routing — no cloud required.
No account needed. No API keys. Runs on your machine.
A paid subscription adds cloud sync, higher model tiers, and team features through the Synalux portal.
What Prism gives you
- Session memory that survives restarts — resume projects with handoff notes, recent work, open TODOs, and configurable quick, standard, or deep context.
- Local-first inference — bounded work is routed through local Ollama models first, with automatic 2B/4B/9B/27B selection based on installed models, available RAM, context fit, and subscription entitlements.
- Route-output enforcement — route mode returns only well-formed calls to
tools the host actually advertised. Standard and higher plans can add
authenticated deterministic correction;
route_guard: "local"keeps the prompt and draft entirely on-device. - One setup for every agent —
prism connectconfigures Claude Code, Claude Desktop, Cursor, Gemini CLI, and Codex while preserving unrelated settings. - Subscription-aware skills — entitled skills are synchronized before the host launches, with safe upgrades, downgrades, conflict preservation, and offline last-good recovery.
- Hook-free startup — MCP metadata and native instructions request Prism's startup context without requiring lifecycle hooks or a Prism-owned launcher.
- Safe escalation and observability — inference outcomes are explicit, reserved content remains fail-closed, and local/cloud usage is recorded for review.
Get started
npm install -g prism-mcp-server
prism connect
Use prism connect --dry-run to preview changes, prism connect --all to
configure every detected host, or prism connect --refresh to reconcile
Prism-managed entries after an upgrade. Restart the host after connecting.
Prism works locally without an account, API key, or cloud subscription. Add a Synalux subscription when you want cloud memory, paid-tier skills, or team features.
What's New in v20.2.7
Session Saves Survive Agent Restarts
Prism now remembers that a conversation successfully loaded its project context
when the MCP server restarts or another Prism process handles the next request.
session_save_ledger and session_save_handoff no longer fail with a false
context_not_loaded error in that flow.
The recovery remains fail-closed: authorization is limited to the exact project and conversation, expires with the existing context window, and stores no plaintext conversation identifier. Cross-project, forged, malformed, expired, or future-dated receipts are still rejected. The release also updates PostCSS to the patched 8.5.23 release.
What's New in v20.2.6
Safer Configuration Updates Across Every Agent
prism connect now reads Claude, Cursor, Gemini, and Codex configuration
through a single verified file snapshot, preventing another process from
swapping a file between Prism's safety check and its read. Supported symlinked
dotfiles still work, while dangling or planted symlinks fail loudly instead of
being followed or overwritten. This release also carries the patched
dependencies and cross-platform release checks introduced in v20.2.5.
Cloud fallback is now documented consistently as Gemini 3.6 Flash. Plan
ceilings govern automatic prism_infer routing; direct use of any downloaded
model through local Ollama remains free on every tier.
What's New in v20.2.4
Reliable Session Memory That Shows Work, Not Greetings
Greeting-only assistant replies are skipped before ledger writes. Existing
greeting rows are filtered at read time across native startup, MCP context, and
prism load --json, while entries containing decisions, TODOs, changed files,
or non-session events remain visible. Historical rows are not destructively
deleted. If Synalux has a transient startup failure, Prism displays one bounded
local last-good snapshot and clearly labels it; permanent authorization or
validation failures still fail loud, and later writes remain cloud-routed.
What's New in v20.2.2
One Local-First Workflow Across Every Agent
prism connect now installs one orchestration contract for Claude Code,
Claude Desktop, Cursor, Gemini CLI, and Codex. Bounded delegated work goes to
session_task_route and the local prism_infer worker first; routine work must
not create background host agents. Local workers can receive the active
project's dashboard-configured quick, standard, or deep memory and select a
RAM-safe 2B/4B/9B/27B model at call time. The router forwards complexity but
does not choose the model; prism_infer owns the final decision using memory
and context fit, installed models, live RAM, entitlements, and explicit caller
overrides.
Codex and Gemini native agent fan-out are disabled during connect. Codex keeps
a two-thread, one-level Terra/low fallback profile if the developer explicitly
re-enables native agents later. Claude Code keeps native agents as a last-resort
path but pins their model to Sonnet. Cursor and Claude Desktop do not expose a
supported global subagent-policy file, so they receive the identical workflow
through Prism's MCP server instructions. prism_infer safety boundaries and
the host's final verification responsibility are unchanged.
Subscription-Tier Skills Arrive Before the First Host Launch
prism connect now downloads the authoritative Synalux skill manifest and
materializes entitled packages in the native ~/.agents/skills directory
before the command exits. Codex therefore sees the current skillset on its
first launch instead of requiring a second restart. Prism rechecks the same
snapshot at MCP startup, session load, and every five minutes—without host
lifecycle hooks.
On the first user turn, Prism's native skill, MCP metadata, and managed host
instructions request one session_bootstrap({}) call. Prism then uses the
dashboard's developer name, Auto-Load Projects, and quick, standard, or deep
setting. The response stays focused on greeting and session state because tier
skills are already present in the host's native skill directory.
Hook-free MCP can provide and prioritize that ready-to-display block, but the host model still owns the final assistant message and may summarize it. Prism does not claim a deterministic verbatim greeting on third-party chat surfaces; that would require a host lifecycle hook, launcher, extension, or Prism-owned panel. Context loading itself remains complete even when a host shortens the visible reply.
Free accounts receive only the public hook-free prism-startup package; the MCP
server still supplies a compact, non-proprietary safety and evidence contract.
Authenticated paid accounts receive the protected behavioral and engineering
packages plus the current subscribed routing set. The paid
evidence-first-protocol keeps ordinary coding lightweight: one correlated
reproduction is enough to begin an edit, while strict acceptance starts only
before a completion claim, push, or release and inspects only the exact artifacts
used as proof. Upgrades install newly entitled packages; verified downgrades
remove only Prism-owned packages while preserving local skills and locally
modified conflicts.
When upgrading an older Claude Code installation, prism connect removes only
the exact Prism-owned startup, skill-sync, handoff, and drift hook actions from
the legacy bootstrap. It also removes the recognized legacy Prism startup
sections from ~/CLAUDE.md, preserves every other instruction, and installs a
small ownership-marked native block that selects session_bootstrap({}) on the
first turn. User hooks, custom instruction sections, and near matches remain
untouched; native skills and server-side reminders preserve those Prism
features without host lifecycle hooks. Because hosts expose no native
session-end callback, handoff at shutdown is instruction-driven rather than a
guaranteed lifecycle event.
After Claude Code's native user registration succeeds, the same default or
--refresh command checks the nearest .mcp.json from the current directory
through the home directory. It removes only the exact legacy
prism-mcp entry { "command": "npx", "args": ["-y", "prism-mcp-server"] }
that would otherwise shadow the user registration. Custom Prism entries and
their additional fields, plus unrelated servers, are preserved; malformed
files fail loud without changes. --dry-run reports the recognized migration
without changing the file.
What's New in v20.2.1
Subscription-Aware Memory Storage
prism connect now carries an explicit PRISM_STORAGE=auto|local|synalux|supabase
into every managed host registration and rejects invalid values before changing a
config file. In auto, a portal-confirmed free tier uses local SQLite, while
Standard, Advanced, and Enterprise use Synalux cloud memory. If entitlement
resolution is unavailable, Prism fails closed instead of splitting history across
backends. Storage remains independent of local-first model routing.
What's New in v20.2.0
One Command Connects Every Supported Host
Install Prism globally and run prism connect. It detects Claude Code, Claude
Desktop on macOS, Windows, and Linux (beta), Cursor, Gemini CLI, and Codex, then safely registers the
server from the installed package. Existing custom entries are untouched;
--dry-run previews changes and --refresh updates only Prism-managed entries.
What's New in v20.1.0
Every Inference Outcome Is Now Observable
prism_infer gains a failure contract: pass escalation: "report" and every call returns a structured gate_outcome — success, degraded (gate-failed output served anyway, explicitly flagged), or refused (typed, with reason, instead of a thrown error). Degraded output can no longer serve silently.
Big Prompts Work Locally
Prompts over 4000 chars were blanket-refused when cloud was off. Now the full text gets a deterministic reserved-keyword scan plus a head+middle+tail excerpt classification — clean oversize prompts serve locally with a distinct UNCERTAIN_LENGTH audit marker. Clinical/reserved handling is unchanged (and its keyword floor got stronger).
No More Silent Truncation
Tier context limits now match the live Modelfiles (27b/9b are 4096-token models; 4b/2b are 32768 — the old table had it backwards). Tiers that can't hold your prompt are skipped with a visible ctx_insufficient reason; if nothing fits, you get the full prompt on cloud or a loud error — never an answer computed from a silently-clipped prompt.
Know Which Plan You're Actually Running Under
Entitlements carry a source field: portal (real), unconfigured (free by design), or fallback_free (portal unreachable — free limits ASSUMED). Pass strict_entitlements: true to fail loud instead of running degraded.
What's New in v20.0.8
verify_behavior Works Again
The verify_behavior tool crashed on every call (-32602 expected object, received string) — the handler returned a bare string instead of an MCP CallToolResult object. Fixed, with contract + fail-closed regression tests so the safety gate can never silently break again. If you're on 20.0.6/20.0.7, update.
From v20.0.7: Reserved-Content Safety, Skills Auth, Delegation Metrics
Reserved clinical content is now Claude-or-refuse (never served by a smaller model than the one that refused it), skill delivery gained a JWT auth fallback (paid-tier skills now reach machines using only PRISM_SYNALUX_API_KEY), and every prism_infer call is recorded in a persistent infer_metrics ledger. Full details in CHANGELOG.md.
What's New in v20.0.5
Local-First Delegation — 15 Categories, Measured Rate
The local-inference-first skill covers 15 hard-trigger categories (code gen, regex, format conversion, summarization, documentation, factual lookup, classification, shell commands, config gen, and more). Pasted code blocks now trigger delegation regardless of question phrasing. Measured delegation rate: 30-35% on engineering sessions, 40-60% on transform/content sessions. Rate depends on prompt mix, not the skill — the instruments now self-validate with nonDelegatedCount to prevent curated-set tautologies.
Think-Only Retry (v20.0.4)
Qwen 3.5 models (9B/27B) with thinking enabled could burn all tokens on <think> blocks and return empty content, causing a cascade to 4B. Now detects think-only responses and retries the same tier with thinking disabled — preserving model quality instead of falling to a smaller model.
What's New in v20.0.3
Layer 1 Cold-Model Resilience
The reserved-category classifier now retries once with a longer timeout on cold-model failure, then falls back to a deterministic keyword backstop before refusing. Over-length prompts (>4K chars) are classified as UNCERTAIN before reaching the classifier — prompt padding can no longer force the ERROR branch. This eliminates the cold-start refusal problem without weakening the safety gate.
Keyword Backstop for Reserved Content
When the LLM classifier fails (timeout, injection, resource pressure), a deterministic regex floor catches reserved vocabulary (restraint, seclusion, self-harm, suicide, overdose, crisis de-escalation, etc.) including inflected and verb forms. Blocks prompt-padding and classifier-injection attacks on the ERROR path.
Single-Source Safety Text
The safety statement in the MCP server instructions field now imports from boundaries.ts — one source of truth instead of two hand-maintained copies. Boundaries version bumped to v3 with an explicit delivery decision documented in code.
Reserved-Category Safety Gate — All Tiers (v20.0.2)
The Layer 1 semantic classifier now runs for every user, not just paid tiers. Reserved clinical content is refused on free tier when cloud is unavailable — fail-closed.
Ledger Dedup (v20.0.2)
session_save_ledger deduplicates identical entries within a 5-minute window.
Evidence Script (v20.0.2)
scripts/generate-evidence.sh regenerates all 5 evidence files with built-in assertions. Run bash scripts/generate-evidence.sh to verify the full pipeline.
What's New in v20.0.0
License: AGPL-3.0 → Apache-2.0
Prism MCP is now Apache-2.0. The thin-client architecture means all proprietary value (skill resolution, tier gating, billing, cloud inference) lives server-side — the open client carries no moat to protect. Apache-2.0 removes the enterprise adoption friction that AGPL caused.
Thin Client Architecture
Skill routing, budget management, and content resolution have moved server-side to the Synalux portal. The MCP client is now a thin API caller — simpler, smaller, and portable across any host (Claude Code, Gemini, Cursor, autonomous scripts). Offline fallback reads the last successful response from local SQLite.
Clean-Room Voyage AI Adapter
The Voyage AI embedding adapter was independently reimplemented from the Voyage API docs to ensure 100% project-owned copyright. Default model updated to voyage-3.5. See PROVENANCE.md for details.
Server-Side Drift Detection
Session drift detection (GATE 5) no longer requires Claude Code hooks. The timer runs server-side per conversation, piggybacked on every MCP tool response. Works for any host.
CLA Requirement
External contributions now require signing the Individual CLA. The CLA check is merge-blocking on the main branch.
Quickstart
The free tier needs no account, no API key, and no cloud. Install Prism, then register it with every supported MCP host already installed on your machine:
npm install --global prism-mcp-server
prism connect
prism connect detects Claude Code, Claude Desktop (macOS/Windows/Linux), Cursor,
Gemini CLI, and Codex.
Use prism connect --all to target all five, --host <name> for one host, or
--dry-run to preview the files that would change. Existing prism and
prism-mcp entries are never overwritten by default. --refresh updates only
an entry previously created by Prism; custom entries remain untouched.
For Claude Code, both the default command and --refresh also remove the exact
legacy project-scoped npx -y prism-mcp-server entry from the effective
ancestor .mcp.json after the native user registration succeeds. No custom or
near-match project entry is changed.
Close the target MCP hosts before a non-dry-run registration so they cannot
edit their configuration at the same time.
The same connection installs the local-first orchestration contract:
| Host | Managed containment |
|---|---|
| Codex | features.multi_agent=false; a 2-thread, depth-1 Terra/low fallback profile is retained for explicit re-enable |
| Gemini CLI | experimental.enableAgents=false |
| Claude Code | CLAUDE_CODE_SUBAGENT_MODEL=sonnet; managed instructions reserve it for last-resort fallback |
| Cursor | Canonical policy delivered through MCP initialize instructions |
| Claude Desktop | Canonical policy delivered through MCP initialize instructions |
All five receive PRISM_AGENT_POLICY=local-first in their managed Prism MCP
entry. Routine tasks use the RAM-aware local worker; native/background fan-out
is not the default workflow. session_task_route supplies a complexity hint;
prism_infer remains the single owner of model and thinking selection and can
choose 27B when its viability gates support it.
Set PRISM_STORAGE before running prism connect to preserve an explicit
storage choice in the generated host entries. This does not change local-model
routing; Synalux cloud storage separately requires an active cloud-memory
entitlement.
Codex registration preserves unrelated ~/.codex/config.toml content, appends
only the marked Prism MCP block, and updates only the documented local-first
feature/agent keys. CODEX_HOME is respected when set and must already exist,
matching Codex's own contract. Restart Codex CLI, the
IDE extension, or the ChatGPT desktop app after connecting.
Restart the connected host and your agent now has memory backed by a local
SQLite database (~/.prism-mcp/data.db). See IDE setup
for manual configuration and host-specific paths.
Optional — local model fleet for offline tool-routing. Pull whichever fits your hardware:
ollama pull dcostenco/prism-coder:2b # 2.3 GB · mobile / lightweight (99.1% routing accuracy)
ollama pull dcostenco/prism-coder:4b # 3.4 GB · verifier (100% accuracy)
ollama pull dcostenco/prism-coder:9b # 5.8 GB · default router (100% accuracy, Qwen3.5)
ollama pull dcostenco/prism-coder:27b # 16 GB · complex tasks (100% accuracy)
Prism detects both the namespaced (dcostenco/prism-coder:9b) and bare (prism-coder:9b) Ollama tags automatically.
What it does
Your AI agent forgets everything between sessions. Prism fixes that — and adds verification, drift detection, and multi-agent coordination on top.
Mind Palace — persistent memory that survives across sessions
Every conversation feeds a persistent store. The next session loads the right context automatically — no re-explaining.
The dashboard shows your current project state, pending TODOs, intent health, and a neural knowledge graph — all built automatically from your agent sessions.
Knowledge Graph — semantic + keyword + graph search
Ask "what did I decide about the auth flow last month?" and get an answer with citations, combining vector similarity, full-text search, and graph traversal.
Session History — immutable audit trail
Every session is logged with files changed, decisions made, and TODOs. Search, filter, and replay any past session.
Inference Metrics — see where your tokens go
Every prism_infer call tracks which model handled it (local Ollama vs cloud) and how many tokens were consumed. When you save a session, Prism shows a summary:
📊 Inference Metrics (this session):
Total calls: 12 — Local: 10 (83%) | Cloud: 2 (17%)
Prompt tokens: 7,840 evaluated / 8,420 submitted est.
Completion tokens: 3,150
Cloud tokens saved (est.): 11,570 — token volume handled locally instead of cloud
Avg latency: 1,240ms
By model:
prism-coder:27b: 6 calls, 7,200 tokens, avg 1,800ms
prism-coder:9b: 4 calls, 2,870 tokens, avg 620ms
synalux-27b: 2 calls, 1,500 tokens, avg 1,100ms
Cloud tokens saved is the honest routing metric — it accrues only when local Ollama handles a call that would otherwise have gone to Synalux cloud inference. A compact version appears inline after every 5th prism_infer call: 📊 local 10 (83%) · cloud 2 (17%) · ~11,570 tok · avg 1,240ms · 11,570 cloud tok saved.
Local calls use actual Ollama token counts (prompt_eval_count / eval_count from Ollama); cloud calls use char/4 estimates. Metrics are tracked locally — no portal dependency, no env vars, works offline. Per-call data is also forwarded to the Synalux portal as best-effort analytics (independent of the display).
Session Drift Detection
Long agent sessions can wander from their original goal. session_detect_drift compares current work against the stated goal and returns on_track / minor_drift / major_drift so the agent can self-correct.
Behavioral Verification — catch bad edits before they happen
AI agents apply patterns from checklists without understanding the real-world impact. The verify_behavior tool challenges the agent with a scenario it must answer before editing — forcing it to think through what the end user will experience.
Agent: "I'll revert this kitchen display change"
Prism: "⚠️ Scenario: A cook sees a 3-item ticket. One item is voided.
What should the cook see after the void?"
Agent: "The ticket stays visible with the remaining 2 items."
Prism: "Correct — your revert would hide the ticket entirely."
17 built-in domains (billing, auth, ordering, clinical, HR, and more). Custom domains per workspace on Enterprise. No hooks needed — works in any MCP client.
Time Travel
Roll back to any previous session state. Compare diffs between versions. Restore a known-good state with one click.
Cognitive Routing
Three memory types, automatically sorted: episodic (what happened — session logs, decisions), semantic (what's true — facts, architecture), and procedural (how to do X — workflows, patterns). When you search, the router picks the right store instead of dumping everything.
Multi-Agent Hivemind
Coordinate multiple AI agents working on the same project. Each agent has its own session, but they share memory through the knowledge graph. The Hivemind Radar shows real-time agent status, tasks, and activity.
Neural Search
Search across all memories with highlighted results, knowledge graph editing, and memory density metrics.
Local-first and privacy
The free tier runs entirely on your machine. Paid tiers add cloud sync through the Synalux portal, which is what enables cross-device memory and team sharing.
| Local tier (free) | Cloud tier (paid) | |
|---|---|---|
| Memory storage | Local SQLite | Synalux portal (Supabase-backed) |
| Inference | Local Ollama models | Local models + Gemini 3.6 Flash fallback |
| API keys required | None | Synalux subscription key |
| Web search / scrape | Not included | Via Synalux portal (provider keys server-side) |
| What leaves your machine | Nothing | Memory text, file paths, search queries, and inference prompts/drafts when their cloud feature is used, sent to the portal over TLS. Cloud memory writes are PHI-redacted; inference and route requests are transient. |
| Works offline | ✅ | Local features yes; sync/cloud no |
Handling sensitive data. Cloud memory writes pass through automatic
redaction (SSNs, dates of birth, medical record numbers, phone numbers, emails,
and clinical identifiers are stripped before storage). Cloud inference and
route correction send the request over TLS for processing and do not store it
as Prism memory; use route_guard: "local" or the local tier for a full
air-gap. Enterprise includes a HIPAA Business Associate Agreement.
Models
The prism-coder fleet uses Qwen3.5 for MCP tool-routing AND general inference. The 9B and 27B are fine-tuned with LoRA (r=128, all 64 layers including DeltaNet); the 2B and 4B use stock Qwen3.5-4B at different quantization levels. The 27B scored 100% on BFCL function-calling and 100% on an internal 15-problem coding eval at $0 inference cost.
prism_infer supports three modes: route (tool routing, fast, nothink), chat (conversation with thinking), and code (code generation with thinking). In chat/code modes, the model uses <think> blocks for chain-of-thought reasoning, which are stripped before the response is served. If the local model fails a quality gate (empty, think-only, or truncated), paid tiers automatically escalate to Gemini 3.6 Flash via the Synalux portal.
Every route-mode result is parsed locally and checked against allowed_tools
before it reaches the host. Malformed or unadvertised calls become NO_TOOL.
With route_guard: "auto" (the default), Standard and higher plans also send
a well-formed draft for one of Prism's seven trained tools—or an unadvertised
draft that may need correction—to Synalux for authenticated deterministic
correction. Advertised custom host tools remain local. Set
route_guard: "local" for a fully on-device route path.
| Model | Ollama tag | Size | BFCL Accuracy | Role | Automatic routing tier |
|---|---|---|---|---|---|
| Qwen3.5-4B Q3_K_M | prism-coder:2b |
2.3 GB | 99.1% × 3 seeds | iPhone / mobile first gate | Free |
| Qwen3.5-4B Q4_K_M | prism-coder:4b |
3.4 GB | 100% × 3 seeds | Verifier | Free |
| Qwen3.5-9B (LoRA) | prism-coder:9b |
5.8 GB | 100% × 3 seeds | Default router | Standard+ |
| Qwen3.5-27B (LoRA) | prism-coder:27b |
16 GB | 100% × 3 seeds | Quality tier (DeltaNet, 28.5 tok/s) | Advanced+ |
These tiers control automatic prism_infer selection, not Ollama itself. Any
user can run any downloaded on-device model directly through Ollama on every
plan.
Weights: huggingface.co/dcostenco (public GGUF). Latency depends on model size and hardware — see Benchmarks to measure it on your own machine rather than trusting a printed number.
Cascade
query → prism-coder:9b (local router, default)
→ prism-coder:4b (grounding verifier)
→ prism-coder:2b (iPhone / mobile, auto-selected by RAM)
→ prism-coder:27b (complex tasks, on demand)
→ Gemini 3.6 Flash cloud fallback (paid tiers, for max quality)
Multi-Layer Verification
Route output and evidence-grounded answers use separate gates. Every tier gets the local route parser and advertised-tool registry; Standard and higher plans can add the private deterministic route correction. Evidence verification is opt-in (or automatic when evidence is supplied) and remains separate from route selection.
| Layer | What | Model | Cost |
|---|---|---|---|
| L1 | Crisis/medical safety gate | None (regex) | 0 ms |
| L3-Registry | Envelope validation + advertised-tool enforcement (all tiers) | None | 0 ms |
| L3-Route | Authenticated deterministic route correction (Standard+) | None | Network latency |
| L3-Tier0 | Integer grounding (set membership) | None (deterministic) | 0 ms |
| L3-Tier2 | NLI verifier (claim → ENTAILED/NEUTRAL/CONTRADICTED) | prism-coder:2b | ~200 ms |
| L4 | Hallucination judge (opt-out for clinical) | prism-coder:4b | ~500 ms |
Fail-closed on the verified path: when the grounding verifier runs, timeout, ambiguity, or missing evidence yields a refusal, not pass-through. If the paid route correction is unavailable, the local registry still blocks malformed and unadvertised calls and reports an allowed preserved route as degraded.
Benchmarks
Published benchmark numbers are concise summaries of internal deterministic evaluation. Evaluators, exhaustive cases, exact tier-routing matrices, and raw model outputs stay in the private engineering repository and are not included in the npm package or public source tree.
Routing evaluation. On a narrow tool-selection suite, the fleet achieved near-saturated results across three seeds. This measures offline MCP routing reliability, not general model capability.
| Model | Routing accuracy | Notes |
|---|---|---|
| prism-coder:2b (Q3_K_M) | 99.1% × 3 seeds | 1 failure: regex→knowledge_search |
| prism-coder:4b / 9b / 27b | 100% × 3 seeds | Perfect on all 115 cases |
| Claude (frontier, same eval) | ~98% | Stronger everywhere outside this narrow task |
Memory uplift (LoCoMo-Plus, self-published). A separate long-context dialogue benchmark (dcostenco/Locomo-Plus) measures how much structured memory helps a base model retain multi-day context. Results show large gains when a model is paired with Prism memory versus running raw. Note this benchmark is authored, run, and LLM-judged by this project — treat it as a reproducible demonstration, not an independent third-party result, and run it yourself with the commands in that repo.
Code generation evaluation. In a small July 2026 deterministic execution check, the local 9B passed 2/3 tasks; the local 27B and Gemini 3.6 Flash each passed 3/3. This is a self-published regression signal, not an independent leaderboard or a claim of broad model equivalence.
Cloud Escalation (cloud_fallback: true)
Prism always tries an eligible local model first. If the quality gate detects an empty, truncated, think-only, or looping response, paid tiers can retry the request through Gemini 3.6 Flash. Free-tier routing stays local and reports the quality-gate outcome without making a cloud call.
Why Prism Coder
vs AI coding assistants
Product capabilities and plans change frequently. The comparison below is intentionally limited to publicly documented differences; it is not a claim that another product lacks an unlisted feature.
Legend: ✅ documented, ◐ conditional or plan-dependent, — not compared, ? verify with the provider.
| Capability | Prism Coder | GitHub Copilot | Cursor | Amazon Q Developer |
|---|---|---|---|---|
| Local/open-weight inference | ✅ | ◐ | ◐ | ◐ |
| Offline workflow | ✅ | ◐ | ? | ? |
| Cross-session memory | ✅ | ◐ (docs) | ◐ | ◐ |
| MCP integration | ✅ | ✅ (docs) | ✅ (pricing) | ◐ |
| Local-first model routing | ✅ | ◐ | ◐ | ◐ |
| Session drift and grounding checks | ✅ | — | — | — |
| Setup surface | ✅ five hosts | ✅ CLI/IDE | ✅ editor/agents | ✅ IDE/CLI (overview) |
| Pricing model | ✅ Synalux tiers | ◐ | ◐ (pricing) | ✅ free + $19 Pro (pricing) |
Prism-specific compliance, contractual, and pricing terms are documented in the Synalux service agreement. Do not infer a competitor's HIPAA, BAA, or data handling status from this table.
vs local AI / memory tools
| Feature | Prism Coder | Ollama | LM Studio | Mem0 | Zep |
|---|---|---|---|---|---|
| Local inference cascade | ✅ | ✅ runtime | ✅ app | — | — |
| Cloud fallback | ✅ optional | — | ◐ provider-dependent | ◐ | ◐ |
| Persistent memory | ✅ | — | ◐ project context | ✅ | ✅ |
| Knowledge/tool integration | ✅ MCP + ingestion | ◐ APIs | ◐ integrations | ✅ SDK/API | ✅ SDK/API |
| MCP server | ✅ native | — | ◐ client integration | ◐ client integration | ◐ client integration |
Pricing
Prism's current published tiers are listed below. Competitor pricing is usage- and plan-dependent, so consult the provider directly: GitHub Copilot, Cursor, and Amazon Q Developer.
Plans
All on-device models are free to run locally via Ollama on every tier. A subscription gates cloud features, higher automatic-routing ceilings, and increased limits. On-device models run through your Ollama regardless of plan; the ceiling applies only to cloud inference and automatic prism_infer routing.
| Free | Standard $19/mo | Advanced $49/mo | Enterprise $99/mo | |
|---|---|---|---|---|
| Seats | 1 | 1 | up to 5 | up to 25 |
Automatic prism_infer ceiling |
up to 4b | up to 9b | up to 27b | up to 27b |
| Cloud inference | -- | ✅ | ✅ | ✅ (priority) |
| Cloud Coder (Web IDE) | -- | ✅ | ✅ | ✅ (priority) |
| Cloud search | -- | ✅ | ✅ | ✅ |
| Max output tokens | 512 | 1,024 | 2,048 | 4,096 |
| Cloud fallback | -- | Gemini 3.6 Flash | Gemini 3.6 Flash | Gemini 3.6 Flash (priority) |
| Grounding verifier (fact-check AI output) | -- | ✅ | ✅ | ✅ |
| Memory sync (cloud) | -- | ✅ | ✅ | ✅ |
| Knowledge / session memory | limited | unlimited | unlimited | unlimited |
| Analytics dashboard | -- | ✅ | ✅ | ✅ |
| HIPAA BAA | -- | -- | -- | ✅ |
14-day free trial on paid plans. 25+ seats: contact sales
How agents use it
Prism exposes 40+ MCP tools. The core memory loop:
| Tool | What it does |
|---|---|
session_bootstrap |
Hook-free first-turn greeting and dashboard-configured context |
session_load_context |
Explicit project reload or older-server startup fallback |
session_save_ledger |
Append an immutable session log entry |
session_save_handoff |
Save live state for the next session |
knowledge_search |
Semantic + keyword search over all memories |
query_memory_natural |
Memory-first Q&A with a grounded live-source fallback on paid tiers |
session_detect_drift |
Detect when a session has drifted from its goal |
verify_behavior |
Pre-edit scenario challenge — catch bad changes before they happen |
knowledge_ingest |
Teach Prism a codebase or document |
prism_infer |
Local-first inference (route/chat/code modes, thinking, cloud escalation) |
inference_metrics |
Session delegation or persisted MCP + VS Code panel local/cloud stats |
query_memory_natural — memory first, current sources when needed
Ask one natural-language question instead of choosing separate memory, search, scrape, and inference tools. Prism searches its accumulated project memory first. If no useful evidence exists, paid tiers run one bounded Synalux search (Firecrawl, Gemini 3.6 Google Search grounding, then legacy Brave fallback), resolve and preserve the source URLs, scrape the leading page, and ask a RAM-safe local Prism Coder model to answer from that evidence. The paid-tier Gemini 3.6 verifier checks the draft before it is served. Reserved or uncertain clinical content never enters the web-grounded local path; it follows Prism's cloud-or-refuse safety boundary.
prism_infer — local-first inference with cloud escalation
prism_infer({
prompt: "Write a binary search in Python",
mode: "code", // "route" | "chat" | "code"
think: true, // enable <think> reasoning (default: true for chat/code)
model_ceiling: "27b", // use the quality tier
})
// → 27B generates code locally ($0), with thinking for quality
// → If quality gate fails + paid tier → auto-escalate to Gemini 3.6 Flash
| Mode | Think | Model | Use case |
|---|---|---|---|
route |
Off (fast) | 9B default | MCP tool routing |
chat |
On | 27B preferred | Conversation, reasoning |
code |
On | 27B preferred | Code generation, debugging |
Full TypeScript signatures live in src/tools/; architecture in docs/ARCHITECTURE.md.
inference_metrics — see your local-model usage on demand
Call inference_metrics anytime mid-session to see how many prism_infer calls ran locally vs cloud. Use period: "all" to atomically import the Synalux VS Code panel spool and include its local-serve rate in the persisted totals:
📊 Inference Metrics — local-model delegation (this session):
Total calls: 5 — Local: 5 (100%) | Cloud: 0 (0%)
Tokens: 1,240 in + 380 out = 1,620 total
Avg latency: 420ms
By model:
prism-coder:27b: 3 calls, 1,100 tokens, avg 520ms
prism-coder:9b: 2 calls, 520 tokens, avg 270ms
The same block also appears automatically in session_save_ledger and session_save_handoff responses at session end.
Note: The default session view tracks this MCP process's prism_infer delegation. The all-time view combines persisted MCP calls with Synalux VS Code panel inference. Neither view includes the host agent's own token spend; use that host's native usage reporting when available.
Local-model delegation (default)
Prism routes qualifying bounded work—bulk classification, field extraction,
mechanical formatting, test generation, and similar tasks—to local Ollama
models before any host-native subagent. The agent checks gate_outcome,
verifies the result, and continues in the current host thread when the local
worker is unavailable, refused, or degraded.
Pass project memory when the subtask depends on prior work:
{
"prompt": "Generate the bounded regression-test cases.",
"project": "prism-mcp",
No comments yet
Be the first to share your take.