PrismPath
Open SourceThe document your team reads is the graph the engine runs.
PrismPath replaces routing callbacks with Markdown files. A heading is a node, prose is the instruction, an arrow is an edge. Inspect it, diff it, lock it, run it. On any device, in any language.
## Intake
Classify the incoming request.
-> Billing: about charges or refunds
-> Technical: about bugs or outages
-> General: else
## Billing
Pull the account and recent charges.
-> Resolved
## Technical
Check status; reproduce if you can.
-> Resolved
## General
Answer directly.
-> Resolved
## Resolved
Summarize what was done.The same file, two ways: what you read on the left is exactly what the engine runs on the right.
How it works
Markdown in, control flow out.
Write a flow
Headings are nodes. Prose is the agent instruction. Arrow lines are edges with conditions, deterministic or semantic.
Lock the routing
prismpath lock pins every semantic edge’s embedding vector. The lockfile is your routing’s package-lock.json.
Run anywhere
Python, JS, Rust, or Go: the same flow, the same result. Browsers, edge functions, servers, embedded devices.
What you get
- Flows are Markdown: readable, diffable, version-controlled
- Four kernels: Python (full), JavaScript (zero-dep), Rust (native/WASM), Go (stdlib-only)
- Lockfile-pinned semantic routing for reproducible AI decisions
- Conformance-verified across all kernels against a frozen corpus
- Runs in browsers, servers, edge functions, and embedded devices
## Intake Classify the incoming request. -> Billing: about charges, payments, refunds -> Technical: about bugs, errors, outages -> General: anything else ## Billing Look up the customer's account and recent transactions. Summarize charges. -> Resolved ## Technical Check system status and known issues. Reproduce if possible. -> Resolved ## General Answer the question directly. -> Resolved ## Resolved Summarize what was done.
Portability
Four kernels. One spec.
Every kernel is conformance-verified against the same frozen corpus. If a device can run a workload, one of these kernels runs on it.
Python
P0 to P2The reference implementation. Full routing stack: embeddings, LLM hybrid, lockfiles, type gates, checkpoints.
JavaScript
P0 to P1Zero-dependency ES module. Browsers, Node, edge functions, network appliances. ~780 lines.
Rust
P0 to P1Native binaries, WASM, embedded. Two dependencies. Compiles to every architecture Rust targets.
Go
P0Dependency-free, standard library only. Services and CLIs; a single static binary per platform.
Portability levels
“P” stands for Portability: the minimum capability a kernel needs to run a given flow.
Deterministic
No ML. Every edge is decidable: when-predicates, error edges, event edges. Runs on any kernel.
Locked semantic
Semantic edges pinned by a lockfile. Needs an embedder, but routing is reproducible.
Full engine
Live embedding + LLM hybrid routing. Python reference kernel required.
Formal verification
Prove what a flow can, and can’t, do.
Because deterministic edges are decidable, PrismPath doesn’t just run your routing; it can prove properties of it before it ever executes.prismpath verify runs bounded model checking over a flow and answers reachability questions with a witness path.
- “Can this node ever be reached?” Answered, with a concrete path that gets there.
- “Is the danger state unreachable once amount ≤ 500?” Assumptions are first-class.
- Three-valued honesty: yes / may / no, never a false certainty.
- Routing you can audit and sign off, not just execute.
checking reachability (assume: amount <= 500) danger no unreachable (state space exhausted) resolve yes intake → triage → resolve PROVEN: 'danger' is unreachable once amount <= 500.
The hardware target
The same flow, compiled to a chip.
Portability doesn’t stop at software. A Level M flow (one whose deterministic tier is entirely field-op-constant) compiles to a compact binary table that a single fixed circuit interprets on an FPGA. No OS, no kernel, no runtime: the Markdown is the hardware’s program.
the compiled flow (wazuh_triage, unmodified)
routing live sensor data in fabric
worst-case per decision
of a Zynq-7020 (1,064 LUTs)
C and RTL interpreters are certified against a declared subset of the frozen conformance corpus, the subset is stated and never exceeded (deliberately not full spec conformance). Evidence hashes are timestamp-anchored on Bitcoin.
Decision telemetry
Ship the decision, not the data.
Because the policy is decidable, the only thing worth transmitting is which decision a reading produced. Figueroa quantization reduces a reading to exactly that: the minimum sufficient statistic for the policy’s decisions, one small symbol per field, derived from the policy itself and provably decision-preserving. The Facet protocol carries those symbols, with the codebook agreed from the signed policy rather than sent.
- Figueroa quantization: the decision-sufficient statistic, derived from the policy, proven to preserve every routing decision.
- The Facet protocol: a self-framing wire, codebook agreed not transmitted, Merkle-committed and OpenTimestamps-anchored.
- 66.9× smaller than OpenTelemetry (OTLP) protobuf, measured over 64,484 decisions.
- Decision-lossless, not data-lossless: raw magnitudes never leave the node.
Specified, evaluated, and named in the open.
Figueroa quantization and the Facet protocol are the two named contributions here: the primitive, and the wire that carries it. Both are defined normatively, with invariants and a conformance clause, and evaluated against the industry-standard baseline.
See it route in your browser.
The playground runs the JS kernel client-side: write a flow, watch it compile, share it as a link.