// Roadmap

From 0.1.0 to a Stable 1.0.0.

0.1.0 was the start: the protocol and SDK shapes are in place. The 0.x line takes the five core primitives - Synapse, Dendrite, Neuron, Axon, Engram - from shapes to solid, freezes pathways and traces, and then stress-tests the protocol with real agents. 1.0.0 is a strong protocol foundation you can build complex RAG and agent systems on, observed through Doppler Prism, captured and replayed as Brainwaves, and deployed as shareable Brain architectures.

0.1.x · current (0.1.5) - the start

Read the spec. Build the Dendrite by hand.

The first public release. The developer reads the envelope spec, writes an Axon and Dendrite using the SDK primitives, chooses a Synapse adapter, and wires their own orchestration logic. Full control, full complexity, appropriate for early adopters. The Python SDK is the complete reference implementation; as of 0.1.5 the TypeScript SDK is at full parity.

What 0.1.0 ships:

  • Envelope codec (Pydantic) and cosmo validate
  • Axon - agent-side tool, in-process
  • Dendrite - synapse-side connector + all orchestration primitives
  • RegistryStore - memory / SQLite / Postgres backends
  • MemorySynapse, DevSynapse (TCP+NDJSON), NatsSynapse, KafkaSynapse
  • cosmo init (project scaffolding), cosmo synapse start|view|stop, cosmo doppler, cosmo validate, cosmo completion (bash / zsh / fish)
  • Prism - a local browser frontend for monitoring a live Synapse, served by cosmo doppler --prism. A hero form picks the Synapse URL + namespace, then an animated view streams every Signal on the wildcard subject over a WebSocket in real time
  • LifecycleHooks - on_connect / on_refresh / on_schedule
  • connect_synapse(url) - build + connect a Synapse in one call
  • Neuron provider factories - Ollama, HuggingFace / vLLM (via httpx)
  • Engram (shared memory) - RECALL / IMPRINT signals, EngramBinding + EngramClient, and three backends (InMemory / SQLite / Postgres)
  • Pathway - per-trace event handle with three consumption shapes (await pw.wait(), @pw.on(...), async for sig in pw) plus scope="terminal" for the decentralised pattern
  • Cognition signal family - PLAN, THOUGHT_DELTA, TOOL_CALL, TOOL_RESULT, MEMORY_APPEND, CRITIQUE, ESCALATION, CONSENSUS, CONTEXT_SYNC, each with a matching emit_* / on_* pair
  • Capability-routed dispatch + competitive bidding - dispatch(capabilities=...) with queue-group load-balancing, and dispatch_offer(...) running TASK_OFFER / BID / TASK_AWARDED with first_bid, lowest_cost, or highest_confidence selection
  • Dispatch sugar - dispatch_and_wait(...) and dispatch_and_subscribe(...)
  • TypeScript SDK - full parity as of 0.1.5: envelope, builders, Axon, Dendrite (Pathway dispatch, offers / bidding, interactive cognition), all four Synapse adapters with connectSynapse(url), all three RegistryStore backends, LifecycleHooks, the LLM / MCP / unified neuron() source factories, and Engram.
0.2.0 · next - solid barebones

The five primitives, working end to end.

Take every core primitive from shipped to dependable: barebones functionality that holds up with at least basic LLMs behind the Neurons, an observability surface that keeps up, and the trace model locked so everything after can rely on it.

What 0.2.0 means:

  • Synapse, Dendrite, Neuron, Axon, and Engram at barebones functionality - working end to end with basic LLMs at minimum
  • Doppler grows up - multi-tab views, filters, and the workflow of actually watching more than one thing at once
  • Pathways and traces set in stone - the per-trace model (trace_id / parent_id, Pathway scopes, terminal semantics) is frozen and relied upon
  • Heavy testing against NATS, Kafka, and the other components - the networked paths exercised against real brokers, not just memory transports
0.3.0 · future - agents on the wire

Stress-test the protocol with real agents.

With the primitives solid, put real agents on the fabric and see what bends. A mix of fixing and development: every gap an agent workload exposes feeds straight back into the protocol and SDKs.

What 0.3.0 means:

  • Agent systems built from Claude and OpenAI models running over the protocol - not just single LLM calls
  • Stress testing: long traces, concurrent workflows, bidding under load, Engram-heavy agents
  • Fixes and refinements driven by what those workloads expose - development continues where agents demand it
1.0.0 · target - stable

A strong protocol foundation.

1.0.0 is the point where the foundation is strong enough to disappear: you think in terms of the system you are building, not the protocol underneath it.

What 1.0.0 means:

  • Strong protocol foundation - Synapse, Dendrite, Neuron, Axon, and Engram from cosmonapse-core are solid
  • Doppler Prism - basic observability and statistics, with Brain development alongside Synapse development. Maybe "Brainwaves": capture and replay a task or a set of tasks. Shareable Brain architectures - think Terraform, for agent fabrics
  • Infra integration - automated deployments, distributed setups wired into the same tooling
  • The success criterion - consistently building complex RAG LLM / agent systems on Cosmonapse. The capability for agents is already there; 1.0.0 is when doing it reliably is unremarkable
  • Cosmonapse Cloud - all of it available hosted. Further out deliberately: this moves when the project gets full-time attention
Priority order - 0.1.0 → 1.0.0

The order matters. Each milestone lands on the baseline the last one established.

  1. 0.1.0 - the start: protocol drafted, SDKs shipped, every primitive present
  2. 0.2.0 - the five primitives solid with basic LLMs; Doppler multi-tab + filters; pathways and traces set in stone; heavy testing against NATS / Kafka
  3. 0.3.0 - agents from Claude and OpenAI stress-testing the protocol; fixing and development in tandem
  4. 1.0.0 - strong foundation: Doppler Prism observability, Brains and Brainwaves, infra integration, complex RAG / agent systems built consistently, Cosmonapse Cloud