// Roadmap

From 0.1.14 to a Stable 1.0.0.

0.1.14 is out. The protocol and SDK shapes are in place, Effector is the action layer, and Glia puts a policy card on each component with an AUDIT record for everything it does. The rest of the 0.1.x line 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.

Shipped 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.14 · shipped - governance

A policy card on every component.

Out now as 0.1.14: the tool, guardrail and eval layer. A Glia card mounts on an Axon, an Effector or an Engram and reads every signal crossing that component, both ways. There is no orchestrator and no central policy process.

What 0.1.14 ships:

  • Glia policy cards - each policy has a direction, the signal types it reads, a verdict (allow, deny, redact, escalate) and a retry (reask, resend, none). Declared as JSON or as decorators on the card
  • Modes - off by default, audit to record what would have been blocked, enforce to apply it. Existing brains are unaffected
  • AUDIT - a new signal type, one record per policy or repair event, across security, eval, tool, reliability and governance domains
  • The correction repair loop - one bounded loop in the Axon for policy refusals, tool arguments that fail their schema, and unclaimed output under the opt-in strict_output
  • Trace-wide limits on the Dendrite, in component and trace modes
  • Removed - THOUGHT_DELTA. Nothing in the SDK produced it. Observe repair progress with @dendrite.on_audit instead

Not in 0.1.14: signing. Envelopes are not signed, so a policy on directed.id stops mistakes, not an attacker on a shared broker. Per-component keys are the next phase of Glia and are not yet scheduled.

0.1.x → 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 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.x 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 - the reject-and-repair path shipped in 0.1.14: under strict_output, unclaimed output raises InvalidOutput and the Axon re-asks its Neuron, bounded, with an EVAL_RETRY AUDIT record per attempt. Still to come: 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 · in closed testing - 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

Cloud is live now in closed testing, alongside the Pro and Enterprise tiers. 0.3.0 is when it opens beyond that group.

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.14

0.1.14 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. 0.1.14's repair loop re-asks the Neuron when output or tool arguments fail, but the parsers still miss some shapes. Hardened parsing and provider-side response_format / tools are the rest of the 0.1.x line
  • Signals are not signed. Glia policies read directed.id as a claim. Treat a shared broker as a trusted zone until signing ships
  • 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.14 → 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.14 - shipped: Glia policy cards, AUDIT, the correction repair loop, trace-wide limits
  3. 0.1.x → 0.2.0 - one theme: tool calling. Hardened parsers, provider-side structured output
  4. 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
  5. 0.3.0 - Cosmonapse Cloud: managed Synapse, hosted Engram, Prism as a service, on the frozen protocol. Live now in closed testing
  6. 1.0.0 - strong foundation: Prism deepened with cognition analytics, Brains and Brainwaves, deployment and infra integration, complex RAG / agent systems built consistently