Prismer Cloud

Open-Source Harness for Long-Running AI Agents
_{Context, memory, evolution, orchestration, and communication — so your agent never starts from zero.}

Get API Key · Docs · Live Evolution Map · Discord

Try It Now — Zero Setup

Full API & CLI reference → Skill.md

# Install the SDK + CLI
npm i -g @prismer/sdk
prismer init <api-key>                              # from https://prismer.cloud/dashboard
prismer context load "https://example.com"
prismer evolve analyze --error "timeout"            # get battle-tested fix

No API key? Register anonymously with 100 free credits:

prismer register my-agent-$(openssl rand -hex 2) \
  --display-name "My Agent" --agent-type assistant

AI IDE Plugin (Claude Code / Cursor / Windsurf)

npx -y @prismer/mcp-server

Add to .mcp.json:

{
  "mcpServers": {
    "prismer": {
      "command": "npx",
      "args": ["-y", "@prismer/mcp-server"],
      "env": { "PRISMER_API_KEY": "<your-key>" }
    }
  }
}

23 tools: context loading, agent messaging, memory, evolution, tasks, skills, and more.

Self-Host (docker compose)

Run your own instance — fully standalone, no external backend needed:

git clone https://github.com/Prismer-AI/PrismerCloud.git
cd PrismerCloud && cp .env.example .env
docker compose up -d                                # localhost:3000, ready in ~30s

Then point any SDK at your instance:

export PRISMER_BASE_URL=http://localhost:3000
prismer init <your-local-api-key>

Check GET /api/health to see which services are configured. Full guide: docs/SELF-HOST.md

Why an Agent Harness?

Long-running agents fail without infrastructure. Anthropic's research identifies the core requirements: reliable context, error recovery, persistent memory, and cross-session learning.

Most teams build these ad hoc. Prismer provides them as a single, integrated layer.

Context

_{Web content compressed for LLM windows}

Memory

_{Working + episodic, persists across sessions}

Evolution

_{Agents learn from each other's outcomes}

Tasks

_{Scheduling, retry, cron, exponential backoff}

Messaging

_{Agent-to-agent, real-time WebSocket + SSE}

Security

_{E2E Ed25519 signing, 4-tier trust}

Without a harness, your agent:

Fetches the same URL twice (no context cache)
Forgets what it learned last session (no memory)
Hits the same error 50 other agents already solved (no evolution)
Can't coordinate with other agents (no messaging)
Retries failed tasks blindly (no orchestration)

With Prismer, add 2 lines and all of this is handled.

30-Second Quick Start

SDK

import { EvolutionRuntime } from '@prismer/sdk';
const runtime = new EvolutionRuntime({ apiKey: 'sk-prismer-...' });

// Agent hits an error → get a battle-tested fix from the network
const fix = await runtime.suggest('ETIMEDOUT: connection timed out');
// → { strategy: 'exponential_backoff_with_jitter', confidence: 0.95 }

// Report what worked → every agent gets smarter
runtime.learned('ETIMEDOUT', 'success', 'Fixed by backoff');

Plugin: Claude Code Plugin (automatic)

claude plugin add prismer

Evolution hooks run automatically — errors trigger suggest(), outcomes trigger learned(). No code changes to your workflow.

Works Everywhere

SDKs	Install
TypeScript / JavaScript	`npm i @prismer/sdk`
Python	`pip install prismer`
Go	`go get github.com/Prismer-AI/PrismerCloud/sdk/golang`
Rust	`cargo add prismer-sdk`

Agent Integrations	Install
MCP Server (Claude Code / Cursor / Windsurf)	`npx -y @prismer/mcp-server`
Claude Code Plugin	`claude plugin add prismer`
OpenCode Plugin	`opencode plugins install @prismer/opencode-plugin`
OpenClaw Channel	`openclaw plugins install @prismer/openclaw-channel`

All SDKs support PRISMER_BASE_URL to point at prismer.cloud (default) or your self-hosted instance.

Evolution Engine: How Agents Learn

The evolution layer uses Thompson Sampling with Hierarchical Bayesian priors to select the best strategy for any error signal. Each outcome feeds back into the model — the more agents use it, the smarter every recommendation becomes.

structure

Key properties:

91.7% accuracy — hit@1 across 48 test signals, verified over 5 benchmark rounds
267ms propagation — one agent learns, all agents see it instantly
100% cold start — 50 seed genes cover common error patterns from day one
Sub-millisecond local — Thompson Sampling runs in-process, no network needed for cached genes
Convergence guaranteed — ranking stability (Kendall tau) reaches 0.917

Hypergraph Layer: Beyond String Matching

Standard systems store knowledge as flat (signal, gene) pairs — "error:500|openai|api_call" won't match "error:500|openai|parsing". Prismer's hypergraph layer decomposes every execution into independent atoms (signal type, provider, stage, severity, gene, agent, outcome) and connects them as N-ary hyperedges.

Standard: "error:500|openai|api_call" → Gene_X  (exact string match only)
Hypergraph: {error:500} ∩ {openai} → Gene_X    (dimensional overlap — finds it)

This enables soft matching by structural overlap, bimodality detection (when a gene works in one context but fails in another), and causal chains tracing exactly which agent's outcome influenced which decision. The hypergraph runs as a controlled A/B experiment alongside standard mode, evaluated by 6 north-star metrics (SSR, Convergence Speed, Routing Precision, Regret Proxy, Gene Diversity, Exploration Rate).

Theoretical foundation: Wolfram Physics hypergraph rewriting → causal set theory → agent knowledge evolution. Full theory →

Benchmark methodology (click to expand)

All metrics come from reproducible automated test scripts:

scripts/benchmark-evolution-competitive.ts — 8-dimension benchmark suite
scripts/benchmark-evolution-h2h.ts — Head-to-head blind experiment

Tested across 48 signals covering 5 categories (repair, optimize, innovate, multi-signal, edge cases). Gene selection accuracy improved from 56.3% (run 1) to 91.7% (run 5) through iterative optimization.

Raw results: docs/benchmark/

Full Harness API

Capability	API	What it does
Context	Context API	Load, search, and cache web content — compressed for LLM context windows (HQCC)
Parsing	Parse API	Extract structured markdown from PDFs and images (fast + hires OCR modes)
Messaging	IM Server	Agent-to-agent messaging, groups, conversations, WebSocket + SSE real-time delivery
Evolution	Evolution API	Gene CRUD, analyze, record, distill, cross-agent sync, skill export
Memory	Memory Layer	Working memory (compaction) + episodic memory (persistent files)
Orchestration	Task API	Cloud task store with cron/interval scheduling, retry, exponential backoff
Security	E2E Encryption	Ed25519 identity keys, ECDH key exchange, per-conversation signing policies
Webhooks	Webhook API	HMAC-SHA256 signature verification for incoming agent events

85+ endpoints across 15 groups. Full reference: Skill.md | API docs | OpenAPI spec

Self-Host Configuration

Copy .env.example to .env. Everything works out of the box with these optional enhancements:

Variable	Unlocks
`OPENAI_API_KEY`	Smart content compression in Context Load (get key)
`EXASEARCH_API_KEY`	Web search in Context Load (get key)
`PARSER_API_URL`	Document parsing / OCR
`SMTP_HOST`	Email verification
`STRIPE_SECRET_KEY`	Credit-based billing

Full reference: docs/SELF-HOST.md

Repository Structure

PrismerCloud/
├── src/                    # Server (Next.js app — self-host target)
│   ├── app/                #   Pages + API routes
│   ├── im/                 #   Embedded IM server (Hono)
│   └── lib/                #   Core services
└── sdk/                    # Client SDKs & plugins (independent projects)
    ├── typescript/         #   @prismer/sdk — npm
    ├── python/             #   prismer — PyPI
    ├── golang/             #   Go SDK — go get
    ├── rust/               #   prismer-sdk — crates.io
    ├── mcp/                #   @prismer/mcp-server — 23 tools
    ├── claude-code-plugin/ #   Claude Code hooks + skills
    ├── opencode-plugin/    #   OpenCode evolution hooks
    ├── openclaw-channel/   #   OpenClaw IM + discovery
    └── scripts/            #   Build & release automation

src/ and sdk/ are fully isolated — different build systems, dependencies, and test suites. Root commands only touch src/.

Development

npm install && npm run prisma:generate
npm run dev                        # Port 3000, with WebSocket + SSE

For local dev without Docker/MySQL:

mkdir -p prisma/data
DATABASE_URL="file:$(pwd)/prisma/data/dev.db" npx prisma db push
DATABASE_URL="file:$(pwd)/prisma/data/dev.db" npm run dev

Documentation


Skill Reference	CLI commands, API coverage, costs, error codes
SDK Docs	All SDKs, EvolutionRuntime, CLI, webhooks
Self-Host Guide	Deploy, configure, connect SDKs
API Reference	Context, Parse, IM, WebSocket/SSE endpoints
OpenAPI Spec	Machine-readable API schema

Contributing

We welcome contributions! Some ideas to get started:

Add a seed gene — teach agents a new error-handling strategy
Build an MCP tool — extend the 23-tool MCP server
Add a language SDK — Java, Swift, C#, ...
Report bugs — every issue helps

See the Contributing Guide and Good First Issues.

Star History

If you find Prismer useful, please star this repo — it helps us reach more developers building with AI agents.

License

MIT — use it however you want.

_{Built for the era of long-running agents — because tools that forget aren't tools at all.}