FABRIC
Governed AI computation across any device, any network, any organization. With cryptographic proof of every decision.
Any AI. Governed. Everywhere.
Same composable stack. Different use cases. Add what you need, leave the rest.
Regulated AI
Banking, healthcare, legal. Every AI decision governed, every action Merkle-anchored, auditable by regulators without trusting your logs.
Personal AI
Your AI assistant lives on your phone. At your laptop, it follows you there. Needs GPU? It borrows your server. Your data never leaves your devices.
Smart Home
Thermostat, camera, door lock — all mesh nodes. AI can't unlock your door without biometric approval. Every action recorded. Works over MQTT on a Raspberry Pi.
Cross-Org Workflows
Org A's agent calls Org B's API. Ed25519-signed governance proofs travel with the request. Neither side trusts the other. The math verifies.
Edge / Offline AI
Military, mining, disaster response. No internet? No problem. Devices form a local mesh. Governance runs locally. Evidence syncs when connectivity returns.
Enterprise Agents
Customer service, code generation, data analysis. Circuit breakers protect APIs. Rate limiters prevent cost overruns. Every decision auditable.
Infrastructure, not framework.
Most AI frameworks are monoliths with extension points. Orchetron is the opposite — independent planes you compose into whatever your system needs.
A monolith with hooks.
- ✗You write code that fits inside
- ✗Memory is a class, not a plane
- ✗Governance bolted on as middleware
- ✗Swap a backend = rewrite
- ✗Audit trail is "just check the logs"
Independent planes you compose.
- ✓You compose what you need
- ✓Memory is a plane — swap implementations
- ✓Governance is the foundation, not a wrapper
- ✓Swap a backend = implement 1-5 methods
- ✓Evidence is hash-chained, signed, verifiable
You don't pick Orchetron for any single feature. You pick it because in two years, when your needs change, you swap a piece — not the whole stack.
The fabric exists.
11 independent planes. Compose what you need. The foundation.
Governance
PVC pipeline
Evidence
Hash chain · Ed25519
Memory
3-tier · decay · promote
Observation
spans · traces · OTel
Knowledge
vectors · FTS · embed
Connectors
MCP · A2A · 20+ adapters
Events
pub/sub · triggers
Auth
RBAC · ABAC · tenants
Storage
object · blob · scoped
Compute
CPU · GPU · capacity
Scheduling
cron · triggers · jobs
+ Yours
1-5 method interface
YOUR SYSTEM
The fabric extends.
Phone asks a question. Laptop researches via Groq LLM. Governance evaluates every call. Evidence is Merkle-anchored. Works over 8 transports — WebSocket, WebRTC, MQTT, mDNS, Messaging, HTTP, SSE, In-Process.
Phone
light tier · 2 cores
Laptop
standard tier · 8 cores
Server
heavy tier · 64 cores
A task starts on your phone. The mesh detects your laptop and migrates it. When it needs a GPU, it dispatches to your home server. You wrote zero distributed code. The fabric just flows.
The fabric proves itself.
Evidence entries batched into Merkle trees, anchored to crash-safe stores. Cross-org Ed25519 proofs travel between organizations. M-of-N policy voting with cryptographic signatures. A trustless audit() function any regulator can run.
MERKLE ROOT
Single hash that covers 100 records
PUBLIC LEDGER
Ethereum L2 · Transparency Log · IPFS
ANYONE VERIFIES
auditor · regulator · counterparty · future-you
no access to your servers required
trust the math · not the server
A regulator runs audit() on your evidence chain. Checks timestamp ordering, duplicate IDs, Merkle root verification, policy quorum, governance coverage. Returns pass or fail. They never touch your servers. The math proves it.
One protocol.
Every scope.
The Fabric Protocol is the foundation everything runs on. Same envelope format from in-process plane calls to cross-org verification. Same protocol over WebSocket, WebRTC, MQTT, mDNS, Messaging, HTTP, SSE. OFP is to governed computation what HTTP is to the web.
Plane to plane
InProcessOFPTransport. Zero serialization overhead. Plane-to-plane communication within a single fabric instance.
Across the mesh
Phone to laptop over relay. Peer-to-peer via WebRTC. Zero-server via mDNS. IoT via MQTT. Global via Messaging. Same envelope, same governance, same evidence.
Across trust boundaries
Ed25519 cross-org proofs, 2-of-3 decentralized policy voting, trustless audit. OFP envelopes carry governance decisions across trust boundaries.
HTTP let any client talk to any server. OFP lets any governed mission talk to any governed mission — in-process, across devices, across organizations. One protocol. Every scope.
Built on real primitives.
Tests
Across 6 packages. Core, SDK, Protocol, Mesh, Verify, Relay. All green.
Combinators
Governance algebra. AND, OR, NOT, IF, VOTE, RETRY, CIRCUIT_BREAK, CACHE...
Transports
HTTP, WebSocket, WebRTC, MQTT, mDNS, SSE, In-Process, Messaging. Same protocol.
Rings
Fabric, Extensions, Applications, Device Mesh, Decentralized Verify.
FIVE RINGS
Three acts. Five rings. Dependencies flow inward. Each ring maps to part of the story — Ring 1 is the fabric that exists, Ring 4 is the fabric that extends, Ring 5 is the fabric that proves itself.
FABRIC
The runtime. 11 swappable planes, governance algebra, evidence chain, Result monad.
EXTENSIONS
Pluggable capabilities. Skills, channels, browser, model router, IDE integrations.
APPLICATIONS
What you build. CLI, REST API, dashboard, VS Code extension, your own apps.
MESH
Phone + laptop + server form one mesh. Task migration, capability routing, 8 transports. Runs on real phones via Expo.
VERIFY
Merkle-anchored evidence, Ed25519 cross-org proofs, M-of-N policy voting, trustless audit.
IS / RUNS / TRUSTED
Each ring expands the scope without changing the foundation.
What it IS
A compositional computational fabric with swappable planes. A complete framework that runs on a single machine.
Where it RUNS
Not a single machine. Your devices are the fabric. Computation flows where capabilities live.
Why it's TRUSTED
Not because we say so. Because anyone can verify it. Evidence anchored, governance decentralized.
11 PLANES
Each swappable. Each independently testable. Implement 1-5 methods to replace any plane with your own.
Governance
PVC pipeline. 7 stages. 28+ combinators. Cannot be bypassed.
Evidence
Hash-chained. Ed25519 signed. Append-only. Tamper-evident.
Memory
3-tier (episodic, semantic, procedural) + custom. Decay & promotion.
Observation
W3C tracing, spans, metrics. OpenTelemetry native.
Knowledge
Semantic search, vector embeddings, document storage.
Connectors
20+ adapters. MCP + A2A native. Capability discovery.
Events
Pub/sub, triggers, CloudEvents, reactive missions.
Auth
RBAC/ABAC, tokens, roles, kernel-enforced isolation.
Storage
Object/blob storage, tenant-scoped. Pluggable backends.
Compute
Resource management, request lifecycle, capacity scheduling.
Scheduling
Job scheduling, cron triggers, distributed task queues.
Custom Plane
Define your own. 1-5 method interface. Full type safety.
Pay for what you use.
Zero planes by default. Add capabilities incrementally with with*() composable blocks. Each is orthogonal — memory doesn't know about evidence.
run(handler)
+ withGovernance()
+ withEvidence() + withTracing()
+ withMemory()
PROPOSE / VERIFY / COMMIT
The narrow waist of the runtime. Every side effect flows through three stages. No exceptions.
PROPOSE
Agent proposes a tool call with parameters and risk tier. Auto-classified from tool definition.
VERIFY
7 governance stages. Kernel invariants checked first. Cannot be bypassed.
COMMIT
Execute. Record evidence. Hash-chain to immutable append-only ledger.
Your devices.
Your rules.
AI agents run wherever you want them — phone, laptop, server, cloud, or all of them at once. Same governance, same evidence, same protocol everywhere.
- ✗Your data goes UP to the vendor
- ✗One vendor, one trust boundary
- ✗Logs you have to trust
- ✗Permissions are the vendor's problem
- ✓Agent runs ON your devices
- ✓Multi-device mesh, multi-org verifiable
- ✓Evidence anyone can verify, anytime
- ✓Governance is the foundation
Three things make this defensible.
Composability is the moat
23 governance combinators that form a closed algebra. 11 swappable planes with 1-5 method interfaces. 8 transports. The with*() composable pattern where you add governance, evidence, middleware, mesh — each independently, each swappable. 10,619 tests prove it composes. This isn't a feature — it's a foundation.
OFP is the HTTP for governed compute
8 transports — WebSocket, WebRTC, MQTT, mDNS, Messaging, HTTP, SSE, In-Process. Same envelope carries governance decisions, evidence entries, cross-org proofs, and capability invocations. Transport-agnostic by design.
The 5 rings are a topology
All 5 rings built and running. A regulated bank uses Rings 1+5 (governance + verifiability). A consumer app uses Rings 1+4 (device mesh). An IoT system uses Ring 4 over MQTT. A cross-org workflow uses Rings 4+5 with Ed25519 proofs and M-of-N voting. Pick what you need.
Why not seven?
The architecture supports two more rings. Not on the immediate roadmap — but the foundation is there.
EVOLVE
The fabric improves itself, within governance bounds. Capabilities proposed by usage patterns. Skills fitness-evaluated via canary deployment. Memory promotes itself across tiers. Connectors generate from OpenAPI specs.
Every evolution is auditable. No black-box "AI improves AI" — every change is a governed decision in the evidence chain.
EXCHANGE
Compute and capabilities have value. Devices and orgs offer capabilities at a price. Tasks pay for execution across trust boundaries. Reputation accrues to good actors.
An OFP economy where governance proofs and payment proofs travel together. Optional, like blockchain anchoring. Speculative until the world demands it.
Start composing.
Five rings. 8 transports. 10,619 tests. Running on real phones. Pure TypeScript.