// Roadmap

From 0.1.12 to a Stable 1.0.0.

0.1.12 is out - the protocol and SDK shapes are in place, and Effector joins them as the action layer. Everything between 0.1.12 and 0.2.0 goes into one thing: making tool calling dependable across models. 0.2.0 keeps Cosmonapse a local product but ships it as a container, and every envelope and protocol freeze lands in that line. 0.3.0 opens Cosmonapse Cloud on top of a frozen wire format. 1.0.0 is the stable foundation - the six primitives solid, Prism deepened, Brainwaves captured and replayed, Brain architectures shareable and deployable.

0.1.12 · shipped - the start

Read the spec. Build the Dendrite by hand.

Out now as 0.1.12. 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.1.12 → 0.2.0 · next - tool calling

Every release in this line fixes tool calls.

A single theme for the whole patch line. Tool calling is where open models break first: a harness asks for an action object and gets shorthand keys, prose around the JSON, or a truncated tail. Every release from 0.1.12 up to 0.2.0 goes at the parsers and the contract around them, so that a Neuron that drifts is corrected at the Axon instead of by every harness downstream.

What the 0.1.12 line means:

  • Tool-call parsing, hardened - the shorthand variants, wrapped and fenced JSON, and partial objects that real models emit get parsed instead of thrown away
  • Axon output contract - 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 Prism), with provider truncation (finish_reason="length") retried the same way
  • Structured output at the source - response_format / tools passthrough on the OpenAI-compatible Neuron providers, so the provider enforces the schema wherever it can
  • Effector call paths exercised - TOOL_CALL / TOOL_RESULT round trips tested against the model families the examples actually run on, not just the well-behaved ones
0.2.0 · containerized - and frozen

Still local. Now it ships as a container.

0.2.0 does not change what Cosmonapse is: it stays a local product you run yourself. What changes is how you get it standing up - a container image and a compose topology instead of a checklist. This is also the line where the wire format stops moving. Any envelope or protocol freeze happens here, so that everything built on top from 0.3.0 onwards has something stable underneath it.

What 0.2.0 means:

  • Containerized - Synapse, Prism, and the store backends as images with a compose topology, so a full local fabric is one command rather than a setup guide
  • Envelope freeze - the Signal envelope, the cognition signal family, and the versioning rules around them are locked
  • Pathways and traces set in stone - the per-trace model (trace_id / parent_id, Pathway scopes, terminal semantics) is frozen and relied upon
  • The six primitives solid - Synapse, Dendrite, Neuron, Axon, Engram, and Effector working end to end with basic LLMs at minimum
  • Heavy testing against NATS and Kafka - the networked paths exercised against real brokers in containers, not just memory transports
  • Agents on the wire - agent systems built from Claude and OpenAI models stress-testing the protocol: long traces, concurrent workflows, bidding under load, Engram-heavy agents. Every gap those workloads expose feeds back into the freeze before it closes
0.3.0 · future - Cosmonapse Cloud

The same fabric, hosted.

With a frozen envelope and a containerized runtime, the hosted product is the next step rather than a rewrite. 0.3.0 is the launch of Cosmonapse Cloud: managed Synapses, hosted Engram, and Prism as a service, speaking exactly the protocol the local product speaks. The local path stays first-class - Cloud is where you go when you would rather not run the brokers yourself.

What 0.3.0 means:

  • Managed Synapse - hosted transport with the same adapters and the same envelope
  • Hosted Engram - shared memory without standing up Postgres
  • Prism as a service - observability on a hosted fabric, no local port required
  • Local stays local - the same code runs against a self-hosted Synapse or a managed one, by URL

Timing here is honest rather than precise: Cloud moves when the project gets full-time attention.

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, Engram, and Effector from cosmonapse-core are solid
  • Prism - deeper statistics and cognition analytics on top of the views that ship today, with Brain development alongside Synapse development
  • Brainwaves - capture and replay a task or a set of tasks, and shareable Brain architectures - think Terraform, for agent fabrics
  • Infra integration - automated deployments and distributed setups wired into the same tooling, local or on Cloud
  • 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
Known limitations - 0.1.12

0.1.12 is a 0.1: the protocol and SDK shapes are in place, and nothing is frozen until 0.2.0. 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. This is the whole point of the 0.1.12 line: hardened tool-call parsing, the Axon output contract (InvalidOutput + bounded output_retries), and provider-side response_format / tools
  • 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
  • Setup is manual. Standing up a full local fabric means running the pieces yourself; the container image and compose topology land in 0.2.0
Priority order - 0.1.12 → 1.0.0

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

  1. 0.1.12 - shipped: protocol drafted, the Python SDK and the CLI released, every primitive present
  2. 0.1.12 → 0.2.0 - one theme: tool calling. Hardened parsers, the Axon output repair contract, provider-side structured output
  3. 0.2.0 - still local, now containerized. The envelope, the cognition signals, and the trace model freeze here; heavy testing against NATS / Kafka; real agents stress-testing the protocol before the freeze closes
  4. 0.3.0 - Cosmonapse Cloud: managed Synapse, hosted Engram, Prism as a service, on the frozen protocol. Moves when the project gets full-time attention
  5. 1.0.0 - strong foundation: Prism deepened with cognition analytics, Brains and Brainwaves, deployment and infra integration, complex RAG / agent systems built consistently