Roadmap — Cosmonapse

v0.1 · current — manual SDK

Read the spec. Build the Dendrite by hand.

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 who want to shape what their workflow looks like.

What v0.1 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)
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 (partial parity) — envelope, builders, Axon, Dendrite, MemorySynapse, NatsSynapse, in-memory RegistryStore, and the express / MCP / unified neuron() factory. Not yet in TypeScript: DevSynapse, connectSynapse(url), LifecycleHooks, Ollama / HuggingFace neuron sources, KafkaSynapse, SQLite / Postgres RegistryStore, and Engram. Those are tracked in packages/ts-sdk/PORTING_STATUS.md and slated for v0.2 — until then, the Python SDK is the reference implementation.

v0.2 · next — Axon as MCP server

Any agent, anywhere, via MCP.

The Axon ships as an installable MCP server. An arbitrary LLM-driven agent — running in Claude, Cursor, on EC2, or anywhere — can talk to a remote Dendrite over HTTP without importing any Python from Cosmonapse. The Neuron’s interface stays identical; only the transport changes.

What v0.2 adds:

Axon-as-MCP-server (replaces in-process attach for remote agents)
cosmo dev cortex and cosmo dev dendrite scaffold subcommands
Durable REGISTER replay on join (late-joining peers catch up)
TypeScript SDK → full parity — DevSynapse, LifecycleHooks, KafkaSynapse, SqliteRegistryStore / PostgresRegistryStore, and provider-backed Neuron factories

v0.3 · next — declarative router

Describe the workflow. Generate the Dendrite.

A higher-level config layer compiles to a Dendrite. Developers describe workflow rules in a DSL — the SDK generates the orchestration code. The manual Dendrite remains available for cases that need full control; the declarative form is for the 80% of patterns that look the same.

What v0.3 adds:

Workflow DSL covering dispatch, bidding, critique, escalation, consensus
Code generator that emits a Dendrite from the DSL
Hot-reload of workflow config in cosmo synapse start

v0.4 · future — router agent

A Neuron that builds and tunes Dendrites.

A Cosmonapse Neuron whose capability is build_dendrite. It reads the Doppler stream (cost, agent load, trace outcomes), observes which routing decisions worked, and tunes Dendrite config at runtime.

This is only possible because the protocol is self-describing — capabilities declared via REGISTER, neuron IDs named in TASK Signals, task flow visible in the Doppler stream. The router-builder Neuron is itself a participant: same protocol, same Axon, same Synapse.

What v0.4 unlocks:

Self-tuning Dendrites that adapt routing weights based on observed outcomes
Automated capacity planning — Neurons spun up or down based on load
Adversarial critique workflows that run themselves
Cross-Brain federation — Dendrites discovering each other’s capabilities

Out of scope for v0.1

What we deliberately are not shipping.

Every item below is a thing Cosmonapse will not build in v0.1, and the reason it’s held back. The point is to keep the surface small while the protocol stabilises.

Excluded	Reason
Hosted platform / cloud control plane	Adds operational complexity before the protocol is proven
Reference router implementation	Would bake in routing assumptions developers should own
Federation across namespaces	Post-v0.1 — v0.4 brings protocol-level support
Billing / chargeback beyond cost annotation	The envelope carries cost_micro_usd; products on top can add billing
Axon as MCP server	Ships in v0.2 — in-process Axon ships first
Declarative router DSL	Ships in v0.3 — manual Dendrite comes first
GUI for the Doppler	Developer’s own visualisation — not Cosmonapse’s job
CostStore / LatencyStore / TraceStore	Developer-specific schemas; SDK exposes the raw envelope stream and stops there

Build order — v0.1

The order of operations matters. Each item depends on what came before.

Envelope types + codec (Pydantic) — foundation everything builds on
MemorySynapse
Axon — agent-side tool
Dendrite — synapse-side connector + orchestration primitives
RegistryStore — memory / SQLite / Postgres backends
NATS + Kafka Synapses (lazy-imported)
DevSynapseServer + DevSynapse + cosmo synapse start memory — proves the “first five minutes” rule across processes
LifecycleHooks — on_connect / on_refresh / on_schedule