@aws/agentcore 1.0.0-preview.9 → 1.0.0-rc.1

package/dist/assets/{python/http/strands/base → templates/agent-python-strands}/model/load.py

@@ -121,3 +121,49 @@ def load_model() -> GeminiModel:
         model_id="gemini-2.5-flash",
     )
 {{/if}}
+{{#if (eq modelProvider "LiteLLM")}}
+{{#if identityProviders.[0].name}}
+import os
+
+{{/if}}
+from strands.models.litellm import LiteLLMModel
+{{#if identityProviders.[0].name}}
+from bedrock_agentcore.identity.auth import requires_api_key
+
+IDENTITY_PROVIDER_NAME = "{{identityProviders.[0].name}}"
+IDENTITY_ENV_VAR = "{{identityProviders.[0].envVarName}}"
+
+
+@requires_api_key(provider_name=IDENTITY_PROVIDER_NAME)
+def _agentcore_identity_api_key_provider(api_key: str) -> str:
+    """Fetch API key from AgentCore Identity."""
+    return api_key
+
+
+def _get_api_key() -> str:
+    """
+    Uses AgentCore Identity for API key management in deployed environments.
+    For local development, run via 'agentcore dev' which loads agentcore/.env.
+    """
+    if os.getenv("LOCAL_DEV") == "1":
+        api_key = os.getenv(IDENTITY_ENV_VAR)
+        if not api_key:
+            raise RuntimeError(
+                f"{IDENTITY_ENV_VAR} not found. Add {IDENTITY_ENV_VAR}=your-key to .env.local"
+            )
+        return api_key
+    return _agentcore_identity_api_key_provider()
+{{/if}}
+
+
+def load_model() -> LiteLLMModel:
+    """Get a LiteLLM model client (proxies to the provider encoded in model_id)."""
+    client_args = {}
+    {{#if identityProviders.[0].name}}
+    client_args["api_key"] = _get_api_key()
+    {{/if}}
+    return LiteLLMModel(
+        client_args=client_args,
+        model_id="bedrock/us.anthropic.claude-sonnet-4-5-20250514-v1:0",
+    )
+{{/if}}

package/dist/assets/templates/agent-python-strands/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["hatchling ~= 1.27.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ name }}"
+version = "0.1.0"
+description = "AgentCore Runtime Application using Strands SDK"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "aws-opentelemetry-distro ~= 0.18.0",
+    "bedrock-agentcore ~= 1.9.1",
+    "botocore[crt] ~= 1.43.0",
+    {{#if (eq modelProvider "Anthropic")}}"strands-agents[anthropic] ~= 1.15.0",
+    {{else}}{{#if (eq modelProvider "OpenAI")}}"strands-agents[openai] ~= 1.15.0",
+    {{else}}{{#if (eq modelProvider "Gemini")}}"strands-agents[gemini] ~= 1.15.0",
+    {{else}}{{#if (eq modelProvider "LiteLLM")}}"strands-agents[litellm] ~= 1.15.0",
+    {{else}}"strands-agents ~= 1.15.0",
+    {{/if}}{{/if}}{{/if}}{{/if}}
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]

package/dist/assets/templates/agent-typescript-strands/README.md

@@ -0,0 +1,29 @@
+This is a project generated by the AgentCore CLI!
+
+# Layout
+
+The generated application code lives at the agent root directory. At the root, there is a `.gitignore` file, an
+`agentcore/` folder which represents the configurations and state associated with this project. Other `agentcore`
+commands like `deploy`, `dev`, and `invoke` rely on the configuration stored here.
+
+## Agent Root
+
+The main entrypoint to your app is defined in `main.ts`. Using the AgentCore SDK `BedrockAgentCoreApp`, this file
+defines an HTTP server that streams tokens from your chosen Agent framework SDK.
+
+`model/load.ts` instantiates your chosen model provider.
+
+## Input Validation
+
+The generated Zod request schema keeps plain prompts typed as strings before forwarding them to Strands. Retain this
+validation when extending the request shape, and pass only prompt text to the agent.
+
+# Developing locally
+
+If installation was successful, `node_modules/` is already populated with dependencies.
+
+`agentcore project dev` will start a local server using `tsx watch main.ts` for hot reload on 0.0.0.0:8080.
+
+# Deployment
+
+After providing credentials, `agentcore project deploy` will deploy your project into Amazon Bedrock AgentCore.

package/dist/assets/templates/agent-typescript-strands/gitignore.template

@@ -0,0 +1,22 @@
+# Environment variables
+.env
+.env.*
+
+# Node
+node_modules/
+dist/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db

package/dist/assets/templates/agent-typescript-strands/main.ts

@@ -0,0 +1,86 @@
+import { BedrockAgentCoreApp } from 'bedrock-agentcore/runtime';
+import { Agent, McpClient, tool, type ToolList } from '@strands-agents/sdk';
+import { z } from 'zod';
+import { loadModel } from './model/load.js';
+import { getStreamableHttpMcpClient } from './mcp_client/client.js';
+import { getActorId, getOrCreateMemoryManager } from './memory/memory.js';
+
+// Define a collection of MCP clients (filter out anything that failed to initialize)
+const mcpClients: McpClient[] = [getStreamableHttpMcpClient()].filter(
+  (client): client is McpClient => Boolean(client)
+);
+
+// Define a collection of tools used by the model
+const tools: ToolList = [];
+
+// Define a simple function tool — the Zod schema gives us type inference and runtime validation for free
+const addNumbers = tool({
+  name: 'add_numbers',
+  description: 'Return the sum of two numbers',
+  inputSchema: z.object({
+    a: z.number(),
+    b: z.number(),
+  }),
+  callback: async ({ a, b }) => a + b,
+});
+tools.push(addNumbers);
+
+// Add MCP clients to tools
+tools.push(...mcpClients);
+
+const SYSTEM_PROMPT = `
+You are a helpful assistant. Use tools when appropriate.
+`;
+
+const requestSchema = z.object({
+  prompt: z.string().default(''),
+  userId: z.string().optional(),
+});
+
+const agentCache = new Map<string, Agent>();
+
+async function getOrCreateAgent(sessionId: string, actorId: string): Promise<Agent> {
+  const key = `${actorId}:${sessionId}`;
+  let agent = agentCache.get(key);
+  if (agent) return agent;
+
+  const model = await loadModel();
+  agent = new Agent({
+    model,
+    systemPrompt: SYSTEM_PROMPT,
+    tools,
+    memoryManager: getOrCreateMemoryManager(sessionId, actorId) ?? undefined,
+  });
+  agentCache.set(key, agent);
+  return agent;
+}
+
+const app = new BedrockAgentCoreApp({
+  invocationHandler: {
+    requestSchema,
+    async *process(payload, context) {
+      const sessionId = context?.sessionId ?? 'default-session';
+      const actorId = getActorId(payload, context);
+      const agent = await getOrCreateAgent(sessionId, actorId);
+
+      try {
+        for await (const event of agent.stream(payload.prompt)) {
+          if (
+            event.type === 'modelStreamUpdateEvent' &&
+            event.event?.type === 'modelContentBlockDeltaEvent' &&
+            event.event.delta?.type === 'textDelta'
+          ) {
+            yield { data: event.event.delta.text };
+          }
+        }
+      } finally {
+        // Drain in-flight createEvent calls before the runtime can reclaim
+        // the session microVM. flush() is the durability mechanism — without
+        // it, an idle reclamation can lose the tail of the conversation.
+        await agent.memoryManager?.flush();
+      }
+    },
+  },
+});
+
+app.run({ port: parseInt(process.env.PORT ?? '8080') });

package/dist/assets/templates/agent-typescript-strands/mcp_client/client.ts

@@ -0,0 +1,11 @@
+import { McpClient } from '@strands-agents/sdk';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+
+// ExaAI provides information about code through web searches, crawling and code context searches through their platform. Requires no authentication
+const EXAMPLE_MCP_ENDPOINT = 'https://mcp.exa.ai/mcp';
+
+export function getStreamableHttpMcpClient(): McpClient {
+  // to use an MCP server that supports bearer authentication, add a headers() callback to requestInit
+  const transport = new StreamableHTTPClientTransport(new URL(EXAMPLE_MCP_ENDPOINT));
+  return new McpClient({ transport });
+}

package/dist/assets/templates/agent-typescript-strands/memory/memory.ts

@@ -0,0 +1,44 @@
+import { randomUUID } from 'node:crypto';
+import { MemoryManager } from '@strands-agents/sdk';
+import { createAgentCoreMemoryStores } from 'bedrock-agentcore/experimental/memory/strands';
+
+const MEMORY_ID = process.env.{{memoryEnvVarName}};
+
+const CUSTOM_ACTOR_ID_HEADER = 'x-amzn-bedrock-agentcore-runtime-custom-actor-id';
+
+export function getActorId(payload: any, context: any): string {
+  const raw =
+    context?.headers?.[CUSTOM_ACTOR_ID_HEADER] ||
+    payload?.userId ||
+    context?.sessionId;
+  return typeof raw === 'string' && raw.trim().length > 0 ? raw.trim() : randomUUID();
+}
+
+const memoryManagerCache = new Map<string, MemoryManager>();
+
+export function getOrCreateMemoryManager(sessionId: string, actorId: string): MemoryManager | null {
+  if (!MEMORY_ID) return null;
+
+  const key = `${actorId}:${sessionId}`;
+  let manager = memoryManagerCache.get(key);
+  if (manager) return manager;
+
+  const stores = createAgentCoreMemoryStores({
+    memoryId: MEMORY_ID,
+    actorId,
+    sessionId,
+    namespaces: [
+      { namespace: '/users/{actorId}/facts' },
+      { namespace: '/users/{actorId}/preferences' },
+      { namespace: '/episodes/{actorId}/{sessionId}' },
+      { namespace: '/summaries/{actorId}/{sessionId}' },
+    ],
+    // readMode defaults to 'per-namespace' (one retrieve call per namespace).
+    // Switch to 'subtree' to consolidate to a single hierarchical recall call.
+    extraction: true,
+  });
+
+  manager = new MemoryManager({ stores });
+  memoryManagerCache.set(key, manager);
+  return manager;
+}

package/dist/assets/templates/agent-typescript-strands/model/load.ts

@@ -0,0 +1,5 @@
+import { BedrockModel } from '@strands-agents/sdk/models/bedrock';
+
+export function loadModel(): BedrockModel {
+  return new BedrockModel({ modelId: 'global.anthropic.claude-sonnet-4-5-20250929-v1:0' });
+}

package/dist/assets/templates/agent-typescript-strands/package.json.template

@@ -0,0 +1,29 @@
+{
+  "name": "{{name}}",
+  "version": "0.1.0",
+  "description": "AgentCore Runtime Application using Strands TypeScript SDK",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/main.js",
+    "dev": "tsx watch main.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "~1.25.2",
+    "@opentelemetry/api": "~1.9.0",
+    "@strands-agents/sdk": "~1.5.0",
+    "bedrock-agentcore": "~0.3.0",
+    "tsx": "~4.19.0",
+    "zod": "~4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "~22.0.0",
+    "typescript": "~5.6.0"
+  },
+  "overrides": {
+    "bedrock-agentcore": {
+      "@strands-agents/sdk": "$@strands-agents/sdk"
+    }
+  }
+}

package/dist/assets/templates/agent-typescript-strands/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": false,
+    "sourceMap": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "types": ["node"]
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/assets/templates/agent-typescript-vercel/README.md

@@ -0,0 +1,22 @@
+This is a project generated by the AgentCore CLI!
+
+# Layout
+
+The generated application code lives at the agent root directory. At the root, there is a `.gitignore` file, an
+`agentcore/` folder which represents the configurations and state associated with this project. Other `agentcore`
+commands like `deploy`, `dev`, and `invoke` rely on the configuration stored here.
+
+## Agent Root
+
+The main entrypoint to your app is defined in `main.ts`. Using the AgentCore SDK `BedrockAgentCoreApp`, this file
+defines an HTTP server that streams tokens from Amazon Bedrock via the Vercel AI SDK's `streamText` API.
+
+# Developing locally
+
+If installation was successful, `node_modules/` is already populated with dependencies.
+
+`agentcore project dev` will start a local server using `tsx watch main.ts` for hot reload on 0.0.0.0:8080.
+
+# Deployment
+
+After providing credentials, `agentcore project deploy` will deploy your project into Amazon Bedrock AgentCore.

package/dist/assets/templates/agent-typescript-vercel/gitignore.template

@@ -0,0 +1,22 @@
+# Environment variables
+.env
+.env.*
+
+# Node
+node_modules/
+dist/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db

package/dist/assets/templates/agent-typescript-vercel/main.ts

@@ -0,0 +1,35 @@
+import { BedrockAgentCoreApp } from 'bedrock-agentcore/runtime';
+import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
+import { fromNodeProviderChain } from '@aws-sdk/credential-providers';
+import { streamText } from 'ai';
+import { z } from 'zod';
+
+const SYSTEM_PROMPT = `You are a helpful assistant.`;
+
+const bedrock = createAmazonBedrock({
+  region: process.env.AWS_REGION ?? 'us-east-1',
+  credentialProvider: fromNodeProviderChain(),
+});
+
+const requestSchema = z.object({
+  prompt: z.string().default(''),
+});
+
+const app = new BedrockAgentCoreApp({
+  invocationHandler: {
+    requestSchema,
+    async *process(payload) {
+      const result = streamText({
+        model: bedrock('global.anthropic.claude-sonnet-4-5-20250929-v1:0'),
+        system: SYSTEM_PROMPT,
+        prompt: payload.prompt,
+      });
+
+      for await (const chunk of result.textStream) {
+        yield { data: chunk };
+      }
+    },
+  },
+});
+
+app.run({ port: parseInt(process.env.PORT ?? '8080') });

package/dist/assets/templates/agent-typescript-vercel/package.json.template

@@ -0,0 +1,24 @@
+{
+  "name": "{{name}}",
+  "version": "0.1.0",
+  "description": "AgentCore Runtime Application using the Vercel AI SDK",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/main.js",
+    "dev": "tsx watch main.ts"
+  },
+  "dependencies": {
+    "@ai-sdk/amazon-bedrock": "~4.0.0",
+    "@aws-sdk/credential-providers": "~3.1126.0",
+    "ai": "~6.0.0",
+    "bedrock-agentcore": "~0.3.0",
+    "tsx": "~4.19.0",
+    "zod": "~4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "~22.0.0",
+    "typescript": "~5.6.0"
+  }
+}

package/dist/assets/templates/agent-typescript-vercel/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": false,
+    "sourceMap": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "types": ["node"]
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/assets/templates/agui-python-strands/README.md

@@ -0,0 +1,39 @@
+# {{ name }}
+
+An AG-UI agent deployed on Amazon Bedrock AgentCore using the Strands SDK.
+
+## Overview
+
+This agent speaks the [AG-UI protocol](https://docs.ag-ui.com/introduction), which
+streams agent-to-UI events over HTTP. It exposes an `/invocations` endpoint that accepts
+an AG-UI `RunAgentInput` body and streams the response back as AG-UI server-sent events,
+matching the AgentCore Runtime HTTP service contract.
+
+## Adding Tools
+
+Define tools with the `@tool` decorator in `main.py` and add them to the agent's `tools` list:
+
+```python
+@tool
+def my_tool(param: str) -> str:
+    """Description of what the tool does."""
+    return f"Result: {param}"
+```
+
+## Developing locally
+
+`agentcore project dev` starts the agent locally on `0.0.0.0:8080`. Post an AG-UI
+`RunAgentInput` body to `http://127.0.0.1:8080/invocations` to invoke it, and check its
+health at `http://127.0.0.1:8080/ping`.
+
+## Deployment
+
+`agentcore project deploy` deploys the agent into Amazon Bedrock AgentCore. Invoke the deployed
+runtime with an AG-UI `RunAgentInput` payload:
+
+```bash
+agentcore project invoke runtime --name agui_python_strands \
+  --payload '{"threadId":"t1","runId":"r1","state":{},"messages":[{"id":"m1","role":"user","content":"Hello!"}],"tools":[],"context":[],"forwardedProps":{}}'
+```
+
+The response streams back as AG-UI server-sent events.

package/dist/assets/{python/a2a/strands/base → templates/agui-python-strands}/gitignore.template

@@ -38,4 +38,4 @@ env/
 
 # OS
 .DS_Store
-Thumbs.db
+Thumbs.db

package/dist/assets/{python/agui/strands/base → templates/agui-python-strands}/main.py

@@ -1,16 +1,10 @@
 import os
 
-# Suppress OpenTelemetry warnings during local development; remove for production
-if os.getenv("LOCAL_DEV") == "1":
-    os.environ["OTEL_SDK_DISABLED"] = "true"
-
 import uvicorn
 from strands import Agent, tool
 from ag_ui_strands import StrandsAgent, StrandsAgentConfig, create_strands_app
 from model.load import load_model
-{{#if hasMemory}}
 from memory.session import get_memory_session_manager
-{{/if}}
 
 
 @tool
@@ -19,24 +13,27 @@ def add_numbers(a: int, b: int) -> int:
     return a + b
 
 
-tools = [add_numbers]
-
 agent = Agent(
     model=load_model(),
     system_prompt="You are a helpful assistant. Use tools when appropriate.",
-    tools=tools,
+    tools=[add_numbers],
 )
 
-{{#if hasMemory}}
+# The AG-UI protocol carries a per-conversation thread_id; each thread gets its
+# own session manager so history is scoped to the conversation. Returns None
+# (in-process history only) until the deployed MEMORY_ID env var is set.
 def session_manager_provider(input_data):
     return get_memory_session_manager(input_data.thread_id, "default-user")
 
+
 config = StrandsAgentConfig(session_manager_provider=session_manager_provider)
-{{else}}
-config = StrandsAgentConfig()
-{{/if}}
 
-agui_agent = StrandsAgent(agent=agent, name="{{ name }}", description="A helpful assistant", config=config)
+agui_agent = StrandsAgent(
+    agent=agent, name="{{ name }}", description="A helpful assistant", config=config
+)
+
+# create_strands_app publishes the AG-UI endpoint at /invocations and a health
+# check at /ping, matching the AgentCore Runtime HTTP service contract on 8080.
 app = create_strands_app(agui_agent, path="/invocations", ping_path="/ping")
 
 if __name__ == "__main__":

package/dist/assets/templates/agui-python-strands/memory/session.py

@@ -0,0 +1,35 @@
+import os
+import uuid
+from typing import Optional
+
+from bedrock_agentcore.memory.integrations.strands.config import AgentCoreMemoryConfig, RetrievalConfig
+from bedrock_agentcore.memory.integrations.strands.session_manager import AgentCoreMemorySessionManager
+
+MEMORY_ID = os.getenv("{{memoryEnvVarName}}")
+REGION = os.getenv("AWS_REGION")
+
+
+def get_memory_session_manager(
+    session_id: Optional[str], actor_id: str
+) -> Optional[AgentCoreMemorySessionManager]:
+    if not MEMORY_ID:
+        return None
+
+    session_id = session_id or uuid.uuid4().hex
+
+    retrieval_config = {
+        f"/users/{actor_id}/facts": RetrievalConfig(top_k=3, relevance_score=0.5),
+        f"/users/{actor_id}/preferences": RetrievalConfig(top_k=3, relevance_score=0.5),
+        f"/episodes/{actor_id}/{session_id}": RetrievalConfig(top_k=5, relevance_score=0.5),
+        f"/summaries/{actor_id}": RetrievalConfig(top_k=3, relevance_score=0.5),
+    }
+
+    return AgentCoreMemorySessionManager(
+        AgentCoreMemoryConfig(
+            memory_id=MEMORY_ID,
+            session_id=session_id,
+            actor_id=actor_id,
+            retrieval_config=retrieval_config,
+        ),
+        REGION,
+    )

package/dist/assets/templates/agui-python-strands/model/load.py

@@ -0,0 +1,6 @@
+from strands.models.bedrock import BedrockModel
+
+
+def load_model() -> BedrockModel:
+    """Get Bedrock model client using IAM credentials."""
+    return BedrockModel(model_id="global.anthropic.claude-sonnet-4-5-20250929-v1:0")

package/dist/assets/templates/agui-python-strands/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling ~= 1.27.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "{{ name }}"
+version = "0.1.0"
+description = "AgentCore AG-UI Agent using Strands SDK"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "ag-ui-strands >= 0.3.0, < 0.4.0",
+    "ag-ui-protocol >= 0.1.19, < 0.2.0",
+    "aws-opentelemetry-distro ~= 0.17.0",
+    "bedrock-agentcore ~= 1.9.1",
+    "botocore[crt] ~= 1.43.0",
+    "strands-agents ~= 1.15.0",
+    "uvicorn >= 0.34.3, < 1.0.0",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]

package/dist/assets/{python/http/strands/base → templates/export-harness-python}/README.md

@@ -13,6 +13,12 @@ file defines a Starlette ASGI app with the chosen Agent framework SDK running wi
 
 `model/load.py` instantiates your chosen model provider.
 
+## Input Validation
+
+Validate invocation input before forwarding it to Strands. Keep plain prompts typed as strings. If the app accepts a
+caller-supplied message history, retain `strip_trailing_tool_use()`, which normalizes the history tail before
+invoking the agent.
+
 ## Environment Variables
 
 | Variable | Required | Description |
@@ -24,16 +30,17 @@ file defines a Starlette ASGI app with the chosen Agent framework SDK running wi
 
 If installation was successful, a virtual environment is already created with dependencies installed.
 
-Run `source .venv/bin/activate` before developing.
-
-`agentcore dev` will start a local server on 0.0.0.0:8080.
+Activate the environment with `source .venv/bin/activate` on macOS/Linux, `.venv\Scripts\activate.bat` in Windows
+Command Prompt, or `.\.venv\Scripts\activate.ps1` in Windows PowerShell.
 
-In a new terminal, you can invoke that server with:
-
-`agentcore invoke --dev "What can you do"`
+`agentcore project dev` will start a local server on 0.0.0.0:8080.
 
 # Deployment
 
-After providing credentials, `agentcore deploy` will deploy your project into Amazon Bedrock AgentCore.
+After providing credentials, `agentcore project deploy` will deploy your project into Amazon Bedrock AgentCore.
+
+Invoke the deployed Runtime with its native payload:
 
-Use `agentcore invoke` to invoke your deployed agent.
+```bash
+agentcore project invoke runtime --payload '{"prompt":"Hello!"}'
+```