Launching today

Sinapsis
A single contract for the AI ecosystem
3 followers
A single contract for the AI ecosystem
3 followers
A single contract for the AI ecosystem. Package models, libraries and custom Python code as reusable Templates. Connect them through consistent component interfaces and shared data structures, then compose and execute them as either realtime or event-driven complete AI systems, without being locked into a single model provider, framework or runtime. https://github.com/SinapsisHub/sinapsis-hub




Launch Team

AWS Startup AdvisorPersonalized AWS guidance that meets you where you’re already building
Promoted
Hey Product Hunt! We’re Nimesh and Ariel, the founders of Sinapsis, and we’re excited to finally share what we’ve been building. This is our first launch on here!
We’ve both spent many years building and deploying complex AI systems to production, including working together at Arm and other startups. Building AI demos is easier now than ever. Stitching different technologies and tools, managing dependencies and getting everything into production is where things get complicated.
If you have to upgrade a model or dependency, a new feature request comes in or business logic has to change, significant rework and reintegration effort is required. When you move to the next project, you end up rebuilding much of the same functionality. You also often end up tied to a single set of vendors.
We thought there had to be a better way!! That’s why we built Sinapsis. A single contract for the AI ecosystem.
Package models, libraries, APIs and custom Python code into reusable and composable Templates. Connect them through consistent interfaces and shared data structures, then compose them into complete AI systems, or Agents.
Below is what we’re releasing today (there is a lot more we plan to release in the upcoming weeks and months!):
Open-source
Reusable Templates and Agents, including nested Agents and composite Templates
Different execution modes, asynchronous and parallel execution, and lazy initialisation
A common data contract through Universal Data Transport (UDT)
Modular packages for computer vision, speech, generative AI, time series and more
Declarative, type-safe graphs with execution across local Python environments and Docker
A CLI, example applications and practical use cases to get started
Sinapsis Cloud
Managed execution and deployment of Agents
Independent scaling of Templates and Agents
Real-time streaming at Template and Agent level
Secrets management and a web app for monitoring Agents
Cloud execution through the Sinapsis CLI
The core is open source, so you can build and run locally without relying on our cloud. Cloud features require a paid account.
We’re still early, and we’d love developers to get involved, try it out and tell us what works, what doesn’t and what’s missing. You can open a github issue or talk to us directly on our discord server: https://discord.gg/QyDaPBRtg
A question for the community: How are you handling reuse, integration and deployment across different AI projects today?
Thanks for checking us out!
https://github.com/SinapsisHub/sinapsis-hub
https://docs.sinapsis.tech/
https://sinapsis.tech
https://discord.gg/uuBqQqu2vS
Hey everyone, Ariel here, founder and CEO of Sinapsis 👋
After 15 years of researching and building AI and ML systems, one thing has become increasingly clear to me: we keep solving the same integration problems over and over again - even in the post llm era.
The AI ecosystem has incredible tools (though I still have a soft spot for Torch7, Caffe and the like), models and frameworks, but getting them to work together in production is still unnecessarily complicated and takes too much time. Different interfaces, incompatible dependencies, different execution environments, and a lot of glue code.
We built Sinapsis around a simple idea: what if AI capabilities shared a common computational and data contract?
In Sinapsis, everything is a reusable Template. A Template can run a model, train a network, call an API, process data or execute arbitrary Python code.
Templates compose into Agents, and Agents can themselves become Templates. This means you can build complex systems from smaller, reusable components without constantly reinventing the architecture from scratch.
A few core design choices behind how this works:
One data contract: Templates communicate through consistent interfaces and DataContainers, with Universal Data Transport (UDT) handling data representation across execution boundaries.
Compute separate from execution: Define your Agent once, then execute locally, in Docker or through managed infrastructure without rewriting the computational graph.
Dependency isolation: Different Templates can run with different dependency stacks, so incompatible libraries don't have to dictate your entire architecture.
Flexible execution: Asynchronous and parallel execution, lazy initialisation, nested Agents and different execution modes are built into the framework.
No forced stack: Use the models, frameworks, libraries and infrastructure that make sense for your app, whether open source or enterprise.
The core framework, CLI and package ecosystem are open source. You can build and execute Agents locally without using Sinapsis Cloud. For developers who need managed execution, scaling and real-time streaming, we've built Sinapsis Cloud on top of the same computational model.
We're launching today, and I'd genuinely love feedback from other engineers. In particular, I'm interested in how you're handling dependency conflicts, reusable AI components and the separation of application logic from execution infrastructure.
Have a look at the code and poke holes in the architecture. Feel free to open an issue, contribute a template, or just drop a comment with what you think!
https://sinapsis.tech
https://github.com/SinapsisHub/
https://docs.sinapsis.tech/
https://discord.gg/uuBqQqu2vS