prismlang 0.1.0

Deterministic vector language protocol for multi-agent AI orchestration

PrismLang

Deterministic Vector Language Protocol for LangGraph Multi-Agent AI

Stop paying the token tax on every agent hop. Start routing with math.

📖 Docs · 🚀 Quickstart · 📊 Benchmarks · 🏢 Insight IT Solutions

pip install prismlang

---

The Problem

Every node in a LangGraph multi-agent pipeline reads the entire message history as prompt tokens. By turn 3 of a standard graph, every agent is paying for every prior agent's output — every single call.

Turn 1 →  800 B   1 agent  reading history
Turn 2 → 1,600 B  2 agents reading history
Turn 3 → 2,400 B  3 agents reading history    ← you're paying 3× for the same data

On top of that:

• No audit trail — you can't trace why an agent classified something the way it did
• No tenant isolation — in multi-tenant SaaS, one misconfigured agent can bleed context across org boundaries

---

The Solution

PrismLang replaces growing text payloads with 64-number deterministic vectors — one per agent turn. A single decorator on your existing nodes. No agent refactoring. No LLM retraining.

[Your Agent]  →  "Credit risk elevated in EM bonds."  (text, 400+ tokens)
                              ↓  @prism_node
              →  PrismEnvelope { vector[64], slug="risk", rule_chain }  (~414 bytes)

The math guarantees that the same input always produces the same vector, that different tenants produce incompatible vectors, and that every routing decision is traceable back to a taxonomy rule.

---

How It Works

PrismLang applies two equations on every agent output:

Step 1 — Spherical Blend (pulls the embedding toward its category direction)

v' = normalize( (1 − α) · v  +  α · ‖v‖ · eᵢ )

Step 2 — JL Reduction (compresses to k=64 dims, isolated per tenant)

p = normalize( P · v' )

Where P is a (64 × 384) Gaussian matrix seeded from SHA-256(tenant_id). A vector stolen from Tenant A is geometrically meaningless to any model operating under Tenant B's projection.

                    ┌─────────────────────────────────────────────┐
                    │           Your LangGraph Graph              │
                    │                                             │
  [researcher] ──→ [summarizer] ──→ [reviewer] ──→ [translator]  │
       │                │               │               │         │
  @prism_node      @prism_node     @prism_node     (boundary)     │
       │                │               │               │         │
  PrismEnvelope    PrismEnvelope   PrismEnvelope   Human text     │
  {64-d vector}    {64-d vector}   {64-d vector}                  │
  {rule_chain}     {rule_chain}    {rule_chain}                    │
                    │                                             │
                    │  prism_sequence  ─────────  append-only     │
                    └─────────────────────────────────────────────┘

---

Quick Start

from prismlang import (
    Category, TaxonomyConfig, PrismProjector,
    PrismState, prism_node, BoundaryTranslator,
    JsonFileCheckpointer,
)
from langgraph.graph import StateGraph, END

# 1. Define your domain taxonomy
taxonomy = TaxonomyConfig(categories=[
    Category("risk",       "Market Risk",   ["risk", "exposure", "volatility"]),
    Category("market",     "Market Data",   ["price", "equity", "bond"]),
    Category("compliance", "Compliance",    ["regulation", "audit", "kyc"]),
])

# 2. One projector per tenant — cryptographically isolated
projector = PrismProjector(taxonomy, tenant_id="acme-finance-prod", k=64)

# 3. Decorate your existing nodes — zero changes to agent logic
@prism_node(agent_id="analyst", projector=projector)
def analyst(state: PrismState) -> dict:
    return {"raw_output": "Credit risk exposure elevated in EM bonds."}

@prism_node(agent_id="reviewer", projector=projector)
def reviewer(state: PrismState) -> dict:
    prev = state["prism_sequence"][-1]["category_slug"]
    return {"raw_output": f"Reviewing {prev} findings for compliance sign-off."}

# 4. Build and run — exactly like any LangGraph graph
translator = BoundaryTranslator()
graph = StateGraph(PrismState)
graph.add_node("analyst",    analyst)
graph.add_node("reviewer",   reviewer)
graph.add_node("translator", translator.as_langgraph_node())
graph.set_entry_point("analyst")
graph.add_edge("analyst", "reviewer")
graph.add_edge("reviewer", "translator")
graph.add_edge("translator", END)

app = graph.compile(checkpointer=JsonFileCheckpointer())
result = app.invoke({
    "prism_sequence": [], "raw_output": "", "tenant_id": "acme-finance-prod"
})

# Inspect the audit envelope
envelope = result["prism_sequence"][0]
print(envelope["category_slug"])   # "risk"
print(len(envelope["vector"]))     # 64
print(envelope["rule_chain"])
# ['text -> encoder(all-MiniLM-L6-v2, d=384)',
#  "category_inference -> slug='risk'",
#  'spherical_blend(alpha=0.300) -> v_prime',
#  "JL_reduction(seed=sha256('acme-finance-prod'), k=64) -> p"]

---

Benchmark Results

Measured against standard LangGraph text-state across three enterprise domains.
Full methodology in docs/BENCHMARK.md. Results stored in PostgreSQL.

Domain	Metric	Standard LangGraph	PrismLang	Change
🏥 Healthcare ICU triage pipeline	Prompt tokens (3 turns)	391	148	−62.1%
	State size (turn 3)	1,928 B	960 B	−50.2%
💹 Finance Risk / portfolio pipeline	Prompt tokens (3 turns)	407	175	−57.0%
	State size (turn 3)	1,760 B	960 B	−45.5%
📈 Trade Market Signal / execution pipeline	Prompt tokens (3 turns)	435	180	−58.6%
	State size (turn 3)	1,867 B	960 B	−48.6%

LLM inference latency: unchanged. PrismLang reduces state transport, not compute.
Encoding overhead per turn: ~31–35 ms CPU-only (no GPU required).

---

Key Properties

Property	Detail
Zero agent refactoring	Agents return {"raw_output": "..."} — nothing else changes
Deterministic	Same text + same tenant = identical vector, always
Full audit trail	Every envelope carries a rule_chain tracing the full decision path
Tenant isolation	SHA-256(tenant_id) seeds the JL matrix — cross-tenant vectors are incompatible
No GPU	ONNX Runtime CPU inference — runs on any standard server
No external API	Encoder is fully local — no network call per token
Model-agnostic	Works with GPT-4, Claude, Gemini, Llama, or any LLM
Async native	@async_prism_node for async LangGraph nodes
Two checkpointers	JsonFileCheckpointer (zero deps) + PostgresCheckpointer

---

Installation Options

# Core (local JSON checkpointing)
pip install prismlang

# PostgreSQL checkpointing
pip install "prismlang[postgres]"

# Async support (asyncpg + aiofiles)
pip install "prismlang[async-postgres,async-files]"

# Full development environment
pip install "prismlang[dev]"

---

Run the Benchmarks

git clone https://github.com/insightitsGit/prismlang
cd prismlang
pip install -e ".[dev]"

# Runs all 3 domain benchmarks and prints comparison table
python -m benchmarks.run_all

Requires a running PostgreSQL instance. Set DATABASE_URL or use the default:
postgresql://insight_admin:...@localhost/prismLangDB

---

Project Structure

prismlang/
├── prismlang/
│   ├── encoder.py        # ONNX all-MiniLM-L6-v2 → 384-d unit vector
│   ├── taxonomy.py       # TaxonomyConfig + Category direction vectors (eᵢ)
│   ├── projector.py      # PrismProjector: spherical blend + JL reduction
│   ├── middleware.py     # @prism_node + @async_prism_node decorators
│   ├── checkpointer.py   # JsonFile + Postgres + Async variants
│   ├── exceptions.py     # Typed exception hierarchy (17 classes)
│   ├── envelope.py       # PrismEnvelope TypedDict
│   ├── state.py          # PrismState (LangGraph append-only channel)
│   └── translator.py     # BoundaryTranslator (structural reconstruction)
├── benchmarks/
│   └── domains/          # Healthcare · Finance · Trade Market
├── demo/
│   └── graph.py          # Runnable 3-node LangGraph demo
├── tests/                # 34 tests · 0 failures
└── docs/
    ├── ARCHITECTURE.md
    ├── BENCHMARK.md
    └── SECURITY.md

---

Security

PrismLang's tenant isolation is a geometric property guaranteed by the Johnson-Lindenstrauss lemma — not an access-control system. For production deployments, see docs/SECURITY.md which covers:

• What the JL matrix does and does not protect
• Overlay encryption for PII in raw_output
• Dependency security notes (onnxruntime, psycopg2, asyncpg)
• NumPy PRNG stability across version upgrades

To report a vulnerability: [e-mail] — do not open a public GitHub issue.

---

Citation

@techreport{parva2026prismlang,
  title       = {PrismLang: A Deterministic Vector Language Protocol
                 for Auditable Multi-Agent AI Orchestration},
  author      = {Parva, Amin},
  year        = {2026},
  institution = {Insight IT Solutions LLC},
  url         = {https://www.insightits.com/prismlang}
}

---

License

Apache 2.0 — free for commercial and personal use.

---

Built by Insight IT Solutions LLC

Enterprise AI systems · LangGraph architecture · Vector search · Production deployment

🌐 Website · 📧 Contact · 🔒 Security