The platform to build
proactive agents.
A proactive agent acts when something happens - a document lands, a threshold trips, another agent disagrees - not when someone types. That is an event problem, not a graph problem. Cosmonapse gives you the substrate: design the system on a canvas in Genesis, run it on the open Core protocol and runtime, and watch it think in Prism. No supervisor loop, no control-flow graph to maintain - just components reacting to Signals on one bus.
Python 3.11+ · Apache 2.0 · Core, Genesis and Prism all ship in the one package
Three bets.
Cosmonapse is not a nicer wrapper around the same idea. It starts from three positions that most of the current tooling disagrees with: two about the systems people are building today, and one about the ones they cannot build yet.
A graph is a diagram. It is not a program.
Graph and loop frameworks make you declare control flow before you know what the system does - nodes, edges, branches, and a supervisor that turns the crank. Then something arrives that you did not draw: a tool returns late, a human answers halfway through, a second model disagrees with the first. Every new case is a new edge, and the supervisor becomes the thing you cannot change.
Components emit Signals and react to Signals on one bus. Nobody holds the loop, so an agent can act the moment something happens rather than waiting for its turn in a graph. Concurrency, fan-out, retries, ordering and backpressure are properties of the transport - the same ones that have run distributed systems for twenty years.
Wrappers do not have moats. Systems do.
A prompt, a vector store and a UI over somebody else's model is cheap to clone and hard to price. The teams stuck here have already solved which model to use; what they cannot do is get from a demo to something with a shape - observable, ownable, operable by a team, and defensible enough to charge for.
Build the system instead of the wrapper: domain memory that is yours, tools that touch real systems, interfaces people actually use, and an explicit policy for when a human steps in. Boutique AI, assembled from parts you own and running on an open protocol you can read.
The domains that are coming have no prompt to wait for.
Physical intelligence, AI-native software and operating systems, communities of agents that outlive any one session - all of it is continuous and concurrent. A robot revises its picture of the world many times a second. An AI-native OS has to answer a file changing, a process dying, a peer coming online. A community of agents has members joining, disagreeing and dropping offline while the work carries on. None of it begins with a person typing, and none of it fits a request, a traversal and an answer. So every team working in these areas writes its own bus, its own scheduler and its own trace format before it gets near the actual domain problem.
For those systems an event substrate is not an optimisation, it is the only shape they have. Cosmonapse is that layer with agent semantics already in the envelope: a Signal knows whether it is a tool call, a memory write or a model output, so a sensor loop, an OS event stream and a community's membership churn are the same primitive rather than three bespoke integrations. Change the transport URL and what you prototyped on a laptop runs across a fleet. We are not building those products. The bet is that the substrate they need does not exist yet, and that whoever builds them should not have to build it twice.
Three products. One event stream.
Genesis, Core and Prism are separate products with separate jobs, and they share exactly one thing: the Signal envelope. That is what lets the designer, the runtime and the observability plane stay honest about the same system without any of them owning it.
Cosmonapse Core
The open Apache 2.0 protocol and the runtime that speaks it. One Signal envelope, one Synapse, replaceable Neurons. Memory (Engram), tools (Effector) and interfaces (Receptor) are first-class primitives, not framework add-ons - and the transport swaps from in-process to NATS or Kafka by changing a URL.
- Signal envelope spec + the Python reference SDK
- Neuron, Axon, Dendrite, Engram, Effector, Receptor primitives
- Memory, NATS and Kafka transports behind one URL
pip install cosmonapseExplore →Cosmonapse Genesis
The designer. Name a brain, scaffold it, and grow it on a canvas - one Synapse surrounded by the Neurons that think, Engrams that remember, Effectors that act and Receptors that listen. Genesis writes each module into your project as real source you own, edits it through the AST rather than regenerating it, then runs the brain and lets you talk to it without leaving the browser.
- Canvas: place a primitive, Genesis writes the module and wires brain.py
- Code: declarations as forms, handlers as code, edits applied through the AST
- Test: run brain.py and drive its Receptors by terminal, HTTP or chat
cosmo genesisExplore →Cosmonapse Prism
The observability plane. Prism is a read-only tap on the Synapse - it never claims a Signal - and turns one event stream into five views: the live neural graph, the per-run execution graph, the causal tree of a task, the raw Signal list, and metrics. Every number is derived from timestamps and lineage already in the envelope, so there is nothing to instrument and nothing extra for the SDK to emit.
- Brain View: watch Signals fire between participants in real time
- Signal Tree: causal parentage from TASK to FINAL, sub-tasks nested
- Metrics: success rate, latency, memory hit rate, HITL waits, bidding
cosmo prismExplore →Where the open source line falls.
Core is Apache 2.0 and always will be. The essential builds of Genesis and Prism are free with it, in the same pip install, and they are enough to build and run a real system on your own machine. What gets sold later is Pro, Cloud and Enterprise - the deeper product surface and the operating burden around it, never the protocol.
The protocol, the Python SDK and the runtime. Apache 2.0, and it stays that way - the substrate your system is built on is not something we intend to sell you back later.
- Signal envelope spec and the reference SDK
- Neuron, Axon, Dendrite, Engram, Effector, Receptor
- In-process, NATS and Kafka transports behind one URL
Enough of the designer and the observability plane to build, run and debug a real system on your own machine, free, in the same pip install. No account, no key, no seat count.
- Genesis: canvas, code editing through the AST, run and test a brain
- Prism: live brain view, signal tree, the raw stream and core metrics
- Local only, single developer, your source on your disk
The deeper end of Genesis and Prism for people doing this full time - the surface that pays for itself in a working week rather than the surface you need to get started.
- Advanced Genesis workflows and larger-system tooling
- Retained history, comparison and analysis in Prism
- Per-seat, self-serve
The hosted version of the same loop. Design and observe in a browser, deploy a brain as a service, and let a team work on one project at once.
- Managed deploy with quotas and scoped credentials
- Shared projects, presence and a persistent Signal history
- Usage-based
What a regulated buyer needs before any of this is allowed near production, distributed as a licensed wheel off a private index.
- RBAC, audit trails, multi-tenancy and HA
- Offline-verifiable licensing, airgap friendly
- Support, SLA and architecture review
The rule we are holding ourselves to: nothing on the paid side is load-bearing for anything on the free side. A system you build today keeps running on an open protocol, an open runtime and a local toolchain whether or not you ever pay us. Early access is where the commercial tiers get shaped, so if you have an opinion about what belongs on which side, that is the room.
Design it. Run it. Watch it.
You are never handed off between tools. The canvas, the runtime and the traces are three views of the same running system, and the source on disk is the only artifact.
Design
Lay the system out on a canvas - Neurons that think, Engrams that remember, Effectors that act, Receptors that listen. Genesis writes real source into your project and edits it through the AST as the shape changes.
Run
Everything talks over one Signal envelope on one Synapse. Start in-process, move to NATS or Kafka by changing a URL. No orchestrator holds the loop, so nothing has to be rewritten to scale out.
Observe
Attach a read-only tap to the same bus and watch the system think: the live graph, the causal tree behind a single task, where a task's wall clock actually went. Tracing is free because the bus already saw it.
~20 lines. Three transports.
A working multi-agent system is about twenty lines - define an async function, wrap it in an Axon, attach it to a Dendrite, call dispatch_and_wait. No protocol boilerplate. And the scale path is a single URL swap: MemorySynapse → NatsSynapse → KafkaSynapse, with zero changes to your Neuron code.
import asyncio, os from cosmonapse import Axon, Dendrite, connect_synapse SYNAPSE_URL = "memory://" # ← the only line that changes axon = Axon.huggingface("greeter", endpoint="https://router.huggingface.co", model="meta-llama/Llama-3.1-8B-Instruct", api_key=os.environ["HF_TOKEN"], use_chat_api=True, capabilities=["chat"]) async def main(): synapse = await connect_synapse(SYNAPSE_URL) worker = Dendrite(synapse=synapse, namespace="demo", role="worker") worker.attach_axon(axon) orch = Dendrite(synapse=synapse, namespace="demo") async with worker, orch: reply = await orch.dispatch_and_wait( neuron="greeter", input={"prompt": "Say hello to Cosmonapse."}, timeout_s=30.0) print(reply.payload["output"]["response"]) asyncio.run(main())
Boutique AI systems, not another wrapper.
The shape is always the same: an interface people actually use, domain memory that is yours, tools that touch real systems, and a policy for when a human gets involved. The model is the cheapest part. Everything around it is the product.
None of these are graphs. Each one is a set of independent components reacting to Signals, where the interesting behaviour - escalation, disagreement, a late tool result, a human in the middle - is a Signal arriving rather than an edge you drew. Fourteen runnable examples show the patterns end to end.
Running an enterprise team or startup building something real on this? Come talk to us.
This round is scoped to enterprise teams and funded startups. We run architecture sessions with early adopters on the system they are actually building - free, framework-agnostic, and with the people writing the protocol. The first 10 members accepted also get credits, a standing discount on Cosmonapse Cloud, and the option to form a Letter of Intent with us.
Build a system, not a demo.
Core 0.1.12 is a research preview: the envelope is drafted, the Python SDK implements it, and Genesis and Prism run locally today off the same CLI. It is open source under Apache 2.0 - read the spec, disagree with it in public, and build on it either way.