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 is the open-source framework for event-driven AI agents: 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
Glia: a policy card on every Axon, Effector and Engram.
A card reads the signals entering and leaving its component and refuses, redacts or escalates what its policies match. Every violation emits an AUDIT record on its own subject, so no AUDIT on a trace means nothing fired. Cards default to off, run in audit first, and enforce when you switch them.
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. Glia puts a policy card on each Axon, Effector and Engram. The transport swaps from in-process to NATS or Kafka by changing a URL.
- Signal envelope spec + the Python reference SDK
- Six primitives, with Glia policy cards on Axons, Effectors and Engrams
- 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 we sell is Pro, Cloud and Enterprise, live now in closed testing - 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. If you have an opinion about what belongs on which side, book a call.
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.
Get started.
Install the package and follow the quickstart to run your first brain on your own machine. If you are building something real on Cosmonapse, book a call and we will go through the system with you.