What Strands Agents already keeps

Agents keep conversation history through a conversation manager and can persist sessions. Durable facts across sessions and users are outside that scope.

Where Auld fits

Decorate recall and remember with @tool. On AWS you can also expose the Auld MCP server through a gateway so several agents share one governed tool endpoint.

ConcernStrands AgentsAuld
Current conversationYesNot needed
Facts across sessions and channelsYour codeYes
Which fact is current after a changeYour codeYes, with history
What was true on a dateYour codeYes (asOf)
Who may see a memoryYour codeIdentities and audiences
Source for each statementYour codeReturned with every memory

Implementation sequence

  1. Decorate tools

    Use @tool with docstrings that explain when to call them.

  2. Pass to Agent

    Agent(tools=[...]).

  3. Store keys safely

    Load the Auld key from your secrets manager, not code.

  4. Consider a gateway

    Centralize MCP access if many agents need memory.

Example

memory_client.py — shared helper
import os, requests

AULD = os.environ["AULD_API_BASE"]          # e.g. https://YOUR-AULD-HOST
HEADERS = {"Authorization": f"Bearer {os.environ['AULD_API_KEY']}"}

def auld_post(path: str, body: dict) -> dict:
    r = requests.post(f"{AULD}/v1/{path}", json=body, headers=HEADERS, timeout=30)
    r.raise_for_status()
    return r.json()

def remember(text: str, user_id: str, source_id: str, occurred_at: str) -> str:
    """Store a dated record for one user. Returns the job id."""
    return auld_post("records", {"sourceId": source_id, "text": text,
                                 "occurredAt": occurred_at, "author": user_id,
                                 "visibility": f"user:{user_id}"})["jobId"]

def recall(query: str, user_id: str, max_tokens: int = 2000) -> str:
    """Current memories with sources, formatted for a prompt."""
    res = auld_post("recall", {"query": query, "viewer": user_id, "maxTokens": max_tokens})
    return "\n".join(f"- {m['text']} ({m['sources'][0]['title']}, {m['sources'][0]['occurredAt'][:10]})"
                     for m in res["memories"]) or "No relevant memory."
Strands Agents wiring
from strands import Agent, tool
from memory_client import recall, remember

CURRENT_USER = "user_42"  # set per request

@tool
def recall_memory(query: str) -> str:
    """Recall facts about the current user before answering history questions."""
    return recall(query, CURRENT_USER)

@tool
def save_memory(fact: str, occurred_at: str) -> str:
    """Save a durable fact with the ISO time it happened."""
    remember(fact, CURRENT_USER, f"strands-{CURRENT_USER}-{occurred_at}", occurred_at)
    return "saved"

agent = Agent(tools=[recall_memory, save_memory])

Illustrative example · standard HTTP · check the framework’s current docs for exact signatures

Or connect the MCP server

If your Strands Agents setup can use MCP tools, point it at the Auld MCP endpoint instead of writing wrappers. The model gets remember, recall, forget and memory_status. Use wrappers when you need to inject the user id yourself or post-process results; use MCP for speed of setup.

Connect an MCP client →

Custom integration recipe using standard HTTP/MCP tools

  • This recipe wires Strands Agents’s own tool interface to the Auld REST API or MCP server; there is nothing Auld-specific to install.
  • Bind the viewer id from your authentication layer, not from model output.
  • Ingestion is asynchronous — poll the job before depending on a just-sent fact in tests.
  • Recall returns up to your plan’s token limit (8,000 on Pay as you go and Flex).

Frequently asked questions

Does this need Bedrock?

No. Auld is model-agnostic; use whichever model provider Strands is configured for.

Global user variable?

Shown for brevity. In a server, build the agent per request with the id captured in a closure.