Docs

Deployment-Ready Features

Asset Core is engineered for production systems that need deterministic state, explicit isolation, and audit-grade replay. This page summarizes the infrastructure-grade features that matter in real deployments.

Commit Log

Asset Core treats the commit log as the only atomic write. Every state transition is sealed as an immutable batch that includes both a delta and a post-state snapshot.

  • Append-only batches with checksums for integrity verification
  • Monotonic world sequence per namespace for stable ordering
  • Deterministic replay to reconstruct any historical state
  • Idempotency keys to safely retry write requests

Namespaces

Namespaces are hard boundaries: each namespace has its own identity space, registries, indices, and commit history. Isolation is enforced in both the write daemon and the read projections.

  • Namespace-scoped class registries and container ID spaces
  • Lifecycle states with explicit disable/delete transitions
  • Lineage metadata for fork-from-snapshot restores and staged branches
  • Per-namespace audit trails and history queries

Write Path

The write path is a deterministic pipeline with explicit sequencing, validation, and durability boundaries.

  • Admission and precheck workers to validate payloads in parallel
  • Reorder buffer to preserve deterministic sequencing under concurrency
  • Single-writer lane to serialize world mutations
  • Append pool and commit-log driver to seal and publish batches

Preflight Validation

Preflight validation simulates a commit without mutating world state or appending to the commit log. It uses the same L2/L3 rules as real commits, so results are commit-equivalent.

  • Fail-fast semantics: stops at the first invalid operation
  • Returns validated world sequence and per-op outcomes for planning
  • Enables agents to verify complex multi-op changes before submission

Example: a robot planner preflights a pick-and-place sequence against the shared workcell; if it passes, the exact commit will succeed at the same world sequence.

Authorization

Authorization is evaluated at request admission and per-operation with a default-deny posture. Responses avoid leaking namespace existence.

  • Default-deny policy with role-based evaluation
  • Namespace-scoped allow/deny bindings
  • Non-disclosure posture for unknown namespaces
  • Auth failure throttling and optional quota enforcement
  • Policy-driven authorization context for varied deployment environments

Log Storage

Asset Core supports multiple commit-log storage and reader configurations to fit different deployment profiles. The commit log interface is modular so deployments can add alternate backends without changing core semantics.

  • File-backed durable commit log for production deployments
  • In-memory commit log for development and embedded testing
  • Memory-mapped reader backend for alternate tailing strategies
  • Segment-based storage with checkpoints for fast recovery
  • Extensible backend surface for alternate storage media and policies

Observability

The read daemon tails the log to materialize projections and expose freshness metadata.

  • Freshness and lag metrics tied to world sequence
  • History/query endpoints that return sealed commit batches
  • Health probes for readiness and catch-up status
  • Deterministic replay paths for auditing and incident review
  • Projection freshness metadata to bound read-side staleness

For architecture and container fundamentals, see Basics. For runnable demonstrations, see Examples. For deeper technical reference, see Docs.