CommandLayer Logo
CommandLayer Semantic verb & schema layer for agents
Runtime

Execution on top of stable schemas — reference runtime today, guarantees by design.

Commons and Commercial define what a verb means: public request + receipt contracts. Runtime is the execution surface: it runs schema-conformant verbs and returns typed, signed receipts that can be verified independently — without changing semantics.

Today, Runtime operates as a reference execution layer. Its architecture is built to support policy, metering, idempotency, and settlement over time — layered on top of the same pinned contracts.

▶️ See live receipts 🪪 How routing works
Schemas are public and pinned Runtime executes + proves Receipts are verifiable evidence

Where Runtime sits in the stack

Runtime sits above schemas and below applications. It consumes the same immutable JSON Schemas and returns the same receipt shapes — but introduces a real execution surface where guarantees can be enforced over time.

Inputs

Schema-shaped verb invocations (Commons today). Routing is explicit and deterministic — no hidden payloads, no semantic drift.

Execution

Reference execution against pinned schemas, producing deterministic receipts. Validation and proof are first-class outputs, not afterthoughts.

Outputs

Typed receipts with trace IDs and cryptographic proofs. Clients read what happened — they don’t infer it.

What Runtime provides today

This is the minimum surface required for agents to behave like infrastructure: schema enforcement, reproducibility, and independently verifiable evidence.

Live capabilities (reference runtime)

What exists now, end-to-end, in the live demo and runtime-backed flows.

  • Schema enforcement: requests and receipts conform to pinned JSON Schemas.
  • Traceability: every execution returns a trace_id.
  • Receipts as evidence: signed, hashable receipts — not logs.
  • Reproducibility: calls can be replayed via copy-pasteable curl.
  • Verification: schema + hash + signature can be checked independently.

This layer is intentionally narrow: it proves the contract can be executed and proven reliably before layering in commercial policy and economics.

What Runtime is designed to add

These are planned capabilities. They are deliberately layered on top of stable schemas — never baked into them.

  • Policy layers: allow/deny rules, safety filters, execution constraints.
  • Idempotency: safe retries for multi-step and commercial flows.
  • Metering: standardized usage fields in receipts.
  • Pricing: SLA-based execution tiers (latency/throughput/policy bundles).
  • Settlement: execution-time economics on standardized rails.
  • Multi-runtime portability: same contracts, different executors.

The constraint: semantics remain public goods. Runtime evolves operationally without fragmenting meaning.

Why value accrues at execution

CommandLayer does not monetize meaning. Value accrues where execution absorbs operational cost and produces audit-grade proof.

Economics (principle)

Contracts stay open. Execution becomes infrastructure.

  • Schemas remain public: the verb language stays accessible and portable.
  • Receipts remain portable: evidence can be verified without trusting a vendor.
  • Execution carries cost: guarantees, policy, reliability, and metering live at runtime.

The forward-looking bet: a shared verb language becomes normal. The winners are runtimes that can execute it reliably and prove what happened — without forking semantics.

Receipt envelope (shape you can verify)

Runtime receipts are designed to be checked independently: schema-valid, hash-stable, and signature-verifiable. The live demo returns real receipts; the snippet below shows the kind of fields Runtime standardizes.

Example receipt (fields representative)

Replace placeholders with any live receipt from the demo to verify end-to-end. 

{
  "x402": {
    "verb": "convert",
    "version": "1.0.0"
  },
  "trace": {
    "trace_id": "trace_00f07ceec643",
    "started_at": "2025-12-26T02:14:14.397Z",
    "completed_at": "2025-12-26T02:14:14.397Z",
    "duration_ms": 0
  },
  "status": "success",
  "result": {
    "converted_content": "..."
  },
  "metadata": {
    "proof": {
      "alg": "ed25519-sha256",
      "canonical": "json-stringify",
      "signer_id": "runtime.commandlayer.eth",
      "hash_sha256": "...",
      "signature_b64": "..."
    }
  }
}

The point: clients don’t guess what happened. They read a typed receipt tied to a schema version and a trace ID, with a proof they can verify.

Runtime roadmap (high level)

Runtime ships in phases. Each phase hardens execution without changing semantics.

  • Phase 1 (now): reference runtime + receipts + verification.
  • Phase 2: policy hooks + metered usage fields in receipts.
  • Phase 3: commercial verbs + idempotent execution semantics.
  • Phase 4: settlement + multi-runtime ecosystems on shared contracts.

Simple model: Commons/Commercial are the public language. Runtime is what it means to run it correctly. Semantics stay open. Execution becomes infrastructure.