Amazon Bedrock AgentCore Runtime + Memanto

Amazon Bedrock AgentCore Runtime sessions are ephemeral — they terminate on inactivity and reprovision fresh environments. The memanto-agentcore package adds durable memory keyed to stable user identity (not runtimeSessionId), using the same recall → execute → retain loop as other Memanto framework adapters.

Cross-session recall

before_turn() runs semantic recall before your Bedrock call so a new runtime session still sees prior context.

Automatic retention

after_turn() stores each turn to Memanto (async by default so responses are not blocked).

Stable identity

Memory is scoped to tenant + user_id + agent_name — never to ephemeral sessionId.

Fail-open recall

If Memanto is unavailable, recall returns empty context and your agent continues.

How It Works

AgentCore invokes your handler(event)
        │
        ▼
  MemantoRuntimeAdapter.before_turn()  →  Memanto recall (Moorcheh)
        │
        ▼
  your agent_callable(payload, memory_context)  →  Bedrock / tools
        │
        ▼
  MemantoRuntimeAdapter.after_turn()   →  Memanto remember

Memanto does not replace AgentCore or Bedrock. You deploy your handler on AgentCore Runtime; the adapter only wraps each turn with memory I/O against Moorcheh. Default Memanto agent id (memory namespace):

tenant-{tenant_id}-user-{user_id}-agent-{agent_name}

Only [A-Za-z0-9_-] are allowed in Memanto agent ids. The readable form above is used only when it maps back to exactly one (tenant_id, user_id, agent_name): every part already fits that charset, and the -user- / -agent- delimiters each appear exactly once. Any other identity (emails, dotted or non-Latin usernames, parts that contain a delimiter, or ids longer than 64 characters) maps to a 64-character SHA-256 hex id of the three parts instead, so two different identities never share a namespace. Without a tenant, the tenant part is default.

Upgrading from 0.1.0: earlier versions rewrote unsupported characters to _, so different users could resolve to the same agent id (for example john.doe@acme.com and john_doe@acme.com). Identities like these now get their own hashed agent id and start with empty memory. Their old agent is not adopted automatically, because it may hold memories from more than one person. Ids that were already unambiguous (e.g. tenant-acme-user-u42-agent-support, UUID user ids) are unchanged.

Prerequisites

Python 3.10+
Memanto and a Moorcheh API key (or on-prem Memanto backend configured)
An AgentCore Runtime handler that receives a trusted userId (JWT, AgentCore identity header, or server-side auth — never client-supplied)
AWS credentials and permissions for deploying and invoking AgentCore separately from Memanto

Install

Install the adapter

pip install memanto-agentcore

This pulls in memanto automatically (PyPI dependency). Add pip install memanto only if you want to upgrade the core package independently of the adapter.

Configure Moorcheh

export MOORCHEH_API_KEY=your_key_xxxxxxxxxxxxxxxxxx

Or run memanto once to write ~/.memanto/.env. On-prem users: memanto config backend on-prem and set the Moorcheh URL per on-prem docs.

Wrap your handler

import os
from memanto.cli.client.sdk_client import SdkClient
from memanto_agentcore import MemantoRuntimeAdapter, TurnContext

client = SdkClient(api_key=os.environ["MOORCHEH_API_KEY"])
adapter = MemantoRuntimeAdapter(client, agent_name="support-agent")


async def handler(event: dict) -> dict:
    context = TurnContext(
        runtime_session_id=event["sessionId"],
        user_id=event["userId"],  # validated identity — not from the client
        agent_name="support-agent",
        tenant_id=event.get("tenantId"),
        request_id=event.get("requestId"),
    )
    return await adapter.run_turn(
        context=context,
        payload={"prompt": event["prompt"]},
        agent_callable=run_my_agent,
    )


async def run_my_agent(payload: dict, memory_context: str) -> dict:
    prompt = payload["prompt"]
    if memory_context:
        prompt = f"Past context:\n{memory_context}\n\nCurrent request: {prompt}"
    output = await call_bedrock(prompt)  # your Bedrock integration
    return {"output": output}

Lower-level hooks

memory_context = await adapter.before_turn(context, query=user_message)
result = await run_my_agent(payload, memory_context=memory_context)
await adapter.after_turn(context, result=result["output"], query=user_message)

Identity rules

Never use runtimeSessionId as the Memanto agent id. Sessions expire; memory must survive session churn.

Preferred identity sources:

Validated user ID from AgentCore JWT/OAuth (sub)
X-Amzn-Bedrock-AgentCore-Runtime-User-Id header
Application-supplied user ID in trusted server-side deployments

Custom namespace resolution:

import hashlib
import json

from memanto_agentcore import MemantoRuntimeAdapter, TurnContext

def my_resolver(context: TurnContext) -> str:
    # Must be injective: never join raw identity parts with a character they
    # may contain ("a_b" + "c" and "a" + "b_c" would share one namespace).
    identity = json.dumps([context.tenant_id, context.user_id, context.agent_name])
    return "acme-" + hashlib.sha256(identity.encode()).hexdigest()[:48]

adapter = MemantoRuntimeAdapter(client, agent_id_resolver=my_resolver)

If user_id is missing, the default resolver raises AgentResolutionError (fail closed).

Verify cross-session memory

Manual checklist (no AWS required for the Memanto side):

Run one turn for a test user and store a preference via after_turn or run_turn.
Use a new runtimeSessionId for the same userId.
Call before_turn — recalled context should include the stored detail.
Repeat with a second user — they must not see the first user’s memory.

From the Memanto repo you can run the automated smoke script:

python integrations/agentcore/scripts/smoke_test.py

CI publishes the adapter when you tag integrations/agentcore/vX.Y.Z on the memanto repository.

Shared memory across integrations

All Memanto integration packages use the same Moorcheh-backed agents when they share an agent_id:

Integration	Package	What it does
`integrations/ag2`	`memanto-ag2`	AG2 tool registration for remember / recall / answer.
AgentCore	`memanto-agentcore`	Recall/retain wrapper for Bedrock AgentCore Runtime handlers.
`integrations/mcp`	`memanto-mcp`	MCP server for Claude Desktop, Cursor, etc.
`integrations/google-adk`	`memanto-google-adk`	Google ADK `BaseMemoryService` plus a remember tool.
`integrations/crewai`	`crewai-memanto`	CrewAI tools for multi-agent memory.
`integrations/langgraph`	`langgraph-memanto`	LangGraph `BaseStore`, nodes, and tools.
`integrations/hermes-agents`	`hermes-memanto`	Hermes memory provider.

Integrations

Amazon Bedrock AgentCore

Amazon Bedrock AgentCore Runtime + Memanto

Cross-session recall

Automatic retention

Stable identity

Fail-open recall

How It Works

Prerequisites

Install

Wrap your handler

Lower-level hooks

Identity rules

Verify cross-session memory

Shared memory across integrations

Next Steps

​Amazon Bedrock AgentCore Runtime + Memanto

Cross-session recall

Automatic retention

Stable identity

Fail-open recall

​How It Works

​Prerequisites

​Install

​Wrap your handler

​Lower-level hooks

​Identity rules

​Verify cross-session memory

​Shared memory across integrations

​Next Steps

Amazon Bedrock AgentCore Runtime + Memanto

How It Works

Prerequisites

Install

Wrap your handler

Lower-level hooks

Identity rules

Verify cross-session memory

Shared memory across integrations

Next Steps