Sinapsis

Platform & architecture

Sinapsis architecture: one contract across AI components

Technical architecture of the Sinapsis single contract, declarative Agent graphs, typed multimodal packets and Universal Data Transport.

The Sinapsis architecture separates the application graph (Agent), reusable computation (Templates), shared multimodal data (DataContainer and DataPackets), data exchange (Universal Data Transport) and runtime execution. These layers make it possible to combine heterogeneous AI tools without inventing a new application-level interface for every component.

The architecture at a glance

A Sinapsis Agent defines a declarative graph of Templates. Every normal Template takes one DataContainer and returns one DataContainer. A DataContainer holds typed packets containing payloads and metadata. UDT provides an exchange format when container values cross a process or service boundary. A runtime executes the declared graph while respecting its data dependencies.

This separation matters: a component can change its model provider or internal implementation while the enclosing Agent graph continues to use the same boundary, subject to application-level compatibility and tests.

Agent: the workflow contract

An Agent describes which Templates participate, their connections and their dependencies, rather than requiring an imperative sequence of calls. The architecture defines one external DataContainer input and output. A graph can contain parallel branches, but branch fan-out and fan-in must be represented by explicit DataSplit and DataMerge operations. An arbitrary DAG is therefore not automatically a valid Sinapsis Agent.

Because scheduling is separate from graph semantics, a runtime may execute supported work sequentially, concurrently or at remote boundaries without changing what the Agent declares. The specific deployment architecture determines which runtime and scaling facilities are available.

Read the Agent Model in the developer docs.

Template: the reusable computation contract

A normal Template implements DataContainer → DataContainer. It can call an API or model, transform content, add typed packets, enrich existing packets with annotations or produce an empty container. Templates can encapsulate models, Python classes, third-party libraries, domain logic and composed behaviour. They are not restricted to LLM prompting.

Each Template must still understand the packet types it processes. A common data boundary does not mean that all Templates accept all possible payloads.

Read Templates and the detailed Template Model.

DataContainer and packets: the multimodal contract

A DataContainer provides the common semantic interface across the graph. Its typed packets can represent text, images, audio, files, dataframes, custom payloads and rich annotations. For example, an image-processing Template might add bounding boxes or masks to an image packet; a downstream Template can use those annotations to crop regions or compute embeddings without changing the graph-level interface.

Packet classes and serializers may evolve across package generations; use the version-specific API reference for exact class names and requirements.

Read DataContainers and Packets.

Universal Data Transport: the exchange contract

UDT standardizes DataContainer representation and exchange when data must cross boundaries. Local components may pass Python objects directly; remote operations can serialize and reconstruct the container. UDT does not imply a single codec for every payload: Arrow, binary array encoding, Protobuf payload schemas and artifact references can serve distinct needs. Physical transport may use HTTP, queues, TCP or another supported mechanism.

In short: the Agent defines the topology, the Template defines the transformation, DataContainer defines the semantic data boundary, UDT defines exchange, and the runtime defines execution.

Read UDT concepts.

How this helps with production systems

The shared boundary makes it easier to isolate, profile, test, replace and reuse individual steps; the declarative graph makes dependencies visible. In production, deployment, retries, observability, security, capacity management and autoscaling still require concrete platform and infrastructure configuration. The common contract is the architectural foundation, not an automatic guarantee of operational reliability.

For an application-level view, read Why Sinapsis and Production AI.

Authoritative source material

Architecture · Why Sinapsis? · Production AI · Pricing · Open-source GitHub