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. Ids longer than 64 characters are replaced by a 64-character SHA-256 digest of tenant + user_id + agent_name, so they stay stable and unique.

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:

from memanto_agentcore import MemantoRuntimeAdapter, TurnContext

def my_resolver(context: TurnContext) -> str:
    return f"acme_{context.user_id}_{context.agent_name}"

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/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