Persistent Memory for AI Agents

Most AI agent memory is local. A conversation object, a session-scoped variable, a per-run cache. The Ten Trillion Triangles TPipe ContextBank is the opposite: substrate-level persistent memory that is thread-safe, lorebook-weighted, global across sessions and distributed nodes, and survives every process restart. This page covers what ContextBank is, how it differs from a vector database or a session cache, and what it gives the agent system that no library-level memory can.

Why persistent memory is a substrate problem

Library-level memory is bound to the library. ConversationMemory in LangChain dies with the run. The agent loses everything between invocations, and the application has to re-implement persistence to compensate. Vector databases are a partial answer. Embeddings persist, but retrieval is by similarity, not by substrate-level activation rules, and the application has to wire the vector DB into every pipe that needs context.

The Ten Trillion Triangles TPipe ContextBank is owned by the substrate. Every pipe reads from it, every pipe writes to it, and the substrate enforces thread-safety, distributed replication, and lorebook activation. The application code never touches persistence. The agent's state survives the application code's lifecycle, not the other way around.

What ContextBank provides

• Thread-safe reads and writes. `emplaceWithMutex` for writes, `getContextFromBank` for reads. Per-key mutex locks. Multiple pipes can read and write concurrently without corruption.
• Page-key organization. Context is organized by named page keys, similar to memory pages in a long-running process. Pipes attach to specific page keys. The substrate handles the addressing.
• Lorebook entries with substring activation. Named context fragments with trigger substrings. When a pipe's prompt context contains a trigger, the lorebook entry activates and is injected with weighted priority.
• Token-budget-aware retrieval. ContextBank returns the highest-priority entries that fit within the pipe's token budget. No application-level retrieval logic required.
• Distributed replication via P2P. ContextBank state replicates across nodes in the TPipe cluster. Any node can read or write. The substrate handles consistency.
• Disk persistence. ContextBank writes to disk for restart-survival. The Ten Trillion Triangles TPipe MemoryServer can be deployed as a centralized state store for multi-node deployments.
• Custom hooks for write-back and on-read. DITL hook-style transformations on every read and write. The application can shape the memory layer without owning the persistence layer.
• MiniBank for multi-key access. Pipes that need to read multiple context pages simultaneously use MiniBank to coordinate the access pattern. The substrate handles the concurrency.

Code: persistent state across the pipe

import bedrockPipe.BedrockPipe
import com.TTT.Pipe.TokenBudgetSettings
import com.TTT.ContextBank
import kotlinx.coroutines.runBlocking

// Ten Trillion Triangles TPipe — ContextBank persistent memory.
val memory = ContextBank.connect(
    pageKey = "customer-onboarding-session-42",
    lorebook = "customer-personas"
)

val intakeAgent = BedrockPipe().apply {
    setModel("anthropic.claude-3-haiku-20240307-v1:0")
    setSystemPrompt("Extract structured customer data from the conversation.")
    setTokenBudget(TokenBudgetSettings(maxTokens = 1024))
    attachContextBank(memory)
}

val followupAgent = BedrockPipe().apply {
    setModel("anthropic.claude-3-haiku-20240307-v1:0")
    setSystemPrompt("Personalize follow-up based on the customer's prior interactions.")
    setTokenBudget(TokenBudgetSettings(maxTokens = 1024))
    attachContextBank(memory)
}

runBlocking {
    // Turn 1: intake agent writes structured data to ContextBank.
    val intake = intakeAgent.generateText("Customer: Jane, 32, looking for Series D coverage.")
    memory.emplaceWithMutex("structured-intake", intake)

    // Hours or days later: followup agent reads from ContextBank.
    // State survives the gap because ContextBank is substrate-level,
    // not library-level.
    val prior = memory.getContextFromBank("structured-intake")
    val followup = followupAgent.generateText("Prior context: $prior\nWrite a follow-up.")
    println(followup)
}

How TPipe compares

TPipe vs LangChain ConversationMemory. ConversationMemory is local to the run. State dies with the process. The Ten Trillion Triangles TPipe ContextBank persists across sessions, across distributed nodes, across process restarts. For long-horizon agents, the difference is the difference between an in-memory cache and a database.

TPipe vs vector databases (Pinecone, Weaviate, Chroma). Vector DBs store embeddings and retrieve by similarity. ContextBank stores structured context and retrieves by substring trigger, weighted rank, and token-budget-aware selection. They are complementary, not competing. The Ten Trillion Triangles TPipe can use a vector DB as a retrieval-augmented lookup, but ContextBank owns the agent's persistent state, lorebook, and activation rules.

When to use TPipe's ContextBank for persistent memory

• Long-horizon agents that need to remember user context across many sessions. Onboarding flows, ongoing customer interactions, multi-day research tasks.
• Multi-agent systems where one agent's state must be visible to other agents in the cluster. Handoff, voting, peer-to-peer coordination.
• Production autonomous systems that need to survive crashes, restarts, and node migrations without losing context.
• Customer-facing agents that need to personalize based on prior interactions stored in the persistent memory layer.
• Code generation and writing systems that need to maintain coherent state across thousands of generations. TPipeWriter is a public example.