Agentic Layers · Memory SDK
Write a lesson when a run finishes. Retrieve the relevant ones before the next call. The primitive underneath self-learning agents, self-improving environments, and adaptive tool routers.
import mubitmubit.init(agent_id="my-agent") # reads MUBIT_API_KEY from envcontext = mubit.recall(query="user wants JSON") # before each callmubit.remember(content="tool X failed on type Y", intent="lesson") # after each run
01 · SELF-LEARNING AGENTS
Every run writes back what worked, what didn't, and the context that shaped it. The next run retrieves the relevant lessons before calling the model. No retraining, no prompt rewrites.
02 · SELF-IMPROVING ENVIRONMENTS
An IDE, a CRM, a support console — when actions inside it write lessons back to memory, the environment learns what users actually want. The next session opens with the right defaults, the right shortcuts, the right surfaced fields.
03 · TRACEABLE DECISIONS
Every call records the lessons it retrieved, the input, and the output in one record. Open any past run and see exactly which lessons drove the result.
Two functions — write and retrieve — over a managed memory store. Intelligence, Actions, and Gateway are all composed on top of it. You can compose it too.
Writes queue to a worker and return immediately. Reads run off the critical path — memory never blocks the loop your agent is running in.
Not in front of OpenAI, Anthropic, Bedrock, or Vertex — beside them. No wrapping, no routing required.
LangGraph, custom orchestrators, a single Python script — the SDK doesn't care what's around it.
Same SDK, same wire format. Run the memory plane in your VPC if traffic can't leave.
Two calls: retrieve relevant lessons before the model runs, write what the run learned after. No vector database — embeddings, storage, and ranking are managed.
import os
import mubit
# Persistent memory for an agent.
mubit.init(
api_key=os.environ["MUBIT_API_KEY"],
agent_id="my-agent",
)
# Read relevant lessons
context = mubit.recall(
query="user wants a JSON response",
limit=5,
entry_types=["lesson", "rule"],
)
# Write what was learned from this run.
mubit.remember(
content="Tool X failed for type Y; route to Z.",
intent="lesson",
lesson_type="failure",
)Because it does one thing — give your agent execution memory — and nothing else. You compose it into whatever you're building, instead of buying a finished product around it.
Intelligence turns captured lessons into observability. Actions proposes prompt and skill updates from them. Gateway uses the same memory store on the inference path. Same primitive underneath.
Short, retrievable summaries of what happened in a run — the input that triggered the agent, the decision it made, the outcome, and any tags you attach. Mubit handles embedding and ranking; you just write the lesson.
No. Memory ships with managed embeddings + ANN retrieval. Point the SDK at your agent ID and you're done — no separate index to provision, scale, or backup.
A blend of semantic similarity to the current context, recency, and tag match. You can override the ranker per-call if you need custom weighting — e.g. boost failures, demote stale lessons.
Writes are non-blocking — they queue to a background worker. Reads stay off your agent's critical path too, so memory never blocks the loop it's running in.
Either. Use Mubit Cloud for the fastest setup, or self-host the memory plane in your own region. Same SDK, same APIs, same wire format — switch any time.
Lessons carry arbitrary metadata. Pass user_id, tenant_id, env, or anything else to write(), then filter on the same keys in retrieve() — Mubit constrains the result set automatically.