Mullusi Signal Compression Index Runtime witness: AwaitingEvidence

Every public claim must survive governance before it becomes visible.

Governed software that does not execute a claim until its state is known.

Mullusi separates product routes, proof boundaries, runtime witness state, and release gates into one symbolic control surface.

Website: Live
Proof boundary: Visible
Runtime witness: AwaitingEvidence
Next gate: Signed witness endpoints

Review Proof Boundary View Foundation Route

Last updated 2026-06-09

Flagship route Mullu claim -> proof -> witness

Claim declassification

Runtime is live

scan
conflict
rewrite
verdict

Live

Public Route

mullusi.com is the company and foundation routing surface.

Rule

Public identity may be shown because the surface exists.

Inspect surface

Start Here

Choose the surface

A first visit should route quickly: product, proof, sandbox, or public structure.

ProductView MulluFoundation-stage governed product route. EvidenceReview proof boundaryPending runtime claims. DemoInspect the playgroundIllustrative flow only, not a runtime claim. StructureRead the platform mapLayer map, request flow, and release discipline.

Verification Plane

Three things you can check

Trust comes from what you can verify, not from what we promise. Each pillar is named after what it lets you catch — not what it prevents.

Inclusion

Is a stamp recorded in the public log? Reserved until the witness endpoint publishes signed evidence.
Reserved
Integrity

Is the log itself append-only? AwaitingEvidence until cryptographic checkpoints publish.
AwaitingEvidence
Identity

Which independent witnesses watch the log? Reserved until external monitors register their public keys.
Reserved

Each pillar is the same shape: name what you catch, name the adversary baseline, name when it goes live. Borrowed from transparency-log practice and the Ethiopian canon-table tradition — both are witness apparatuses.

Platform Spine

Company, platform, products

Mullusi is layered: public surfaces route users, the control plane governs actions, product services execute privately, storage preserves memory, Cloudflare protects the edge, and GitHub remains the source factory.

In plain terms: the website is the map; the dashboard is the control room; the API is the machine gateway; the control plane decides what can run.

public map

Public Surface

mullusi.com, docs, learn, and future status routes.

governance brain

Control Plane

Auth, users, product registry, permissions, policy, audit, and job routing.

private execution

Product Services

Search, agents, chain, video, music, science, robotics, and developer services.

Public website

Docs route

Private source boundary

Cloudflare edge

Control-plane skeleton

API health endpoint

User/auth layer

First governed product

01What is it?02Who can use it?03What happens if it fails?

Public Surface Metrics

Public surface metrics

Every number below is computed at load time from the same governed JSON the rest of the site renders. If it is shown here, it is verifiable.

Deployed public surfaces

Draft v1

Govern API contract

AwaitingEvidence

Runtime witness state

Mullu: Flagship product route
1: Deployed public surface
AwaitingEvidence: Runtime evidence

The Shift

Old way vs Mullusi way

Mullusi is being structured so output-derived actions become proposals first, then pass through governance only when evidence, authority, risk, and dependency state permit execution.

Old way

Mullusi way

Model output drives action directly

Model output becomes a proposal

Prompt confidence is treated as readiness

Action requires governed verdict

Logs appear after execution

Trace exists before execution

One approval covers a whole agent run

Material consequences are re-checked as context changes

UI summarizes without proof linkage

Every surface field is reversible to trace

Rollback means hiding or replacing old state

Rollback creates superseded lineage

Deadlines pressure evidence claims

Evidence state cannot be mutated by pressure

Checked before it runsTraceable reasoningFail-closed by default Tamper-evident traceDomain engines, stagedVerifiable public surface Checked before it runsTraceable reasoningFail-closed by default Tamper-evident traceDomain engines, stagedVerifiable public surface

Govern Cloud v1

Govern evaluation service

Start with one vertical contract: authorized request, deterministic evaluation, append-only trace, proof state, repair action, and dashboard visibility.

In plain terms: send an action, get back a verdict, the reason, an audit trace, and a proof stamp.

Starter

Free

Explore SDK, CLI, sandbox examples, public docs, and local proof examples.

Paid

Pro

Planned higher evaluation limits, persistent traces, proof stamp review, and dashboard workspace control.

Contract

Enterprise

Planned private deployment boundary with custom governance rules and support limits after release evidence closes.

Core v1

Govern Evaluation

POST /v1/govern/evaluate

Evaluates a proposed action or system state against Mullusi governance constraints.

Use Cases

Use-case fit

Illustrative scenarios — the shape of value the governed runtime will deliver once evidence is published.

Production Claim Boundary

Production claim boundary

The website proves the public company and product route boundary. It does not claim a live governed runtime until the deployment witness endpoints publish signed evidence.

Mullusi: Company, research, governance authority, trust boundary, and public domain owner.
Mullu: Flagship governed product under Mullusi for proof-backed symbolic work.
Runtime Witness: AwaitingEvidence until /health, /gateway/witness, and /runtime/conformance close.
Proof Route: mullusi.com/proof/ is the public boundary for pending runtime evidence.

Website is live. Govern API and proof stamps remain AwaitingEvidence until signed runtime evidence publishes. The status board is generated from data/site.json.

Evidence Plane

Evidence plane

Every page answers the same questions: what exists, where it lives, how it is governed, what remains planned, and whether runtime witness evidence is closed.

In plain terms: if it is stated here, you can check where it lives and how it is governed.

Identity

Immutable public boundary

Mullusi is presented as one governed system across website, docs, release evidence, sandbox, metrics, and contact paths.

Governance

Claims tied to evidence

Public claims are separated into the deployed website, private incubation, planned domains, and operational interfaces.

Structure

Content is data-backed

Deployment card, staged domain engines, interface links, proof lanes, and roadmap stages are modeled as structured records.

Evolution

Expansion without redesign

New product surfaces and domains enter the public site through data updates before they need dedicated pages.

Architecture

Governed public spine

The site is structured around Mullusi's invariant model. Public pages point only to the deployed website surface, staged domain engines, proof artifacts, demos, or planned roadmap slots without exposing private incubation work.

In plain terms: every public claim points to a real surface, a planned slot, or nothing — never a guess.

Architecture Review proof boundary

Interfaces

Public routes

Interface links are treated as managed records so new public routes can be added without reworking the layout.

Public route

Docs

Reference material, architecture notes, and public learning paths.

Open Docs →

Service Stack

Service stack

Packages help users connect, validate, and submit work. Hosted services perform governance, preserve traces, issue proof stamps, and expose operational control.

Primary offer

Mullusi Govern Cloud

Hosted symbolic governance for constraint evaluation, causal verdicts, proof states, and trace records.

Access layer

Developer Packages

Client SDK, CLI, and local validators for connecting to Mullusi services.

Operator surface

Mullusi Dashboard

Project control, trace review, proof stamps, violations, usage, teams, and release witness visibility.

Product Graph

Product graph

The public site now separates the Mullusi umbrella, the Mullu product route, and the proof boundary. Product-shaped runtime, SDK, science, language, and interface work remains private until release gates are met.

In plain terms: Mullu has the public foundation route first; the other engines wait for proof-ready release gates.

Mullu

Foundation-stage governed product for proof-backed work, local proof threads, product surfaces, and runtime-bound symbolic execution.

Mullu Control Plane

Governance, channels, approvals, budgets, audit traces, multi-provider runtime boundaries, and witness closure preparation.

SDK & Cells

MSIC, symbol cells, causal-chain linking, mesh binding, deterministic memory routing, Φ traversal.

Evidence & Interfaces

Search, inspect, capsule, 3D, SCC harnesses, trace surfaces, and proof-carrying public demos.

public productawaiting-evidence

Mullu Govern

Flagship governed evaluation product for checking actions, recording traces, and issuing proof-backed verdicts.

Science Engines

Science roadmap

Math, physics, engineering, biology, chemistry, and music are staged as governed product families, connected by a cross-domain bridge layer. None are exposed as public product releases yet.

In plain terms: the roadmap is sequential; staged domains do not compete with the foundation product path.

Engines Review proof boundary

Public Surface Registry

Public surface registry

Search the deployed public surfaces. Product, runtime, SDK, science, and research source work stay outside this catalog unless Mullusi approves a separate public release.

Surfaces Review proof boundary

Roadmap

Release gates

The public site can record future surface expansion, but each new domain stays private until it has a route, demo boundary, docs route, governance status, and product card that can be defended.

Register

Add or revise a deployed public-surface record in the structured registry.

Attach

Connect docs, demo, proof, status, and contact routes.

Verify

Confirm claims, accessibility, local rendering, and public boundary constraints.

Publish

Expose the product surface only after the public boundary is verified.

Judgment Kernel

Judgment kernel

Website claims follow the same discipline as the system: observable public surface, stated boundary, reversible update, and no silent failure. That is why the public graph separates deployed surfaces, private incubation, staged domains, and operational interfaces.

In plain terms: Psi is the judgment step. It releases a public claim only when state, effects, safety guards, proof, and lineage all hold. If anything is unresolved, nothing is published.

Architect note Review proof boundary

Frontier Signal

Frontier signal

A daily ranked digest of notable technology, science breakthroughs, and research releases, followed by Mullu product activity and platform release notes.

News Status

Expansion

Promote after proof

Each new domain can move from private incubation to public surface when the route, demo boundary, docs route, governance status, and release boundary are verified. Mullu remains the first product path under the Mullusi umbrella.

View platform map Review proof boundary Contact research