Compact Contract Runtime

15 bytes that prove your system followed the rules

MOVA records any meaningful action into a verifiable binary artifact. Cryptographic contract proof inside. Domain semantics via swappable dictionaries. Vendor-neutral. Open source. Rust-powered.

Get SDK → See how it works

header 4D 56 41 0B magic: MVA

schema_tag 00 00 A4 11 → 42001

schema_hash8 fe 33 6b ab 29 7c f1 cd ✓ RFC 8785

policy_tag 00 00 A8 09 → 43001

policy_hash8 a0 d6 1c 6e 75 5e 0c 3a ✓ RFC 8785

record #1 01 01 2E E3 00 00 00 00 ... extract → retrieval

record #2 02 02 2E E4 00 00 00 00 ... calculate → calculator

record #3 03 03 2E E5 00 00 00 00 ... answer → api

97 B

compact core

13.6×

expansion to JSON

The Problem

Systems act. But nothing proves how.

AI models make decisions. Supply chains move goods. Agents call tools. But the link between what happened and what was supposed to happen is broken.

✗ Today: trust gap

Traces and logs are stored separately from rules. You can't prove which schema version or policy was active when a record was created. Audit = reconstruct and hope.

✗ Today: bloated traces

A single LLM call produces kilobytes of JSON. Multiply by millions of actions — and you're drowning in storage costs. Most of it is repetitive structure, not signal.

✓ MOVA: embedded proof

Schema hash and policy hash are written into the binary header. The artifact itself proves which contract it was created under. Verification is offline, instant, trustless.

✓ MOVA: 15 bytes per record

Compact binary core. Domain semantics restored on read via dictionary. 97 bytes for a 3-step agent run. Fits on an NFC tag. Fits in a QR code. Fits everywhere.

Two Paths In

Build from data. Or wrap what you have.

Starting from scratch? Build an agent from a dataset and dictionary.
Already have a working system? Describe it in MOVA, add recording on boundaries, get contract proof instantly.

Path A — "I have data, I need an agent"

Take a HuggingFace dataset. Extract a domain dictionary: verbs, tools, conditions. Build an agent that speaks this vocabulary. Record compact traces from day one.

1. HF dataset → extractor → dictionary
2. Dictionary → agent with domain vocabulary
3. Agent runs → core.mova from first call

Path B — "I have a system, I need a contract"

Your agent, pipeline, or workflow already works. Describe its steps as MOVA verbs and tools. Compose a dictionary. Add event record calls at boundaries. Done — contract proof without rewriting anything.

1. Your process → identify verbs, tools, conditions
2. Compose dictionary → hash → bind
3. Wrap boundaries → core.mova from existing code

Both paths converge into the same cycle

Schema + Policy → Record → Compare → Correct → Repeat.
Same binary core. Same contract proof. Same compact dataset output.

How It Works

Record. Prove. Read.

Three layers. One binary artifact. Full verifiability.

Record

Every meaningful boundary event — a tool call, a decision, a data handoff — is recorded as a 15-byte binary record with CRC32 integrity check. Schema and policy hashes are embedded in the file header.

$ mova run start --mode framed \ --schema-tag 42001 \ --policy-tag 43001 # → core.mova created with contract proof in header

Prove

Anyone can verify: take the published schema JSON, hash it with RFC 8785, compare first 8 bytes with hash8 in the binary header. If it matches — this record was made under that exact contract. No server needed. No trust required.

$ mova contract hash --file schema.json hash8: fe336bab297cf1cd tag: 42001
# matches core.mova header → contract verified ✓

Read

Attach a domain dictionary and the compact binary unfolds into a semantic journal: human-readable, with verb names, tool labels, conditions and expectations. 97 bytes become 1,324 bytes of meaning.

$ mova journal tail --session-id S-DEMO seq:1 extract → retrieval [inputs_complete] ✓ seq:2 calculate → calculator [projection_ready] ✓ seq:3 answer → api [final_answer_ready] ✓

Live Examples

Two real runs. Both committed.

All artifacts — core.mova, sidecar.jsonl, journal, evaluation — are committed in the repository and ready to inspect.

Demo A — Deterministic Workflow

Ad routing decision. No AI. 4 deterministic steps. Schema + policy proof in header.

seq=1 ingest → ingress_gateway [context_captured]
seq=2 evaluate → rules_engine [best_rule_selected]
seq=3 resolve → resolver [resolution_complete]
seq=4 redirect → router [client_redirect_ready]

116 B

core.mova

15×

vs decoded journal

score: 100/100 · all checks passed
schema_tag: 52001 · policy_tag: 53001
gate: invariant_pass=true

Demo B — AI Agent + Quality Gate

Finance agent. LLM invents numbers on attempt #1. MOVA catches it, sends feedback, forces retry. Both attempts recorded.

seq=1 extract → retrieval [inputs_complete]
seq=2 calculate → calculator [projection_ready]
seq=3 answer → api [final_answer_ready]

97 B

core.mova

13.6×

vs decoded journal

attempt #1: score=52 rejected (8 invented numbers)
attempt #2: score=96 accepted ✓ (0 invented)
OTel trace: 9715b9b3... (Grafana / Datadog)

Inspect artifacts on GitHub →

Architecture

Four repositories. One ecosystem.

From abstract specification to working binary runtime — a complete vertical stack, open source. OTel correlation is built into the SDK via standard span IDs — no separate layer needed.

Standard

mova-spec

The language. JSON Schema contracts, verbs, envelopes, global semantic layer.

ds.* — data schemas env.* — speech-act envelopes global.* — shared vocabulary

Domain Profile

agent-profile

Agent-domain extension. Agent contract, execution result, task and result envelopes.

ds.mova_agent_contract_core_v1 ds.mova_agent_execution_result env.agent_task_execute_v1

Semantics

dictionaries

Domain meaning. Maps numeric IDs to verbs, tools, conditions. Swappable per domain.

HuggingFace datasets compact_overrides hash-verified binding

Runtime

mova_sdk

The engine. Rust binary core, contract proof, sidecar with OTel spans, CLI/API/embed.

core.mova — 15B records + CRC32 sidecar.jsonl — metadata + OTel spans manifest.json — contract gate

Schema + Policy → RFC 8785 hash → Embedded in binary header → Offline verification → Dictionary decode → Semantic journal

The Closed Loop

Data → Behavior → Data → Better.

MOVA doesn't just record. It produces compact datasets that drive the next iteration. Every run is a verifiable, comparable, improvable artifact.

STEP 01

Source Dataset

Domain data from HuggingFace or private registry. Hash-verified, revision-pinned.

dictionary_hash: sha256:cc43...

STEP 02

Build Dictionary

Extract domain vocabulary: verbs, tools, conditions, expectations. Bind to compact IDs.

finance_qa_v1.json

STEP 03

Execute + Record

Agent runs. Every boundary event → 15-byte record. Contract proof in header. Sidecar captures evals.

core.mova — 97 bytes

STEP 04

Compare

Current run vs etalon. Contract compatibility check before any metrics. Strict or tolerant mode.

run compare → ok / drift

STEP 05

Correct + Repeat

Adjust policy rules, evolve schema, update dictionary. Next cycle starts from improved baseline.

policy_v2 → schema_v2

↻ COMPACT AGENT DATASET

Each run produces a publishable, verifiable dataset.
Compare with etalon. Publish back. Next agent is better.

Contract Proof

The artifact proves itself.

No trust required. No server needed. Hash the published contract, compare with the binary header. Match = proven.

Published Contract

schema.json
↓ RFC 8785 canonical
↓ SHA-256
↓ first 8 bytes
→ fe336bab297cf1cd

Binary Header

core.mova
↓ read header
↓ schema_hash8

→ fe336bab297cf1cd

→

Verdict

✓ schema_status: ok
✓ policy_status: ok
✓ invariant_pass: true
✓ strict_fail: false

✓ Offline. Microseconds. No trust in source required.

OpenTelemetry Correlation

Standard spans. Zero connectors.

MOVA writes standard trace_id/span_id into sidecar records. Your existing APM picks them up. No bridge, no adapter, no migration — just matching IDs.

Datadog / Grafana

trace_id:9715b9b3... → latency, errors, throughput

→ DevOps

── same trace_id ──

MOVA core.mova

trace_id:9715b9b3... → contract proof, policy gate

→ Compliance

── same trace_id ──

MOVA journal

trace_id:9715b9b3... → semantic events, eval scores

→ Data Science

Use Cases

One format. Every domain.

Same binary core. Same contract proof. Different dictionary — different domain.

🤖

Now — 2026

AI Systems

Record every LLM call, tool use, and decision. Compare runs against etalon. Policy-driven quality gates with automatic retry. Compact agent datasets for continuous improvement.

3 records = 97 bytes
attempt#1 score=52 rejected
attempt#2 score=96 accepted ✓

⚖️

2026 — 2027

Regulated Compliance

EU AI Act, SEC, HIPAA — all require audit trails for AI decisions. MOVA delivers cryptographic evidence: which schema, which policy, which result. Not logs — proof.

schema_status: ok
policy_status: ok
invariant_pass: true

🔋

2027 — 2028

Digital Product Passport

15-byte records fit on NFC tags and in QR codes. Contract hash binds to the exact EU delegated act version. Offline verification at point of scan. No server, no trust in manufacturer.

core.mova on NFC: ~400 bytes
contract: EU Battery Reg v1
verify: offline, instant

🔗

2026+

Supply Chain Trust

Two parties that don't trust each other exchange core.mova. Receiver checks schema_hash8 against published contract. Match = data is structurally valid. No central mediator.

vendor A → core.mova
vendor B verifies → hash8 match ✓
trust: cryptographic, not social

Vendor Neutral

Open standards. Zero lock-in.

Every layer uses international standards. Artifact created in Azure verifies in AWS, reads on-prem, stores on HuggingFace.

Schemas

JSON Schema 2020-12

Industry-standard contract format. Not a proprietary DSL.

Hashing

RFC 8785

Canonical JSON serialization. Deterministic, reproducible hashes.

Telemetry

OpenTelemetry

Correlates via trace_id/span_id. Works with any OTel-compatible APM.

Sidecar

JSONL

Universal line-delimited JSON. Readable by any tool in any language.

Dictionaries

HuggingFace / Local

Store anywhere. SHA-256 verification. No central authority.

Runtime

Rust + Python

Runs on cloud, on-prem, edge, air-gapped. No cloud dependency.

Get Started

Three commands to your first proof.

STEP 01

Install

Clone the SDK. Install Python dependencies. Rust compiles automatically on first run.

git clone https://github.com/mova-compact/mova_sdk
cd mova_sdk
pip install -e .

STEP 02

Record

Start a session with a contract. Record events. Each becomes a 15-byte binary record.

mova run start --mode framed \
  --schema-tag 42001 \
  --policy-tag 43001
mova event record --verb CALL \
  --tool 12003 --status ok

STEP 03

Verify + Read

Verify contract integrity. Decode the binary into a semantic journal with domain meaning.

mova contract hash --file schema.json
mova journal tail --session-id S-DEMO
mova journal summary --session-id S-DEMO

15 bytes that prove your system followed the rules

Systems act. But nothing proves how.

Build from data. Or wrap what you have.

Record. Prove. Read.

Record

Prove

Read

Two real runs. Both committed.

Four repositories. One ecosystem.

Data → Behavior → Data → Better.

The artifact proves itself.

Standard spans. Zero connectors.

One format. Every domain.

Open standards. Zero lock-in.

Three commands to your first proof.

Record in bytes. Prove in microseconds. Improve every cycle.

Record in bytes.
Prove in microseconds.
Improve every cycle.