Ask an LLM-powered assistant the same question two days in a row and it will happily re-derive the answer from scratch, oblivious to the fact that it already solved this — for you, specifically — on Tuesday. That’s not a model limitation; it’s an architecture decision. A bare chat-completion call is stateless by design, and most applications built on top of one inherit that amnesia without ever deciding to.
The teams getting real compounding value from AI are the ones that made the opposite decision: knowledge accumulates. That’s the idea behind giving agents a second brain — and it’s three distinct capabilities working together, not one feature.
1. Episodic memory: agents that remember what happened
The first layer is memory attached to the agent itself — the decisions it made, the preferences a user expressed, the context of past sessions. MultiMind’s agents ship with persistent memory as a built-in property of the agent framework, not an add-on you wire up separately:
from multimind import OpenAIModel
from multimind.agents import Agent
from multimind.agents.tools import CalculatorTool
agent = Agent(
model=OpenAIModel(model_name="gpt-4o-mini"),
tools=[CalculatorTool()],
)
The practical difference is mundane and enormous at the same time: a support agent that remembers the customer’s environment from last week’s ticket, a research assistant that doesn’t re-summarize the same paper, an internal tool that stops asking the same onboarding questions. Every one of those is the same underlying property — state that survives the session. For the exact memory configuration options, see the SDK repo; the point here is that persistence is the default posture, not a project.
2. Portable context: memory that isn’t hostage to one provider
Memory attached to a provider’s thread API is memory you lose the day you switch providers — which quietly turns a technical convenience into vendor lock-in. MultiMind’s ModelSession takes the opposite approach: the conversation state belongs to your application, and the model behind it is a swappable detail. A live conversation can move from GPT to Claude to a local model with its context intact.
That matters for the second-brain idea specifically: a knowledge asset you’re accumulating over months should not be coupled to this quarter’s model choice. If the memory travels, the switching cost stays near zero — the same portability argument we made for vendor risk applies to accumulated knowledge even more strongly than to code.
3. Semantic knowledge: a second brain from your documents
The third layer is knowledge that didn’t come from conversations at all — your team’s documents, runbooks, decisions, and notes, made retrievable through the RAG pipeline. FAISS and Chroma work out of the box with document processing, and 40+ client-backed vector stores (Pinecone, Qdrant, Weaviate, Milvus, pgvector, LanceDB among them) are behind the same interface:
result = await (
pipeline
.load_documents(["Your documents here"])
.query("What did we decide about the retention policy?")
.generate()
.execute()
)
Combined with agent memory, this is the full second-brain shape: episodic memory for what the agent experienced, semantic retrieval for what the organization knows, and one governance layer over both.
The sovereignty angle: whose brain is it?
A second brain is only yours if you control where it lives. This is where the memory story connects to the sovereignty story: with local models via Ollama, the entire stack — the agent, its memory, the vector store, the documents — runs on your own infrastructure, offline if it has to. Accumulated organizational knowledge is exactly the kind of asset you don’t want resident in a third party’s storage under a third party’s terms. And because the same PII guard and audit trail wrap agent calls like any other model call, what flows into that memory is governed and logged the same way everything else is.
Where to start
The lowest-friction starting point is not a grand knowledge-management project — it’s one agent, with memory on, doing one recurring job where repetition is currently wasted (support triage and internal Q&A are the usual candidates). Let the memory accumulate for a few weeks, then look at what it knows. That’s the moment the second-brain framing stops being a metaphor.
Source and docs: github.com/multimindlab/multimind-sdk.