Changelog Overview

User-visible Mubit documentation and integration updates.

This changelog tracks user-visible Mubit changes — SDK releases, API and runtime behavior, framework integrations, and documentation.

2026-07-16 — SDKs v0.12.0

• Bi-temporal writes everywhere: remember(..., occurrence_time=...) forwarded by the typed helper in Python and JavaScript (Rust already had it).
• Recall parity with the wire: budget, rank_by, explain, min_timestamp/max_timestamp, and evidence_only forwarded by the typed recall in all three SDKs.
• Typed circuit_break, record_step_outcome, optimize_prompt, optimize_skill in Python/JS.
• Run scoping: with client.run(...) (Python, sync + async), client.withRun(...) (JS), client.run_scope(...) + end_with_reflect() (Rust).
• Receiver-side handoffs: receive_handoffs(agent_id=...) inbox and handoff(..., await_verdict=True) verdict polling.
• remember(..., share="run"|"session"|"global") scope alias ("org" is rejected — org scope is promotion-gated); record_outcome(..., idempotency_key=...) in all three.
• Rust: raw control ops move to client.advanced(); the flat delegates are deprecated.
• Fixes: Rust record_step_outcome was mis-wired to the run-level outcome endpoint; the published JS CommonJS entry (index.cjs) was syntactically broken; Python gRPC enum normalization restored.

2026-07-15 — SDKs v0.11.0 · Runtime v0.11.0

SDKs (Python, JavaScript, Rust) — v0.11.0

• Proto contract sync: the bundled control.proto now matches the server contract exactly, adding the evidence_only query field (return retrieved evidence without answer synthesis) to the typed gRPC surface.

Runtime v0.11.0 — continual learning on by default

• Seven continual-learning features are now enabled by default on hosted instances: bi-temporal supersession, relevance-gated lesson injection, sleep-time consolidation, workflow induction, guardrail distillation, shadow-gated scope promotion, and write-time lesson reconciliation. Each can be disabled per instance.

2026-06-05 — SDKs v0.10.0 — mubit.learn loop closure

• Python — mubit.learn outcome attribution and context fetching hardened: lesson injection no longer silently no-ops on slow context fetches (the timeout is now configurable), feedback() reliably credits the entries recalled for the current span, and automatic capture never fabricates outcomes.
• JavaScript & Rust — the learn loop is closed in both SDKs: feedback() credits recalled entries and the context-fetch timeout is configurable. (JS/Rust learn covers injection + loop closure; automatic trace ingest remains Python-only.)
• Hermetic learn test suites added for JavaScript and Rust.

2026-06-04 — SDKs v0.9.0 · Runtime v0.7.0

SDKs (Python, JavaScript, Rust) — v0.9.0

• Contract and proto sync across all three SDKs (continual-learning alignment; gRPC dependency bump). PrewarmRun exposed in the typed core gRPC surface.

Runtime v0.7.0 — retrieval accuracy

• Major retrieval-accuracy release: exact reranking is on by default, with improved cross-run fusion and sparse recall. No API changes required to benefit.

2026-06-03 — Faster cold starts: PrewarmRun

• New PrewarmRun RPC and POST /v2/core/runs/:run_id/prewarm route warm a run's index ahead of the first query, cutting first-query latency on cold or recently-evicted runs. Exposed across the SDKs.

2026-05-25 — SDKs v0.8.0 · Runtime v0.6.3

SDKs (Python, JavaScript, Rust) — v0.8.0

• Version bump consolidating the learned(), include_step_outcomes, and environment-tag work below into a single release across all three packages.

Retrieval ranking fix

• Cross-run global lessons no longer crowd out results specific to the current run, and knowledge-confidence is now factored into answer synthesis.

Integrations

• @mubit-ai JavaScript integration packages published at v0.7.0.

2026-05-22 — Runtime v0.6.2 — Environment tags, knowledge confidence, verified-in-production, learned()

• Environment tags — attach semantic environment tags to lessons and facts in TYPE:NAME:VERSION form (e.g. ["lang:python:3.12", "framework:langchain:0.3"]) so retrieval can prefer evidence from a matching stack. Available as the env_tags field on remember/ingest.
• Knowledge confidence — query evidence now carries a knowledge_confidence score that feeds ranking and the synthesis prompt.
• Verified-in-production — record_outcome(verified_in_production=True) marks an outcome as confirmed in production and gives the associated entries a retrieval boost.
• learned() — a convenience helper across all three SDKs for storing a production-tested lesson in one call. Also exposed as the mubit_learned MCP tool.

2026-05-19 — SDK: step-outcome-aware reflection

• The SDK reflect surface gained the include_step_outcomes option, so reflection can fold per-step outcome signals into lesson extraction. (Over the typed Python helper this remains a wire-level field — pass it through the low-level control op; the JS/Rust clients accept it directly.)

2026-04-27 — Console billing + integration updates

• Console (hosted) — the dashboard gained a usage and credit-balance view.
• Python integration packages published at v0.5.2 / v0.5.3 for SDK v0.7.0 compatibility.
• New example: Google ADK BigQuery agent with Mubit memory.

2026-04-24 — Streaming events, resilience & SDKs v0.7.0

Real-time event streaming

• Pub/sub streaming — subscribe to control and core events over SSE or gRPC server-streaming, with a consistent event shape across both transports and automatic cleanup when a subscriber disconnects.
• Reflection fix — a freshly reflected lesson now returns its lesson_id directly, so you no longer have to re-list lessons to correlate it.
• Drift monitoring can track a registered agent's objective and fold in per-step outcomes.

Resilience & durability

• The service now self-heals from transient infrastructure blips (e.g. a cache or coordinator restart) without manual intervention.
• Agent prompt-version history now persists across service restarts. Additive — no wire change, no new configuration.

SDKs (Python, JavaScript, Rust) — v0.7.0

• Normalized pub/sub events: payloads and enum values decode to consistent strings, so a streamed event reads the same shape regardless of transport (for await … of client.subscribe(...) in JS; streamed events in Python and Rust).

2026-04-23 — Production hardening + new adapters

Reliability

• Stronger availability and durability defaults: readiness/liveness health checks, graceful shutdown that flushes pending writes, configurable CORS and request timeouts, and control-plane retry backoff.

Integrations

• Python mubit-langchain and mubit-llama-index memory/store adapters published (integrations-python v0.5.1).

2026-04-21 — SDKs v0.6.0 — Automatic retries + Run Monitor

• Automatic retries — all three SDKs now retry transient transport failures and 5xx responses with exponential backoff and jitter, tunable via MUBIT_RETRY_ATTEMPTS / MUBIT_RETRY_BASE_MS / MUBIT_RETRY_CAP_MS / MUBIT_RETRY_JITTER. See Retries and idempotency.
• Run Monitor — a new GetRunSignal op surfaces a per-run health signal (e.g. looping or drift) that agents can poll mid-run.

2026-04-19 — Grouped option builders + more integrations

• SDKs introduce grouped metadata structures and fluent builders for Remember and Archive options, so optional fields (metadata, hints, lesson attributes, lane, idempotency key) are set without long positional argument lists.
• New integrations for Agent Lightning and AutoGen.

2026-04-18 — AlreadyExistsError for HTTP 409

• The SDKs now raise a dedicated AlreadyExistsError (a subclass of ValidationError) on 409 Conflict — e.g. creating a project, agent, or skill whose id already exists — so duplicate-create can be caught distinctly from other validation failures. See Errors.

2026-04-17 — v0.6.0 — Flat client surface (breaking)

SDKs (Python, JavaScript, Rust)

• Every control-plane operation now lives directly on Client. Call client.create_project(...), client.set_prompt(...), client.optimize_prompt(...) — the .control. step is gone.
• High-level helpers (remember, recall, checkpoint, reflect, record_outcome, …) are unchanged and continue to wrap the 10 identically-named raw ops with session resolution and richer defaults. Helper names win over the raw ops at name-collision sites.
• Admin and low-level storage ops remain under client.auth.* and client.core.*.
• Migration: global find-and-replace client.control. → client. and re-run tests. Three Core↔Control overlaps (batch_insert, create_session, delete_run) now resolve to the control version at client.<op>(); call client.core.<op>() explicitly for the core variant.
• The Rust SDK also gains typed methods for 34 previously-missing control ops (Projects, Agent Definitions, Skills, Prompts, Sessions, Run History, activity listing/export, record_step_outcome, get_run_ingest_stats) — Rust is now at parity with Python and JavaScript.

All three packages ship at v0.6.0.

Version compatibility

When upgrading mubit-sdk to 0.6.0, upgrade the framework integration packages to their matching releases. The Python adapters all declare mubit-integration-base>=0.5.1, which in turn pins mubit-sdk>=0.6.0, so a mismatched upgrade will fail at install time rather than at runtime.

Recommended upgrade flow:

# Python
pip install --upgrade mubit-sdk==0.6.0 \
  mubit-integration-base==0.5.1 \
  mubit-langgraph==0.5.1 mubit-langchain==0.5.1 \
  mubit-crewai==0.5.1 mubit-adk==0.5.1 \
  mubit-agno==0.5.1 mubit-llama-index==0.5.1
 
# JavaScript
npm install @mubit-ai/sdk@0.6.0 \
  @mubit-ai/langgraph @mubit-ai/ai-sdk @mubit-ai/mcp
 
# Rust
cargo add mubit-sdk@0.6.0

2026-04-17 — Managed resources + Project-first console

New API documentation

• Projects, Agent Definitions, Skills, Prompts are now documented as first-class managed resources. See Projects, Agents, Skills, Prompts.
• Prompt and Skill version lifecycle — candidate → active promotion, LLM-powered optimization, version diff — are covered end-to-end.
• New recipe: Prompt Optimization Lifecycle — record outcomes → optimize → review diff → activate → rollback.
• Control HTTP reference expanded with full route tables for /v2/control/projects/*, /v2/control/projects/agents/*, /v2/control/skills/*, /v2/control/prompt/*, and /v2/control/sessions/*. See Control HTTP — Managed resources.
• Control gRPC reference expanded with the matching RPC groups (CreateProject/..., SetPrompt/OptimizePrompt/ActivatePromptVersion/GetPromptDiff, CreateSkill/OptimizeSkill/..., CreateControlSession/...). See Control gRPC — Managed resources.

Deprecations (no runtime impact)

• Goals, Actions, and Decision Cycle routes (/v2/control/goals/*, /v2/control/actions/*, /v2/control/cycles/*) are now formally marked deprecated in State management. Existing deployments continue to work; new integrations should track goals/actions in external task and orchestration systems (Linear, LangGraph, CrewAI) and feed resulting lessons / outcomes into Mubit.
• Variables and Concepts remain supported.

Console

• The user console is now organized around Projects as the top-level concept, with Agent Cards, Prompt versioning, Skill versioning, per-project Memory, Sandbox, Logs, and Settings. The SDK surface is unchanged — the new resource model is what the console renders against.

2026-04-02 — Security hardening

• Stricter API-key validation and safer SDK install behavior (npm ignore-scripts).

2026-03-25 — Runtime v0.5.2 — Read-path quality

• Retrieval and consistency fixes across the read path: a rank_by ranking parameter (relevance / freshness / balanced), an explain mode that returns per-evidence score components, temporal decay in scoring, a context recency fallback, lessons/health consistency, promotion dedup, and activity filtering — with matching SDK field alignment. All additive.

2026-03-23 — v0.5.1 (Hindsight features + scaling)

New SDK features

• Temporal range queries — the min_timestamp / max_timestamp query fields filter evidence by when events occurred, not when they were ingested. They are wire-level fields, not typed recall() kwargs — pass them through the low-level query op (client.advanced.query({..., "min_timestamp": ..., "max_timestamp": ...})). See temporal queries.
• Occurrence time tracking — the occurrence_time field records when an event happened, separate from ingestion time. It travels in item metadata, not as a typed remember() kwarg — set it via remember(metadata={"occurrence_time": ...}) or on the raw ingest item (client.advanced.ingest({...})). See occurrence time.
• Search budget control — the budget query field ("low" | "mid" | "high") controls the latency/quality tradeoff. It is a wire-level field, not a typed recall() kwarg — pass it through the low-level query op (client.advanced.query({..., "budget": "mid"})). See search budget.
• Staleness metadata — Query evidence now includes is_stale and superseded_by fields. Stale entries are automatically deprioritized in ranking. See staleness detection.
• Mental model entry type — remember(intent="mental_model") stores consolidated entity summaries that are prioritized over raw facts in context assembly. See mental models.

Server improvements

• Per-run disk-backed index pools — memory stays bounded regardless of data volume.
• LLM telemetry with Prometheus metrics (mubit_llm_calls_total, mubit_llm_tokens_total, mubit_llm_call_duration_seconds).
• Connection pooling, write tuning, and client-side LLM rate limiting for 200+ concurrent agent workloads.
• Event stream trimming, storage health monitoring, and disk usage metrics.
• Sanitized error messages — no internal implementation details exposed to SDK clients.
• New xlarge instance plan tier (8 CPU, 16 GiB) for high-throughput workloads.

No breaking changes

All new fields are optional with sensible defaults. Existing code continues to work without modification.

2026-03-16 — Documentation sync

• Added SDK Configuration Reference page covering env vars, transport selection, and endpoint defaults.
• Added gRPC Transport Guide explaining when to use gRPC vs HTTP, endpoint configuration, and TLS.
• Added Activity & Audit Trail documentation for listActivity, exportActivity, and appendActivity.
• Added missing SDK methods to the SDK methods reference: activity, ingest job tracking, run management, context snapshot.
• Added missing HTTP routes to the Control HTTP reference: activity, runs, ingest stats, heartbeat, context/snapshot.
• Added missing gRPC RPCs to the Control gRPC reference: full variable, concept, action, and cycle RPCs.
• Added core route reference to Core Direct Lanes: SDM, scratchpad, sessions, storage, ACL, PubSub.
• Added Troubleshooting / FAQ page covering common issues.
• Corrected the GitHub repository links on the Framework Integrations page.

2026-03-14 — v0.4.1 (JS SDK patch)

• Fixed keepCase gRPC field casing in the JavaScript SDK to preserve proto field names.

2026-03-14 — Integration packages v0.1.0

• Published framework integration packages:
  • Python: mubit-crewai, mubit-langgraph, mubit-langchain, mubit-adk
  • JavaScript: @mubit-ai/langgraph, @mubit-ai/ai-sdk, @mubit-ai/mcp
• TLS enabled on api.mubit.ai and api.dev.mubit.ai.

2026-03-13 — v0.4.0 (MAS Features)

• Added step-level outcome recording: RecordStepOutcome RPC, /v2/control/step_outcome HTTP route, record_step_outcome() SDK helper. Records per-step process reward signals (signal, rationale, directive hint) for dense RL within a run.
• Added lane-scoped memory: lane field on IngestItem, lane_filter on queries and context assembly, shared_memory_lanes on agent registration. Enables multi-agent memory isolation within a shared run.
• Added step-wise reflection: step_id, last_n_items, and include_step_outcomes fields on ReflectRequest for targeted, incremental lesson extraction scoped to recent evidence or a specific step.
• Added auto-extraction in mubit.learn: heuristic extraction of rules, lessons, preferences, and facts from LLM responses without an extra LLM call (auto_extract=True in learn config).
• New cookbook: Step-Level Outcomes and Process Rewards.
• New cookbook: Lane-Scoped Multi-Agent Memory.

2026-03-10 — SDK: archive, dereference & activity audit

• Added archive and dereference — store a full artifact (long document, transcript, plan) and pull it back verbatim by reference, instead of round-tripping it through memory.
• Added the ListActivity and ExportActivity RPCs (/v2/control/activity, /v2/control/activity/export) for a chronological, filterable browse and export of a run's memory/activity. These are HTTP/gRPC surfaces, not typed SDK helpers.

2026-03-05 — Reflection, lessons & multi-agent auto-capture

• Reflection & lessons — reflect() extracts reusable lessons from a run's evidence, with lesson listing/deletion and the run→session→global promotion ladder.
• Auto-capture for mubit.learn — three interception tiers that capture lessons from existing LLM calls (Anthropic, OpenAI, LiteLLM, Google GenAI) without rewriting agent code.
• Control-plane primitives for agent registration, handoffs/feedback, and checkpoint for compaction-safe continuity.

2026-02-22 — SDKs v0.1.0 — Initial release

• First public Python, JavaScript, and Rust SDKs, each speaking both gRPC and HTTP with a shared operation contract and MUBIT_ENDPOINT / MUBIT_API_KEY configuration.
• Backed by the core retrieval engine: high-performance (HNSW) semantic search, run-scoped isolation via run_id, and durable persistent storage, with the control-plane memory primitives remember / recall / get_context.

2026-02-20 — Documentation

• Launched the SDK-first documentation site, including a full SDK method catalog that maps every operation across the Python, JavaScript, and Rust method names.
• Added the first cookbook guides — Event-driven agents and Branching memory — plus coverage of linked runs (include_linked_runs, link_run / unlink_run) and control event subscriptions.

Next steps

• Review SDK onboarding at /.
• Review API mapping at Control HTTP reference.