Multi-agent runs you can replay, inspect, and trust.

Syntropy organizes autonomous agents on a mathematical lattice — hierarchy emerges from interaction, not assignment. Deterministic routing, snapshot replay, and identical math in Python and Elixir.

Open platform Read the docs

Syntropy platform overview dashboard showing runtime status, the live lattice graph, and the event feed

Deterministic routing

Same inputs, same ordering, same selection. No randomness in position computation.

Snapshot replay

Every run captures lattice snapshots you can step through after the fact.

Optional Postgres durability

In-memory by default; write-through persistence when you enable it.

Python + Elixir parity

Both runtimes satisfy the same lattice axioms, enforced by property tests.

Watch a decision take shape

A replayed architecture review from the runtime: agents position themselves on the lattice, a subset is selected, and the synthesis carries structural evidence you can audit.

Massive Concurrency & Observability: Architecture Decision Review.

A team asks whether the next product stage should use a monolith, modular monolith, or microservices. Syntropy parses the intent and dynamically routes the task through a massive, distributed lattice of specialized agents on the BEAM. It selects only the most relevant perspectives, synthesizes the trade-off, and retains the execution path as an observable, replayable artifact.

Agents: 21
Weighted links: 31
Selected: 6
Trigger: recommendation_created

The runtime coordinates state on a rigorous mathematical lattice across BEAM/OTP and asyncio. Hierarchy emerges from agent interaction rather than static assignment, which keeps routing deterministic and conflict resolution auditable across distributed nodes.

Platform flow Inspect the contract

Selected participantStandby lattice nodeLink thickness = coherence

Runtime task: decision-task-001
Join recommendation: rec-decision-join-001
Gateway node: gateway

Syntropy selects perspectives for the decision.

Reliability, security, and product rise first because the prompt asks for architecture risk, delivery speed, and future stage trade-offs.

The retained graph explains the recommendation.

The synthesis favors a modular monolith for the next stage, with reliability and operations carrying the strongest structural evidence against premature microservices.

Structural trust evidence stays reviewable.

A reliability-plus-operations join appears as recommendation evidence, but persistent structural change still belongs to Syntropy mission control.

Mathematically rigorous by contract

Every operation satisfies the lattice invariants below, in both the Python core and the Elixir coordination engine. Property-based tests on both sides read the same axiom contract.

a ∨ b = b ∨ a

Commutativity and associativity

Final lattice synthesis is independent of agent processing order or network arrival times.

a ∨ a = a

Idempotency

Duplicate observations or duplicate thought triggers do not corrupt agent positioning or state.

a ∨ (a ∧ b) = a

Absorption

Underpins conflict resolution: integrating redundant views preserves local coherence.

pos(a ∨ b) ≥ pos(a)

Bounds preservation

Join and meet compute strict upper and lower boundaries for perspective aggregation.

shared/axioms.json6 axioms · enforced in CI

// lattice axioms
join(a, b) == join(b, a)
join(a, join(b, c)) == join(join(a, b), c)
join(a, a) == a
join(a, meet(a, b)) == a
position(join(a, b)) >= max(position(a), position(b))
position(meet(a, b)) <= min(position(a), position(b))
// shared constants
position = 0.3*knowledge + 0.5*synthesis + 0.2*connections
ema_alpha = 0.2
incomparability_epsilon = 0.05
recompute_interval_seconds = 30

Start in minutes

Run a review from the Python SDK, the Elixir runtime, or the REST API.

from syntropy import Lattice

lattice = Lattice()
lattice.add_agent("Reliability Reviewer", perspective="reliability")
lattice.add_agent("Security Reviewer", perspective="security")
lattice.add_agent("Product Strategist", perspective="product")

result = await lattice.submit(
    "Should this system use a monolith, modular monolith, or microservices for the next product stage?",
    strategy="parallel",
)

print(result.synthesis)
print(result.selection_trace)
print(lattice.print_order())