Process a prompt
Every prompt is screened by ORA's 4-layer AST shield, checked against the Constitution, and gated by your authority level before a model ever sees it. The gates below are the real ones — running live in your browser.
THE CONSTITUTION
Four immutable Prime Directives sit above everything ORA does. The document is hashed (SHA-256); verify_immutability() fails closed if a single rule is altered.
Nine prohibited operations are refused at the gate — try the "Prohibited op" chip above:
Authority — the A0–A5 ladder
Capabilities are gated by authority level. Nothing escalates itself; raising authority requires approval, and A5 (disabling gates) requires a hardware key. Current session runs at the level shown.
Pending approvals
High-authority and out-of-policy actions don't just run — they queue for a human. Approve or reject; every decision lands in the audit trail.
Secrets vault
API keys and credentials live in an encrypted vault, sealed by default. Tools can only read a secret while the vault is unlocked and the authority level permits it — and every access is logged.
Immutable audit trail
Every gate result, decision, and action is appended to a hash-linked chain — each entry carries the hash of the one before it, so the record can't be quietly rewritten. Run prompts and watch it grow.
Kernel metrics
ORA is a single Rust binary — low, predictable overhead. Live snapshot (demo values).
One server. Six kernels.
ORA isn't a wrapper around a model. It's a single Rust binary that does the work of a memory API, an MCP server, and a multi-agent orchestrator at once — with a security kernel wrapped around all of it. The user sees one assistant; inside, ORA picks the cheapest trustworthy path to an answer.
ROUTE KERNEL
Classifies each request and chooses the cheapest trustworthy path — memory recall, cached evidence, live retrieval, or a specialist sub-run — instead of brute-forcing every query through a big model.
MEMORY KERNEL · PulZ
Durable semantic memory with compression — recall across sessions without re-stuffing the prompt. The embedded answer to Zep / Mem0, but governed and auditable.
ACQUISITION KERNEL
Retrieval, web search, and tool execution — fetched only when the route kernel decides it's needed, then verified before it's trusted.
SECURITY KERNEL
The 4-layer AST shield, A0–A5 authority, sandbox, and an encrypted vault — quantum-ready crypto on the roadmap. Governance is the foundation, not a bolt-on.
ORCHESTRATION
Multi-agent DAG routing — Planner → Search → Summarize → Verify → Output — coordinated internally, exposed simply. Swarm inside, single tool outside.
GATEWAY
One Rust/Axum surface over HTTP, WebSocket, and the Model Context Protocol — so Claude, IDEs, and MCP clients talk to ORA directly. Every action lands in the immutable audit log.
The cheapest trustworthy path
ORA doesn't brute-force every question through a big model. The route kernel classifies each request and walks a ladder — stopping at the first rung that can answer it with enough confidence. Most questions never need the expensive rungs.
Every route decision is recorded with its reasoning. The router scores each request on three axes before choosing: Task class (general · workspace · operational · browser · command) · Freshness (historical · recent · live) · Evidence burden (minimal · grounded · strict). Decisions persist to a SQLite control plane so you can audit why ORA chose the path it did.
17 governed tools. One MCP surface.
ORA speaks the Model Context Protocol (2024-11-05), so Claude Desktop, Cursor, and any MCP client can drive it directly. Every tool call runs through the gates and the authority check first — and lands in the audit log after.
TOOLS (17)
GATEWAY — 30+ ENDPOINTS
PROVIDERS — BRING YOUR OWN MODEL
Provider-agnostic client trait with auto-detection at startup. Run fully local on Ollama, or route to a frontier API — same governance either way.
One Rust binary. 7,888 lines. Zero interpreter.
ORA is a single statically-linked binary built with release-grade optimization — no Python, no node, no runtime to ship. Security isn't bolted on; some of it is enforced by the type system at compile time.
COMPILE-TIME AUTHORITY
Authority levels are encoded as a Rust type-state trait hierarchy (A0Clearance → … → A5Clearance), wrapped in a SecureContext<C>. If an agent doesn't hold the clearance a privileged operation requires, the code does not compile. Zero runtime cost — the guarantee is in the type system, not a check you can forget to write.
Where ORA stands
The market split into three layers — memory APIs (Mem0, Zep), MCP transport, and agent orchestrators (CrewAI, AutoGen) — each largely blind to the others, and most blind to governance. ORA spans all three with a security kernel built in.
| ORA | Mem0/Zep | CrewAI/AutoGen | Letta | Sema4 |
|---|
Positioning per ORA's March-2026 competitor analysis. "~" = partial / implicit.
Benchmarks
ORA's pitch is speed + safety, proven — not claimed. These are the published targets from the ORA benchmarking plan; the orchestrator is being open-sourced so anyone can reproduce them. (Gate latency above is measured live in this demo.)
Labs — capabilities we discuss privately
Not everything 3D3D builds is on the public menu. A few capabilities are powerful enough — and dual-use enough — that we keep the method private and the conversation by request, for vetted partners and authorized testing only. You're behind the demo gate, so here's a glimpse of one.
PROVENANCE & INTEGRITY LAYER
It can embed an invisible, verifiable mark inside ordinary files — images, documents, model outputs — so origin and tampering can be proven after the fact. It can read those marks back out, and it can tell when someone else has hidden something inside a file. Think watermarking, content provenance, tamper-evidence, and detection — done quietly, at the byte level.
We don't ship offensive tooling and we don't publish the technique. What it can do, and how well, we'll show you. How it does it stays in the lab.