Architecture: three complementary modules (SYNE, ECHOS, PRISM)
How LIVEX separates the truth of the world, its observation and its perceptual rendering to guarantee reproducibility and traceability.
Note: this article describes the architecture as published in October 2026 (LIVEX 1.0.0 line). A reworked PRISM V2 is planned; see the PRISM V2 series for the target.
An agent is thirsty. It consults its memory, spots a waterhole it knows, weighs the energy of the trip against the risk of arriving too late, then sets off. At the precise instant it moves, three questions arise at once: who decided this step? Who observes it? Who shows it?
An improvised architecture would answer "a bit of everyone." LIVEX answers with a strict separation: one module holds the truth of the world, another observes it, a third makes it perceivable. Neither the observer nor the renderer can change the smallest decision of an agent. This principle was set down before the first feature, and it still drives every technical choice of the project today.
Three roles, one truth
The system is built around three complementary modules, with a deliberately sharp division of responsibilities.
| Module | Full name | Role |
|---|---|---|
| SYNE | Systems & Emergent Network Engine | Multi-agent simulation engine. It holds the truth of the world state, runs the simulation loop and guarantees determinism. Independent of rendering. |
| ECHOS | Emergent Cognition & Holistic Observation System | Observation, analysis, calibration and control system. It consumes the SYNE stream, computes metrics, detects emergent phenomena, produces calibration reports and allows comparison between runs. |
| PRISM | Perceptual Rendering & Interactive Simulation Module | LIVEX's final Unreal project, integrating the PRISM-LDK plugin (LIVEX Development Kit). It provides perceptual rendering and immersion without carrying decision logic. |
This split looks like a matter of comfort. It is actually a scientific constraint. A world about which we want to prove something must be replayable identically, and for that we must know, at every moment, who has authority. As soon as two components can write into the world state, the chain of causality blurs: it becomes impossible to say whether the observed phenomenon comes from the laws of the simulation or from interference by the observation.
Why decouple, and how far
Decoupling answers three imperatives that hold together: reproducibility, traceability and portability. They impose a simple, almost brutal rule.
Only SYNE has authority. Neither ECHOS nor PRISM modifies the decision state; SYNE is the single source of truth. This is what allows us to claim that a run is deterministic (for a given seed and configuration, it repeats) without having to prove that three components left it alone.
Observation is non-intrusive. ECHOS subscribes to SYNE's observability stream (snapshots, events, ticks) without altering the simulation. The broadcast order and the semantics of the frames are fixed by contract, precisely so that the observer cannot introduce an invisible feedback loop.
Rendering is independent of the core. PRISM does not carry cognition: it consumes SYNE's state and events to produce a perceptual representation, while remaining controllable through orchestration.
SYNE, the decision core
SYNE implements a discrete-time world, advanced tick by tick. The autonomous agents have needs, memory, beliefs, partial perception, a utility formula and capacities for action. Nothing spectacular in this list taken in isolation. It is their combination, tick after tick, that produces trajectories no line of code wrote in advance.
The loop is deterministic: with an identical seed and a consistent configuration, the execution lands on a state aligned with its oracles. Persistence, handled by SQLite, allows a run to resume at the exact place where it stopped, and the HTTP control server allows full programmatic control. A world can therefore be started, paused, moved and resumed without its trajectory changing. This is the condition of a replayable experiment.
ECHOS, the observer that touches nothing
On the other side of the stream, ECHOS turns raw observability into traceable knowledge. It ingests what SYNE publishes, persists an event log and snapshots, computes normalized metrics and builds time series from them. It also detects tick discontinuities (the gaps) and records them instead of smoothing them over. Every value carries its provenance.
Its calibration reports are versioned (schemaVersion 2) and include outcome, extinctionTick and a viability block. The comparison between runs (/api/compare) clearly distinguishes a verdict based on the bit-for-bit fingerprint from a simple lightweight summary: a demonstrated equality is never confused with a resemblance. What ECHOS produces stays read-only. The observatory writes its conclusions, and never rewrites the world.
PRISM and the PRISM-LDK plugin
PRISM is LIVEX's final Unreal project. It integrates PRISM-LDK, a technical module that formalizes the interface with SYNE and ECHOS: the world_initialized description (which includes simulatedSecondsPerTick and metersPerUnit), the snapshot stream, the events, the control cycle (prepare, ready, start, pause, resume, stop, reset) and supervision.
ADR-002 records this choice and supersedes the historical ADR-001, which described a Godot prototype: SYNE remains the only decision-maker, and PRISM is only a perceptual rendering host. The project preferred to own this shift through a written decision rather than through a silent drift.
Contracts, not promises
None of this would hold on the developers' goodwill alone. The whole is locked down by living contracts (API_CONTRACTS.md, INTEGRATION_CONTRACT.md, TRANSPORT_API.md) whose rules are few but non-negotiable. The "snapshot then events" order on the observability stream is strict, tick after tick. The canonical run_id, in the format run-<seed>-<12hex>, guarantees traceability between executions, packages and reports. And because these rules are tested, observation cannot, even accidentally, influence the course of the simulation.
Separate to be able to prove
The goal fits in one sentence: separate what runs the world (SYNE), from what observes it (ECHOS), from what shows it (PRISM). This separation is not an architect's refinement. It is the very condition of the reproducibility and traceability demanded by LIVEX's guiding question. Without it, every observation would be an anecdote. With it, every observation becomes a claim that can be replayed, verified and discussed.
To go further, the documentation portal details the architecture and the contracts, and the project journal, also available as an RSS feed, follows the evolution of the components measurement after measurement.
This article is an English translation of the original French post, Architecture : trois modules complémentaires (SYNE, ECHOS, PRISM), published on the LIVEX journal on October 2, 2026. Project website: LIVEX. Source code: GitHub.
About the author
- Creator and developer of LIVEX, an open-source lab for multi-agent simulation. Notes on engines, observation tools and the surprises that emerge.
Comments
Join the discussionNo comments yet. Be the first to comment.
LIVEX: Behind the Simulation (EN)
The story of LIVEX in plain English: why it exists, how it works and what it takes to make a multi-agent simulation reproducible.





