Design the system. Keep the source.
Genesis is the designer and coder for event-driven AI systems. Name a brain, pick a folder, and grow it on a canvas - then read every component as the file it really is, run it, and talk to it. It writes into your project and gets out of the way: there is no runtime dependency on Genesis and nothing to export.
cosmo genesis · opens on 127.0.0.1:7072 · ships in 0.1.11
Genesis, running.
All three views ship today in 0.1.11. These are the three moments worth watching: a component being created, that same component edited as source, and the finished brain answering through its own interface.
Four primitives. Four silhouettes.
A project grows from four parts, and each one keeps a single shape across the whole product. You place it in Genesis and then watch that exact shape light up in Prism.
The hard part was never the model call.
Wiring a model into a script takes an afternoon. Deciding what the components are, where memory lives, which tool a given step is allowed to reach, and how a person gets pulled in - that is the work, and it is where almost every team stalls. Genesis makes that structure something you can see and move around without turning it into a format you can never leave.
Not a code generator
A generator writes a wall of code once and then fights you every time you edit it. Genesis parses the module you already own, changes the one declaration or handler you touched, and leaves your comments, imports and hand-written logic exactly where they were.
Not a graph builder
The canvas is a picture of what exists, not a control-flow diagram you have to keep accurate. There are no edges encoding “then” - components sit around the Synapse they share, because that is genuinely how the system runs.
Your repo is the artifact
Genesis scaffolds the same standard skeleton as cosmo init and writes into it. brain.py is the single entry point, and the project runs under python, in Docker, or in CI with Genesis nowhere in the picture.
It says what it can’t do
Open a project someone else laid out and Genesis tells you where its assumptions don’t hold - no brain.py to wire into, components outside the folders it reads, a module that builds its component in a factory. None of that blocks you. All of it is said out loud, because the alternative is a button that appears to work and doesn’t.
Canvas, Code, Test.
Three ways of looking at one project - the shape, the source, and the running thing. No build step and no export between them.
Place a primitive. Genesis writes the module.
- One Synapse at the centre of the canvas with everything it hosts in orbit around it. Each node wears the same silhouette Prism gives it - Neurons are circles, Engrams diamonds, Effectors triangles, Receptors cups - so the thing you laid out and the thing you later watch run are visibly the same system.
- Pick a primitive from the palette, name it, and Genesis writes neurons/<name>.py (or engram/, effector/, receptors/) and wires it into brain.py. The name you type is used verbatim as the component's id on the bus, so the file, the node and the Signal all say the same thing.
- A Receptor asks one extra question - CLI, API or chat - because that choice is not switchable afterwards. The three take different constructor keywords and expose different decorators, so turning one into another is a rewrite, and Genesis would rather ask once than offer a toggle that lies.
- Nodes you drag keep their position per project, and a newly added component walks the ring in 15-degree steps to find a free slot rather than landing on top of something you already placed.
Declarations as forms. Handlers as code. Everything else, verbatim.
- Genesis reads a component module into three parts: the declaration (rendered as a form, one field per constructor keyword, with its blurb, suggestions and placeholder - credentials masked with a reveal toggle), the behaviours you have written (rendered as editable code boxes, grouped into the protocols this component can serve), and everything Genesis does not model, shown verbatim so nothing is silently dropped.
- Every structured edit posts to the server and gets the re-read model back. Genesis never guesses what the file now looks like - the file on disk is the only source of truth, which is why you can hand-edit a module in your own editor and reopen it here without a resync step.
- An Engram's shape is switchable in place: served over a working backend (the default), served-only if you want to decide where the data lives, or a prebuilt backend where recall() and imprint() are real methods and there are no hooks to add. InMemory, SQLite and Postgres are one dropdown, and the backend's own keywords - Postgres's dsn= and so on - get their own form.
- An Axon carries two axes, source and form. Source is which provider builds the Neuron - Ollama, HuggingFace, OpenAI, Anthropic, Groq, OpenRouter, Together, Mistral, MCP, or a plain custom function. Form is how the pairing was written, which matters because only the from_source path attaches a recogniser and teaches the model the cosmo intent convention. Genesis knows which providers have a sugar classmethod and which can only be written the long way, instead of offering a button that cannot work.
- Behaviour bodies that cannot be safely dedented are round-tripped exactly as they were. Genesis would rather hand a block back untouched than reformat code it did not fully understand.
Run the brain. Drive it through its own front door.
- The Receptor list is read off your source, not off a running process - which is why it is populated before you press Run, and why a CLI Receptor is drivable at all. Its surface is a set of decorated functions with signatures; a browser could never discover that over HTTP.
- Run starts brain.py as a real process, one per project, with its pid, uptime and exit code on screen. Connect then opens whatever that Receptor actually is: a terminal wired to the process's stdin and stdout over a WebSocket, a request builder for an HTTP one, or a chat panel.
- For a CLI Receptor, Genesis has already parsed each command's parameters into what they become on the command line - a positional, a --flag or a switch - along with which commands are answered locally without ever dispatching a TASK.
- HTTP calls are relayed through the Genesis server rather than fired from the tab. An ApiReceptor sends no CORS header, so a direct call would be blocked before it left the browser; going through the server that served the page also turns transport failures into readable errors instead of an opaque TypeError.
- Because Receptors funnel into the same dispatch trio as every internal component, what you exercise here is the production path rather than a mock of it.
Genesis never hosts the Synapse.
It probes one, spawns one when you ask, and points Prism at it. Every status you see is a fresh probe rather than remembered state - so a Synapse you started from a terminal reads exactly the same as one started from this UI, and closing Genesis never takes your bus down with it.
A liveness pill, not a guess
The header shows whether a Synapse is actually serving your namespace right now, with its transport, uptime and Signal count - and, when it isn’t, the reason in words. Starting one resolves only once the namespace is genuinely registered, so the indicator never has to walk back a green light it showed too early.
Prism is one click away
Open Prism from the same menu and Genesis starts a Prism server if none is running, then hands you a tab already pointed at that Synapse and namespace. Design, run and observe end up being three windows onto one process, not three setups.
Open a canvas in about a minute.
Genesis ships inside the same package as the runtime. pip install cosmonapse, then cosmo genesis - it opens in your browser, and the project it makes is one you can delete Genesis and still run.
What Genesis writes for, and what watches 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 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 →