The PRISM developer reference

PRISM is a pipeline simulator for AI systems. You design a graph of models, retrievers, rerankers, and tools, and PRISM projects the cost, latency, and accuracy you'd see in production — without having to stand the whole thing up.

Everything runs on top of three engines: a token-level cost engine that joins against daily-scraped provider pricing, a queue-theory latency engine that respects node concurrency and cache hit rates, and an accuracy engine that estimates end-to-end quality from published model + reranker benchmarks.

Use it to pick the right model before you integrate it, to pre-budget a feature launch, or to compare two pipelines under identical traffic and pick the cheaper / faster / more accurate one with receipts.

A working simulation in under five minutes. No install required.

1. Create an account

Head to /login and sign up with email. You land on the Free plan — 50 simulation runs per month, unlimited pipelines, community benchmarks.

2. Build a pipeline

Open the canvas, drag in Input, Embedding, Vector Store, Re-ranker, LLM Call, and Output, then wire them left-to-right. Click a node to configure its provider/model/token expectations on the right panel.

3. Run a simulation

Open the simulator panel (bottom-right), set your expected traffic, and hit Run. Results stream in live over WebSocket — progress % on top, stage transitions underneath, and the final cost/latency/accuracy envelope at the end.

POST /v1/simulations
Authorization: Bearer <your-token>
Content-Type: application/json

{
  "pipeline_id": "pipe_01H7...",
  "traffic_params": {
    "requests_per_day": 25000,
    "avg_input_tokens": 1200,
    "avg_output_tokens": 400,
    "cache_hit_rate": 0.15,
    "retry_rate": 0.02
  }
}

You get back a 202 Accepted with the simulation id. Subscribe to live updates via WebSocket (see WebSocket events), or poll GET /v1/simulations/{id}.

4. Compare options

Duplicate the pipeline, swap one variable (say, gpt-4o-mini → claude-3-5-sonnet), then queue a comparison from the Comparisons page. PRISM runs both under identical traffic and picks a winner by your declared priority.

POST /v1/comparisons
Authorization: Bearer <your-token>
Content-Type: application/json

{
  "pipeline_ids": ["pipe_a", "pipe_b"],
  "priority": "balanced",
  "traffic_params": {
    "requests_per_day": 25000,
    "avg_input_tokens": 1200,
    "avg_output_tokens": 400,
    "cache_hit_rate": 0.15,
    "retry_rate": 0.02
  }
}

Pipelines

A pipeline is a directed acyclic graph of nodes with optional routing edges. It has a stable id, a version history, and autosaves as you edit. Pipelines are workspace-scoped — team members see the same set.

Nodes

Nine node types cover the usual shape of an AI system: I/O, core models (LLM, embedding), RAG primitives (vector store, reranker), and logic (cache, router, tool call). See the node reference for the exact config shape each one expects.

Simulations

A simulation evaluates a pipeline against traffic params. It runs three engines in parallel — cost, latency, accuracy — and returns a structured result envelope. Runs stream live over WebSocket; terminal runs are also reachable via polling.

Comparisons

A comparison fans out 2–5 simulations in parallel with identical traffic, then selects a winner using a priority — balanced, cost, latency, or accuracy. Pipelines that fail guardrails (e.g. p95 over threshold) are excluded from the recommendation even if they score highest.

Benchmarks

Benchmarks are the read-only feed of provider pricing, model accuracy, and reranker lift that the engines join against. Updated daily by the scraper for all major providers — OpenAI, Anthropic, Google, Cohere, Mistral, Voyage, and more.

A pipeline is serialized as JSON with two arrays — nodes and edges — plus metadata.

{
  "id": "pipe_01H7XYZ",
  "name": "Support RAG — v3",
  "nodes": [
    { "id": "n_in",   "type": "input",        "label": "User question" },
    { "id": "n_emb",  "type": "embedding",    "config": { "provider": "OpenAI", "model": "text-embedding-3-small" } },
    { "id": "n_vec",  "type": "vector_store", "config": { "provider": "pinecone", "index_name": "support", "top_k": 8 } },
    { "id": "n_rk",   "type": "reranker",     "config": { "provider": "Cohere", "model": "rerank-v3.5", "top_n": 3 } },
    { "id": "n_llm",  "type": "llm_call",     "config": { "provider": "Anthropic", "model": "claude-3-5-sonnet" } },
    { "id": "n_out",  "type": "output",       "config": { "mode": "Response", "format": "JSON" } }
  ],
  "edges": [
    { "source": "n_in",  "target": "n_emb" },
    { "source": "n_emb", "target": "n_vec" },
    { "source": "n_vec", "target": "n_rk"  },
    { "source": "n_rk",  "target": "n_llm" },
    { "source": "n_llm", "target": "n_out" }
  ]
}

The full set of node types. Defaults and the exact TypeScript types live in apps/web/lib/constants/node-presets.ts and apps/web/types/canvas.ts.

Traffic parameters

Every simulation is parameterized by the same five numbers. Two describe volume, two describe typical request size, one captures how cache-y your workload is.

Engines

Result envelope

Terminal simulations include a structured results object. The shape below is abbreviated; see apps/web/types/simulation.ts for the complete TypeScript types.

{
  "status": "complete",
  "cost": {
    "cost_per_query_p50": "0.0042",
    "cost_per_query_p95": "0.0071",
    "daily_cost_usd": "105.00",
    "monthly_cost_usd": "3150.00",
    "stage_breakdown": [ /* per-node cost contribution */ ]
  },
  "latency": {
    "latency_p50_ms": 820,
    "latency_p95_ms": 1740,
    "latency_p99_ms": 2390,
    "stage_breakdown": [ /* per-node latency contribution */ ]
  },
  "accuracy": {
    "applicable": true,
    "overall_score": 0.82,
    "metrics": {
      "retrieval_recall": 0.79,
      "rerank_ndcg": 0.86,
      "answer_relevance": 0.83
    }
  },
  "errors": []
}

Side-by-side simulations under identical traffic with a recommendation at the end.

Provide 2–5 pipeline ids and a priority. PRISM fans out simulations, tracks progress per pipeline, and selects a winner that (a) scores highest on your priority and (b) satisfies every active guardrail. If nothing is compliant, the response carries recommendation_status: "no_compliant_option" instead of quietly recommending a failing run.

// Response shape for GET /v1/comparisons/{id}
{
  "comparison_id": "cmp_01H7...",
  "priority": "balanced",
  "completed_count": 3,
  "total_count": 3,
  "items": [
    {
      "pipeline_id": "pipe_a",
      "pipeline_name": "RAG baseline",
      "simulation_id": "sim_...",
      "status": "complete",
      "score": 0.78,
      "rank": 1,
      "is_compliant": true,
      "metrics": { "cost_per_query_p50": 0.0038, "latency_p95_ms": 1420, "accuracy_overall_score": 0.81 },
      "threshold_violations": []
    }
    // ... more
  ],
  "recommendation": {
    "pipeline_id": "pipe_a",
    "pipeline_name": "RAG baseline",
    "simulation_id": "sim_...",
    "reason": "Lowest cost within latency + accuracy guardrails.",
    "priority": "balanced"
  }
}

The read-only feed the engines join against. Same data powers the public benchmarks page.

• Scraped daily from provider pricing pages: OpenAI, Anthropic, Google, Cohere, Mistral, Voyage, DeepSeek, Groq, Together, xAI, and more.
• Normalized to $/1K tokens regardless of whether a provider publishes $/1M or per-call pricing.
• Historical price deltas exposed via /v1/benchmarks/history/{provider}/{model}.
• Alerts — POST to /v1/benchmarks/alerts to subscribe when a specific model's price moves.

All REST endpoints require a Bearer token. Tokens are issued per-workspace from Settings → API keys. A token carries the role of the user who minted it — admin tokens can write, member tokens can read.

curl https://api.getprism.dev/v1/pipelines \
  -H "Authorization: Bearer $PRISM_API_KEY"

Base URL: https://api.getprism.dev. All endpoints speak JSON, return standard HTTP status codes, and include X-RateLimit-* headers.

Live progress for simulations and validation runs.

Connect to wss://api.getprism.dev/v1/ws/simulations/{id}. Auth is passed via the Sec-WebSocket-Protocol header — bearer.<token>. The server sends newline-delimited JSON frames:

// Frame: progress update
{ "type": "progress", "progress_pct": 42, "stage": "latency_engine" }

// Frame: stage transition
{ "type": "stage", "stage": "accuracy_engine", "started_at": "2026-04-21T10:30:02Z" }

// Frame: terminal (final)
{ "type": "complete", "status": "complete", "results": { /* envelope */ } }

// Frame: error (terminal)
{ "type": "error", "status": "failed", "error": { "message": "Upstream 429 on Anthropic.", "type": "provider_error" } }

Every response includes X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset (seconds until the window rolls). Limits are workspace-scoped.

• Free: 60 req/min, 50 simulation runs/month.
• Pro: 300 req/min, 1,000 simulation runs/month.
• Team: 600 req/min, 10,000 simulation runs/month, seat-based.
• Enterprise: negotiated. Contact sales.

Error responses are JSON with a stable shape.

{
  "error": {
    "type": "validation_error",
    "message": "traffic_params.cache_hit_rate must be between 0 and 1",
    "field": "traffic_params.cache_hit_rate"
  }
}

The REST API is the source of truth. First-party SDKs wrap it and add conveniences (retry, streaming, types).

GitHub Action

getprism/prism-action runs a simulation on every PR and comments the cost / latency / accuracy delta vs. main. Source lives in apps/action/ on this repo.

# .github/workflows/prism.yml
name: PRISM Simulation
on: [pull_request]
jobs:
  simulate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: getprism/prism-action@v1
        with:
          api-key: ${{ secrets.PRISM_API_KEY }}
          pipeline-id: ${{ vars.PRISM_PIPELINE_ID }}
          # optional: override traffic params for the PR run
          traffic: |
            requests_per_day: 25000
            avg_input_tokens: 1200
            avg_output_tokens: 400
            cache_hit_rate: 0.15
            retry_rate: 0.02