// Roadmap

From 0.1.0 to a Stable 1.0.0.

0.1.11 is out - the protocol and SDK shapes are in place, and Effector joins them as the action layer. The 0.x line takes the six core primitives - Synapse, Dendrite, Neuron, Axon, Engram, Effector - 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 · shipped (0.1.11) - the start

Read the spec. Build the Dendrite by hand.

Out now as 0.1.11. 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.

What 0.1.x 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 prism, cosmo validate, cosmo completion (bash / zsh / fish)
  • Prism - a local browser frontend for monitoring a live Synapse, served by cosmo 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 router / TGI / vLLM, OpenAI, Anthropic, OpenAI-compatible hosts (Groq, OpenRouter, Together, Mistral), and any stdio MCP server wrapped as a Neuron
  • Axon.host - deferred Dendrite decorators (@AXON.host.on_agent_output / on_tool_call) that declare a node's chain behaviour in its Neuron's module and self-apply on announce
  • 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(...)
0.2.0 · next - solid barebones

The six 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
  • Axon output contract - validation gets a reject-and-repair path: @detects_output raises InvalidOutput(reason, hint) and the Axon re-asks its Neuron with the hint (bounded output_retries, CRITIQUE signals for doppler), with provider truncation (finish_reason="length") retried the same way - so open models that drift from an action schema are corrected at the Axon instead of by every harness (surfaced by example 15)
  • Structured output at the source - response_format / tools passthrough on the OpenAI-compatible Neuron providers, so the provider enforces the schema wherever it can
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
  • Prism - deeper statistics and cognition analytics on top of the five views that ship today, 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
Known limitations - 0.1.11

0.1.11 is a 0.1: the protocol and SDK shapes are in place, and 0.2.0 hardens them before anything is frozen. These are the edges we know about - each one points at the milestone that closes it.

  • Open models drift from strict action schemas. A harness that asks a plain-chat LLM for {"tool", "args"} JSON will eventually get shorthand variants or truncated objects back; today @detects_output can only transform or error, so every harness carries its own fallback parsing. Fixed by the Axon output contract (InvalidOutput + bounded output_retries, provider-side response_format / tools) in 0.2.0
  • Traces and Pathways are not yet frozen. The per-trace model (trace_id / parent_id, Pathway scopes, terminal semantics) is stable in practice but formally locks in 0.2.0
  • Networked transports need more mileage. The NATS and Kafka adapters work; heavy testing against real brokers is 0.2.0 scope
Priority order - 0.1.0 → 1.0.0

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

  1. 0.1.x - shipped (0.1.11): protocol drafted, both SDKs and the CLI released, every primitive present
  2. 0.2.0 - the six primitives solid with basic LLMs; the Axon output repair contract; 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: Prism deepened with cognition analytics, Brains and Brainwaves, deployment and infra integration, complex RAG / agent systems built consistently, Cosmonapse Cloud