Add Amazon Bedrock AgentCore integration for enterprise-grade agent deployment

[apncodes]

Feature Request: Amazon Bedrock AgentCore Integration

Problem

Koog provides excellent local agent development with Kotlin-native patterns. To complement this strength, developers need seamless integration with enterprise-grade production infrastructure including managed runtime, persistent memory, secure sandboxes, and scalable deployment capabilities.

Proposed Solution

Integrate Amazon Bedrock AgentCore primitives as native Koog components, enabling seamless transition from local development to enterprise production deployment.

Core Integration Points

1. AgentCore Runtime Deployment

kotlin
// Deploy Koog agents to serverless AgentCore Runtime
val agent = AIAgent(strategy, toolRegistry) {
install(AgentCoreRuntime) {
region = "us-east-1"
runtimeConfig = RuntimeConfig.serverless()
}
}
agent.deployToAgentCore()

2. AgentCore Memory as AIAgentFeature

kotlin
// Managed, persistent memory across sessions
install(AgentCoreMemory) {
memoryId = "user-session-${userId}"
shortTermMemory = true
longTermMemory = true
shareAcrossAgents = false
}

3. AgentCore Tools Integration

kotlin
ToolRegistry {
// Secure code execution in isolated sandboxes
tool(AgentCoreCodeInterpreter {
allowedPackages = listOf("pandas", "numpy")
timeoutSeconds = 30
})

// Cloud-based browser automation
tool(AgentCoreBrowser {
headless = true
viewport = Viewport(1920, 1080)
})

// MCP Gateway for API/Lambda integration
tool(AgentCoreGateway {
mcpServers = listOf("internal-apis", "external-tools")
})
}

4. AgentCore Identity & Observability

kotlin
install(AgentCoreIdentity) {
identityProvider = "cognito"
tokenVault = true
}

install(AgentCoreObservability) {
tracing = true
metrics = true
dashboardUrl = "https://console.aws.amazon.com/bedrock/agentcore"
}

Value Proposition

For Kotlin/Java Developers:

• Native AgentCore integration without Python dependencies
• Type-safe configuration with Kotlin DSL
• Seamless local-to-production workflow

For Enterprise Users:

• Managed infrastructure with auto-scaling
• Enterprise security and compliance
• Production-grade observability and monitoring

For Koog Ecosystem:

• Bridge between open-source flexibility and enterprise reliability
• Showcase Kotlin in AI infrastructure
• Enable production-ready agent deployment

Implementation Plan

1. New Module: agents-agentcore following Koog's modular architecture
2. AgentCore SDK Integration: Use AWS SDK for Kotlin for native integration
3. Feature Pattern: Implement as AIAgentFeature for consistency
4. Tool Pattern: Follow existing Tool<TArgs, TResult> interface
5. Testing: Mock AgentCore services for local development

Dependencies

• AWS SDK for Kotlin
• AgentCore service APIs (Runtime, Memory, Identity, etc.)
• Existing Koog agent framework

Documentation

• Integration guide with AgentCore setup
• Migration path from local to AgentCore deployment
• Best practices for enterprise agent development

This integration would make Koog the first Kotlin-native framework to support AgentCore, positioning it as the go-to choice for enterprise Kotlin AI agent development.

[jamesward]

One thing to note that might be an issue... AgentCore Runtime seems to only support IMDSv1 and the AWS Kotlin SDK requires IMDSv2. This limitation will likely prevent Koog from working on AgentCore Runtime without workarounds.

[aozherelyeva]

Thank you for the proposal and for the comment, @apncodes @jamesward!

File an issue so the team can take a look at it ASAP. Please feel free to follow on the progress: KG-486 Add Amazon Bedrock AgentCore integration for enterprise-grade agent deployment

Have a great day!

[apncodes]

thank you @aozherelyeva for considering this and having added this to the issue tracker. I will be more than happy to collaborate and provide any support needed for this.

[AlbertoSH]

I'd be interested in this one!
AgentCore is positioning itself as the enterprise-ready ecosystem for running agents. You can manually wire things up with the AWS SDK, but having native integration would highly simplify things and hide the inner complexities (similarly to other plugins e.g. OpenTelemetry).

[AlbertoSH]

Hey @apncodes, I was doing some testing on my own trying to run a Koog agent in AgentCore Runtime and faced issues with the Kotlin SDK not being able to get credentials. This can be a blocker when accessing the AWS APIs (e.g. Bedrock for the inference, or AgentCore Identity). I did a bit of research, but since the troubleshooting on AgentCore Runtime is a bit uncomfortable (mostly logs based 🙃) I created an issue in the Kotlin SDK project

[AlbertoSH]

Just in case someone else faces the same issue, I got a couple of working solutions. You can check them in the AWS Kotlin SDK issue I mention in my last comment

TL;DR;
Solution 1: Create your own CredentialsProvider wrapping the Java's InstanceProfileCredentialsProvider
Solution 2: Implement your own MicroVM Metadata Service CredentialsProvider. You can find the details in the issue linked in my previous message

If you ask me, I think the Kotlin SDK should support MMDS. But it's not up to me 🙃
If nothing changes, you'll need to provide your own CredentialsProvider. A bit uncomfortable, but not the end of the world
¯_(ツ)_/¯

[jamesward]

MMDS seems to just use either IMDS v1 or v2. And the Kotlin SDK won't add support for v1 since it is deprecated. So for now I think the only option is for Koog to provide its own CredentialsProvider.

[serge-p7v]

@AlbertoSH @jamesward Thank you for your research and clarifications!
I would like to summarize how I see minimal requirements for supporting Bedrock Agentcore in Koog (per component):

Agentcore Runtime

• Koog should provide a way to enable two-three HTTP endpoints to fulfill the protocol contract
• Koog should provide its own CredentialsProvider implementation. An alternative: to switch to AWS Java SDK v2 temporarily.
• Perhaps Koog should also extract a workload token from request headers and pass it downstream.

@apncodes you mentioned agent.deployToAgentCore() function. Could you please tell me if the authors of bedrock-agentcore-starter-toolkit have plans to support agents written in Java/Kotlin? It would be great to have the deployment functionality there!

Agentcore Gateway

• Gateway looks like a Streamable HTTP MCP server (from a framework's "perspective"). Koog already supports Streamable HTTP MCP, it only needs to provide an auth token for the Gateway in "Authorization" header.

Agentcore Memory

• Koog should support both short-term and long-term memory. To me, it looks like Koog should provide its own implementation of PersistenceStorageProvider (for event log) and AgentMemoryProvider (for facts) interfaces. I'll take a closer look at the API and perhaps make a draft of the implementation.

Agentcore Identity

• It seems Koog should support both inbound and outbound authentication.

Agentcore Observability

• Koog should provide a new exporter (in addition to the Langfuse & Weave) in the OpenTelemetry feature.

Agentcore Code Interpreter & Browser Tools

• These tools require sending multiple requests (roughly speaking, to open a session, send some requests and then close the session). So the implementation in Koog should take this into account. I might be wrong, but it seems AWS Java SDK v2 doesn't have the same support of tools as in the Python SDK. For example, I see InvokeCodeInterpreterRequest, but I don't quite understand how to send it through BedrockAgentCoreClient.

Please let me know if I missed anything.

[AlbertoSH]

Hey @serge-p7v, my two cents here as I've been doing some tests with AgentCore and Koog

Agentcore Runtime
Koog should provide a way to enable two-three HTTP endpoints to fulfill the protocol contract

The Python SDK for AgentCore uses decorators, but for Kotlin we could go with an approach similar to the A2AServer

from bedrock_agentcore import BedrockAgentCoreApp
app = BedrockAgentCoreApp()

@app.entrypoint
def production_agent(request):
    return my_local_agent(request.get("prompt"))  # Same logic, enterprise platform

app.run()  # Ready to run on Bedrock AgentCore

so for Kotlin we could go with

val agent: GraphAIAgent<...,...> = ...
// for HTTP contract -> https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-http-protocol-contract.html
val koogAgentCoreApp = KoogAgentCoreApp.HTTP(agent)  
// for A2A contract -> https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/runtime-a2a-protocol-contract.html
val koogAgentCoreApp = KoogAgentCoreApp.A2A(agent)  
// You can host an MCP in AgentCore Runtime as well, but you don't need Koog for that
...
koogAgentCoreApp.run(prompt)

I've even add a second option for building the AgentCore app making the creation of the agent lazy. That way you can customize the agent itself based on the user token

val koogAgentCoreApp = KoogAgentCoreApp.A2A { req ->
    val userToken = req.headers["Authorization"]
    val agent = buildSpecificAgentForUserToken(userToken)
    agent
}

@apncodes you mentioned agent.deployToAgentCore() function. Could you please tell me if the authors of bedrock-agentcore-starter-toolkit have plans to support agents written in Java/Kotlin? It would be great to have the deployment functionality there!

Taking into account that you deploy a Docker image into ECR... I don't see that feature being supported directly by Koog itself. Maybe a Gradle plugin that leverages the Ktor one, build & push the Docker image, and create the whole runtime?
Doable, but that would be entering into IaC terrain. Maybe it can be solved by using a library of CDK constructs/Terraform modules?

Agentcore Gateway
Gateway looks like a Streamable HTTP MCP server (from a framework's "perspective"). Koog already supports Streamable HTTP MCP, it only needs to provide an auth token for the Gateway in "Authorization" header.

There are multiple targets for AgentCore Gateway. The one I see more interesting is Lambda. Having a library that allows developers to deploy their MCP in Lambda, supporting latest spec features (e.g. elicitation and streaming of responses) should be enough. Not sure if this would be under Koog's umbrella, or regular Kotlin MCP SDK

Agentcore Identity
It seems Koog should support both inbound and outbound authentication.

Inbound is managed at AgentCore Runtime/AgentCore Gateway level. From the agent's perspective, you just get the user token. You can perform regular validations as if you were in a Ktor server app, but if the token is invalid your server will not even be invoked.
For outbound, you have to implement the Oauth session binding. Meaning:

1. Get the workload token from the headers of the request
2. Use the workload token and the JWT token/user ID and use AgentCore Identity SDK for requesting a token for the resource server
3. If the token is there, use it. If it's not, send the SSO URL back to the user (e.g. sending a Task update with the state auth-required if implementing A2A). You can then poll for completion, or let the application do another request. When the user performs the login, your polling mechanism will get the token

For the rest, I'm afraid I didn't play with that yet 😅
If I find some time, I'll try to provide a minimum project that showcases my points here

[jamesward]

That all sounds good. For deployment, I don't think Koog needs to do anything like the starter. Users should create containers and deploy with IaC or via the AWS Console.

[serge-p7v]

I've just published a basic support of Agentcore Runtime (only HTTP protocol contract) and Agentcore Memory (both short-term and long-term) with Koog, but not inside Koog in that repo.
Having a basic demo app might be useful for deciding how should real implementation look like in Koog.
Next I'm going to take a closer look at Agentcore Identity.

[serge-p7v]

The current status:

• The support for AgentCore Short-Term Memory was released in Koog 0.8.0 - feat(agents): Amazon Bedrock AgentCore Memory as ChatHistoryProvider #1758
• The support for AgentCore Long-Term Memory is in progress - feat(agents): WIP Amazon Bedrock AgentCore Memory as LongTermMemory #1855