Product Surfaces

Choose the right surface

Syntropy now has three distinct product surfaces. They are related, but they are not interchangeable.

The product promise is direct: This is a BEAM-native multi-agent execution runtime where agent selection, task routing, synthesis, supervision, replay, and trust evidence are observable.

The current MVP path is intentionally narrow: review an architecture decision, inspect the selected perspectives and score breakdown, read the synthesis, replay the path, and check structural trust evidence when it exists.

Source-grounded codebase review is live in the platform: paste a public GitHub repository URL — or point the composer at a local repository path — and Syntropy builds a bounded source packet through GitHub retrieval or Librarian, then grounds the multi-agent recommendation in file-level citations. See Source-grounded reviews for install and contract details. IDE or native app integration comes later.

Python

Use Python when you want:

• local programmable architecture decision review
• library-first adoption
• direct control over tasks, agents, and evaluation

This is the fastest way to start building with the shared lattice contract.

Platform

Use the platform when you want:

• the run cockpit as the primary workflow
• architecture decision submission without operator-only density
• GitHub repository review with file-level source evidence
• local repository review via Librarian when the binary is on PATH
• selected perspectives, score breakdown, synthesis, replay, and runtime posture
• graph-backed explanation of retained snapshots

The platform sits on top of Syntropy APIs. It does not own runtime state.

The public website now includes a static replay demo backed by the shared Syntropy graph presentation fixture. That demo explains the product flow, but it does not replace the authenticated platform or the operator console.

Syntropy Mission Control

Use Syntropy when you want:

• operator truth
• cluster and durability visibility
• deeper replay and inspection
• direct runtime debugging

Syntropy is the runtime source of truth and the operator console. The platform is the cleaner user-facing layer on top of it.

Recommended flow

1. Start with the canonical architecture prompt in Python or the platform: "Should this system use a monolith, modular monolith, or microservices for the next product stage?"
2. Use the platform run cockpit to inspect the selected perspectives, score breakdown, synthesis, replay links, and trust links.
3. Escalate into Syntropy mission control when you need deeper operational detail or incident visibility.
4. For codebase decisions, use the source-grounded review path: paste a GitHub URL or a local repository path into the composer. Install Librarian for local paths. Editor integration comes later.

Current hosted demo posture

The hosted cluster is currently best understood as a live orchestration and runtime demo.

• clustering is real
• replay and retained history are real
• routing and provenance are real
• the hosted provider is still mock

That means the system already demonstrates real runtime architecture without pretending the hosted reasoning layer is production-grade model output.