Technical Foundations

Core Concepts

Asset Core is a deterministic spatial-transactional engine that treats world state as a series of atomic, replayable transformations. When LLM-based agents execute tool calls—from adding items to a container to moving entities across a grid—every mutation is recorded in an append-only commit log that serves as the single source of truth.

This architecture guarantees that:

• The same sequence of events always produces the same final state (determinism)
• Any point in time can be reconstructed by replaying the commit log (replay)
• Internal state and external notifications never diverge (consistency)
• All operations are atomic and transactional (reliability)

Container Types

Agents operate in environments with different spatial structures. Asset Core provides first-class container types for each, modeling containers as spatially-typed objects where each represents a distinct kind of addressable space. The system currently supports:

0-Dimensional Containers

• Balances: Scalar aggregates with no spatial coordinates. Used for currency, resources, or any quantity that doesn’t occupy space.
• Slots: Discrete, numbered positions (1, 2, …, N) without geometric relationships. Used for equipment slots, ordered lists, or semantic positions.

Discrete Grids (1D/2D)

• 1D Grids (ℤ): Linear lattices with sequential positions. Support shape placement, collision, and spatial constraints along a single axis.
• 2D Grids (ℤ²): Two-dimensional lattices (width × height) with full geometric semantics. Support multi-cell shapes, rotation, adjacency, and collision detection.

Continuous Spaces (1D/2D)

• 1D Continuous (ℝ): Fixed-point coordinates along a line for rails, lifts, and single-axis robotics.
• 2D Continuous (ℝ²): Fixed-point x/y placements with rotation for robot workcells and metric collision checks.

Roadmap: Higher Dimensions

3D Discrete Grids (ℤ³): Volumetric lattices with depth, extending 2D semantics into three dimensions.

Continuous 3D (ℝ³): Continuous volumes with physics integration, metric-based collision, and smooth transformations.

Universal Operations

All containers share a common set of operations that work consistently across dimensional spaces:

• Add/Remove: Introduce or remove quantities or entities
• Move: Translate entities within the same container space
• Split/Merge: Divide or combine stacks and quantities
• Transfer: Move entities between different containers (cross-space transitions)

These operations preserve determinism, are fully replayable, and maintain consistent semantics whether applied to 0D balances or 2D grids.

Architecture

When an agent executes a tool call that modifies world state, Asset Core processes it through three layers. This three-layer architecture is inspired by database storage engines, ensuring clean separation of concerns and predictable behavior.

Storage Layer (L1)

Low-level data structures optimized for performance. Uses Structure-of-Arrays (SoA) layout with dense IDs for cache-friendly iteration and predictable memory access patterns. This layer provides raw primitives without validation or business logic.

Operations Layer (L2)

Domain validation and state orchestration. This layer orchestrates storage primitives, enforces world constraints (collision, bounds, shape fitting), maintains derived indexes, and emits events describing what changed. Operations are deterministic and fully validated before committing.

Transaction Layer (L3)

Atomic execution with rollback support. This layer coordinates transaction boundaries, records undo information for rollback, and seals successful operations into the commit log. Guarantees that operations are atomic and isolated. This layering ensures that performance-critical paths remain fast (L1), world rules are centralized and testable (L2), and transactional correctness is enforced structurally (L3).

Guarantees

Asset Core provides strong correctness and reliability guarantees through deterministic replay and an append-only commit log.

Replay

Replay is central to Asset Core’s correctness guarantees and enables perfect reconstruction of agent behavior. The commit log stores events as hybrid records containing both:

• Delta information: What changed (added 10 items, moved from slot A to slot B)
• Post-state: The resulting state after the change (final quantity is 50, entity now at position X)

This dual encoding enables:

• Real-time analytics: Delta information can drive dashboards, notifications, and live queries.
• Deterministic replay: Post-state defines the authoritative result—replaying the recorded sequence reproduces the exact original state with no cumulative drift.
• Crash recovery: Any projection (read model or observer) can be rebuilt from the commit log.

Replay applies events mechanically using storage primitives only, with no validation or world-rule logic. This guarantees that replayed state is bit-for-bit equivalent to the original committed state.

Commit Log

The commit log is an append-only, durable sequence of sealed event batches that serves as the authoritative record of all agent actions. It avoids dual-writes by making the log the only atomic write: every state transition is sealed by a single append, and all projections and notifications derive from that single source of truth.

Key properties:

• Events are immutable once committed.
• Global, monotonically increasing sequence numbers provide total ordering.
• Batches are checksummed for integrity verification.
• Segments can be compressed, encrypted, or archived.

This design supports compliance (audit trails, chain-of-custody), debugging (replay to any historical state), and multi-tenant isolation (namespaced commit history). Projections and notifications are derived from committed events and can be retried independently without risking divergence.

Use Cases

Asset Core is designed to support systems that require a deterministic, transactional model of world state, with a primary focus on LLM-based agents and multi-agent platforms.

Multi-Agent Systems

In multi-agent environments, Asset Core can serve as the shared world model. Tool invocations record deterministic state changes—such as moving or transferring resources—into the commit log, creating an auditable timeline for debugging, analysis, and replay.

Agent Platforms & Orchestration

Orchestration frameworks can integrate Asset Core to provide durable session state and namespaced isolation. Deterministic replay enables reproducible multi-step workflows and post-hoc inspection.

Simulations & Games

Simulation and game engines can employ Asset Core to model inventories, equipment, and spatial logic. Deterministic replay supports precise save/load behavior, synchronized multiplayer state, and audit-grade verification.

See Examples

For concrete demonstrations of each container type, see the Examples page for runnable-in-spirit JSON operations and agent scenarios.