Wrapping Any Framework

AgentCore Runtime does not host LangGraph, or CrewAI, or Strands. It hosts a container that speaks a known protocol (HTTP/MCP/A2A) and runs it in a serverless, per-session microVM. The framework lives inside that container, and AWS never needs to know which one you chose.

The BedrockAgentCoreApp SDK is what makes this work. It is a thin Starlette/Uvicorn ASGI wrapper that turns a plain Python function into the Runtime service contract — wiring up /invocations and /ping, session headers, streaming, and async task tracking. The @app.entrypoint decorator is the seam: on one side is AWS's managed HTTP server, on the other side is your framework's agent object. AWS calls your function with a payload dict and ships back whatever you return as JSON.

That seam is the whole trick. The body inside the entrypoint is the only part that changes between frameworks. Everything around it — the import, the app = BedrockAgentCoreApp(), the decorator, app.run(), and the deploy flow — is identical whether you wrap Strands or LlamaIndex.

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from strands import Agent

app = BedrockAgentCoreApp()
agent = Agent()                              # <- the only framework-specific lines

@app.entrypoint
def invoke(payload):
    result = agent(payload.get("prompt", "Hello"))   # <- ...are these three
    return {"result": result.message}                #    in the middle

if __name__ == "__main__":
    app.run()   # local http://localhost:8080; in the container binds 0.0.0.0:8080

AWS officially supports Strands Agents (first-class / recommended), LangGraph/LangChain, CrewAI, LlamaIndex, Google ADK, and the OpenAI Agents SDK, plus arbitrary custom code. The framework list is one of the fast-moving facts — confirm the current set against the Use any agent framework page before you bet on it.

Pin down exactly what never changes. The invariant — five things present in every framework's wrapper:

1. @app.entrypoint — the decorator that registers your function as the agent handler.
2. payload.get("prompt") — how you read the caller's input out of the request dict.
3. return {"result": ...} — the shape AWS serializes back to the caller.
4. app.run() — boots the ASGI server (binds 0.0.0.0:8080 in the container, serves /invocations + /ping).
5. The deploy flow — agentcore configure -e my_agent.py → agentcore launch (a.k.a. deploy) → agentcore invoke. Identical regardless of framework.

The variant — three steps in the middle that differ per framework:

• Build the agent object (once, at module load).
• Call it inside the entrypoint with the prompt.
• Pull the result out of whatever object the framework returns.

Here is the matrix that drives the rest of the lesson. Memorize the columns, not the rows:

Notice the LlamaIndex row is hedged. The exact build/call/pull snippet for LlamaIndex is not verified from the docs — engine.query(prompt) and str(response) are the typical shape, but you should pull the precise, runnable code from the samples repo rather than trusting this row verbatim.

Three of the six frameworks have a plain synchronous call, so a plain def entrypoint works.

Strands — the AWS-native reference. Build an Agent, call it like a function, read .message:

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from strands import Agent

app = BedrockAgentCoreApp()
agent = Agent(tools=[...])

@app.entrypoint
def invoke(payload):
    result = agent(payload.get("prompt", "Hello"))
    return {"result": result.message}

if __name__ == "__main__":
    app.run()

LangGraph reaches Bedrock through langchain-aws. The model is ChatBedrockConverse (or init_chat_model(..., model_provider="bedrock_converse")); you compile a graph and call graph.invoke(...), then read the last message's content:

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from langchain_aws import ChatBedrockConverse
# from langgraph... import builder  # your graph definition

app = BedrockAgentCoreApp()
llm = ChatBedrockConverse(model="us.anthropic.claude-...")   # model IDs change — verify the live catalog
graph = builder.compile()

@app.entrypoint
def invoke(payload):
    prompt = payload.get("prompt", "Hello")
    out = graph.invoke({"messages": [("user", prompt)]})
    return {"result": out["messages"][-1].content}

if __name__ == "__main__":
    app.run()

CrewAI wraps a multi-agent crew. The sample defines agents and tasks in config/agents.yaml and config/tasks.yaml, exposes a crew() factory, and you call crew.kickoff(inputs=...), reading .raw:

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from crew import AgentcoreCrewAi   # the sample's crew factory

app = BedrockAgentCoreApp()
crew = AgentcoreCrewAi().crew()

@app.entrypoint
def invoke(payload):
    result = crew.kickoff(inputs={"topic": payload.get("prompt", "Hello")})
    return {"result": result.raw}

if __name__ == "__main__":
    app.run()

The invariant scaffold is byte-for-byte identical across all three. Only the build line, the call, and the unwrap differ.

Two frameworks are async: the OpenAI Agents SDK (await Runner.run(...)) and Google ADK (runner.run_async(...)). You have two equally valid ways to host them.

Option A — make the entrypoint itself async. BedrockAgentCoreApp supports an async def entrypoint directly, so you can await inside it:

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from agents import Agent, Runner   # OpenAI Agents SDK

app = BedrockAgentCoreApp()
agent = Agent(name="Assistant", instructions="You are helpful.")

@app.entrypoint
async def invoke(payload):
    result = await Runner.run(agent, payload.get("prompt", "Hello"))
    return {"result": result.final_output}

if __name__ == "__main__":
    app.run()

Option B — keep a sync entrypoint and wrap with asyncio.run(...). Useful when the rest of your code is synchronous:

import asyncio
from bedrock_agentcore.runtime import BedrockAgentCoreApp
from agents import Agent, Runner

app = BedrockAgentCoreApp()
agent = Agent(name="Assistant", instructions="You are helpful.")

@app.entrypoint
def invoke(payload):
    result = asyncio.run(Runner.run(agent, payload.get("prompt", "Hello")))
    return {"result": result.final_output}

if __name__ == "__main__":
    app.run()

Google ADK is async too, and it streams events — you build a root_agent, drive it with runner.run_async(...), and pull text out of the event objects. The result lives at event.content.parts[0].text:

from bedrock_agentcore.runtime import BedrockAgentCoreApp
# from google.adk... import Agent, Runner, root_agent setup

app = BedrockAgentCoreApp()
root_agent = Agent(model="...")   # ADK agent

@app.entrypoint
async def invoke(payload):
    prompt = payload.get("prompt", "Hello")
    final_text = ""
    async for event in runner.run_async(user_id="u", session_id="s", new_message=prompt):
        if event.content and event.content.parts:
            final_text = event.content.parts[0].text
    return {"result": final_text}

if __name__ == "__main__":
    app.run()

The deploy flow does not change for async agents — configure, launch, invoke work identically. The only adaptation is the entrypoint signature.

Strands appears first in the matrix and is the recommended SDK for a reason: it is AWS's own open-source agent framework, and it integrates with the rest of AgentCore in ways the others don't.

• Apache-2.0 licensed, open source.
• Model-driven: you declare a model + tools + system prompt, and the SDK runs the agentic loop for you — no hand-rolled orchestration.
• The @tool decorator turns any Python function into a tool the agent can call.
• strands-agents-tools ships 20+ prebuilt tools out of the box.
• MCP integration — Strands agents can consume MCP servers directly (this is how they reach AgentCore Gateway tools).
• Native AgentCore hooks — AgentCoreMemorySessionManager persists conversation to AgentCore Memory, and StrandsA2AExecutor provides Agent-to-Agent (A2A) support.
• A TypeScript SDK (@strands-agents/sdk) exists alongside the Python one.

The @tool decorator is the most ergonomic part of the model-driven loop:

from strands import Agent, tool

@tool
def get_weather(city: str) -> str:
    """Return the current weather for a city."""
    return f"It's sunny in {city}."

agent = Agent(tools=[get_weather])   # the SDK decides when to call it

Strands is also battle-tested inside AWS — it powers Amazon Q Developer, AWS Glue, and the VPC Reachability Analyzer. None of this locks you into Strands; the wrapper pattern means you can start on Strands and move to LangGraph later by changing the body. But when there's no strong reason to pick another framework, Strands gives you the tightest integration with Memory, Gateway, and A2A for the least glue code.

When the snippets above leave you unsure — especially for LlamaIndex, where the exact code is unverified — go to the canonical source: the samples repo at 03-integrations/agentic-frameworks/. It has a folder per framework:

03-integrations/agentic-frameworks/
├── adk/
├── autogen/
├── claude-agent/
├── crewai/
├── java_adk/
├── langchain/
├── langgraph/
├── llamaindex/        <- pull the exact LlamaIndex wrapper from here
├── openai-agents/
├── pydanticai-agents/
├── strands-agents/
└── typescript_mastra/

Each folder is a complete, runnable wrapper. The presence of autogen, pydanticai-agents, claude-agent, and typescript_mastra underscores the point: the pattern extends well beyond the six headline frameworks.

Once the body is written, the deploy flow is the same for all of them. Using the Starter Toolkit CLI:

# 1. Configure: generates .bedrock_agentcore.yaml + Dockerfile
agentcore configure -e my_agent.py

# 2. Launch (a.k.a. deploy): builds an ARM64 image via CodeBuild (no local Docker),
#    pushes to ECR, creates the Runtime, wires CloudWatch — prints the agent runtime ARN
agentcore launch

# 3. Invoke
agentcore invoke '{"prompt": "What is the weather?"}'

Or from Python with the Starter Toolkit Runtime object:

from bedrock_agentcore_starter_toolkit import Runtime

runtime = Runtime()
runtime.configure(entrypoint="my_agent.py", auto_create_execution_role=True,
                  auto_create_ecr=True, requirements_file="requirements.txt")
runtime.launch()                      # the Python method is always .launch()
runtime.invoke({"prompt": "Hi"})

And you can always test the exact cloud contract locally before deploying:

python my_agent.py   # or: agentcore launch --local
curl -X POST http://localhost:8080/invocations \
  -H 'Content-Type: application/json' \
  -d '{"prompt":"What is the weather?"}'