The protocol and the runtime.
Core is the open, Apache 2.0 licensed foundation the rest of the suite is built on: a Signal envelope, a Synapse to carry it, six primitives that cover work, identity, transport, memory, tools and interfaces, and a policy card that governs each of them. Genesis writes against it and Prism reads from it, but Core stands on its own - and always will.
Six pieces. Nothing hidden.
There is no framework object that runs your system. Routing decisions, workflow rules and lifecycle policy stay with you - Core gives you the parts and the contract they speak.
Signal The envelope
One shared contract for everything that crosses the bus - TASK, AGENT_OUTPUT, TOOL_CALL, RECALL, IMPRINT, FINAL. Two components that emit valid Signals can always talk to each other. That is the only guarantee Core makes, and everything else is built on it.
Neuron The unit of work
A pure async function - fn(input, context) → output - with zero protocol knowledge. The Neuron factory wraps OpenAI, Anthropic, HuggingFace, Groq, Ollama or an MCP server behind that same signature, so swapping a provider never touches the system around it.
Axon Agent-side identity
Owns a Neuron's identity and capabilities and wraps its output into protocol-valid Signals. An Axon never touches the Synapse - that boundary is enforced in code, not by convention, which is what keeps a Neuron portable.
Dendrite Synapse-side connector
The only component that touches the Synapse. It hosts Axons, emits REGISTER / HEARTBEAT / DEREGISTER, routes inbound TASKs to the right Neuron, and exposes every dispatch primitive: fire-and-forget, dispatch_and_wait, capability routing, competitive bidding.
Engram Memory
Shared memory as a protocol citizen rather than a library you import. Recall and Imprint are Signals on the same bus, backed by InMemory, SQLite or Postgres - which means memory access shows up in your traces like everything else.
Effector Tools and side effects
Anything that reaches out of the system. An Effector services TOOL_CALL Signals and mirrors what it did into an Engram, so the record of a side effect is part of the run and not a line in a log file somewhere.
Receptors: where people come in.
A system nobody can talk to is not a product. A Receptor is an interface - a CLI, an HTTP API, a chat or voice surface - that funnels an outside request into the same dispatch trio every internal component uses. Same Signals, same traces, no special path for “the user-facing bit”.
One entry point
brain.py attaches Receptors and calls Dendrite.run(). That is the whole entry point - no separate CLI script, no second server, no drift between how you test the system and how it runs.
Interfaces are not special
A Receptor is caller-side and introduces no new wire types. Whether a TASK came from a terminal, an HTTP request or another Neuron, it is the same TASK - which is why Prism can show you a user-initiated run and an internal one side by side.
Glia: a policy card on each component.
An Axon, an Effector or an Engram can carry one Glia card. The card reads every signal entering and leaving its component and refuses, redacts or escalates what its policies match. Every violation emits an AUDIT record. There is no central policy process to route through.
Two-way
Each policy picks a direction (inbound, outbound or both) and the signal types it reads. The default is everything, both ways. The same IMPRINT can be checked by the Axon sending it and the Engram receiving it.
Retry is the policy's call
A deny can re-ask the Neuron with the refusal as a correction, resend the request behind a bad TOOL_RESULT or RECALLED, or refuse outright. Refusal is the default.
Off until you say so
Cards default to off. Run them in audit to see what would have been blocked, then switch to enforce. Existing brains are unaffected until a deployment opts in.
Scale is a URL change.
The Synapse is an adapter, not an architecture decision you have to make on day one. Your Neuron code does not know or care which one is underneath it.
In-process. Tests, prototypes, single-host demos.
Local TCP + NDJSON broker. cosmo synapse start boots it in a second.
The production default - the cleanest fit for the protocol's shape.
A durable, replayable log of every Signal that ever crossed the bus.
One CLI, one SDK, one spec.
cosmo
cosmo init scaffolds a project. cosmo synapse start boots a local broker. cosmo dispatch fires a TASK from the terminal. cosmo validate checks envelope conformance. One implementation, installable from pip.
The wire, not the language
Python is the single first-party SDK, and nothing about the protocol is Python. Any component that emits and accepts valid Signals is a participant on the bus - the envelope is the whole contract, whatever wrote it.
Read the spec
The envelope specification is short on purpose. If you want to write a Cosmonapse implementation in a third language, that page plus cosmo schema is everything you need. A first-party TypeScript SDK shipped during 0.1.x and was retired: two implementations meant every protocol change had to land twice before it could be called shipped, and the spec carries the language-agnostic claim better than a parity table did.
Learn by running something
Fourteen examples cover routing, bidding, retries, RAG, MCP tools, memory and full agents - each one a project you can clone and run rather than a snippet.
Core is the floor, not the ceiling.
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 →