## TPipe-AgentCore is available

Amazon Bedrock AgentCore gives applications a managed runtime boundary. TPipe-AgentCore puts an ordinary TPipe agent inside that boundary.

The integration is now available as an optional module in the TPipe repository. It connects AgentCore Runtime to the TPipe execution model without asking the application to rebuild its agent around a new abstraction. The application still owns the root: a `Pipeline`, a `Manifold`, or another `P2PInterface` implementation. AgentCore supplies the hosted runtime around it.

## Getting started

Add the optional module to the TPipe multi-project build:

```kotlin
dependencies {
    implementation(project(":TPipe-AgentCore"))
}
```

Then hand the runtime bootstrap a factory for the application's normal TPipe root:

```kotlin
import com.TTT.AgentCore.Runtime.AgentCoreRuntimeBootstrap
import com.TTT.AgentCore.Runtime.AgentCoreSessionContext

val host = AgentCoreRuntimeBootstrap.start(
    wait = false
) { session: AgentCoreSessionContext ->
    buildApplicationRoot(session)
}
```

`buildApplicationRoot` is the application-owned factory. It returns the root that performs the work for that runtime session. The bootstrap starts the host and retains one root per session by default.

The lower-level form is available when the application wants to construct the host directly:

```kotlin
import com.TTT.AgentCore.Runtime.AgentCoreRuntimeHost
import com.TTT.AgentCore.Runtime.AgentCoreRuntimeHostConfig
import com.TTT.AgentCore.Runtime.AgentCoreSessionFactory

val host = AgentCoreRuntimeHost(
    AgentCoreRuntimeHostConfig(port = 8080),
    AgentCoreSessionFactory { session ->
        buildApplicationRoot(session)
    }
)

host.start()
```

The host serves `/invocations`, `/ping`, and `/ws`. The default runtime configuration listens on port `8080`. The application can close the returned host during shutdown.

The module's shipped example follows this same shape: create a session-aware root factory, pass it to `AgentCoreRuntimeBootstrap`, and return the started `AgentCoreRuntimeHost`.

## What ships in the module

TPipe-AgentCore is an infrastructure integration layer. It includes the runtime host and the adapters required to connect TPipe execution to AgentCore services. The module also includes seams for exact TPipe state persistence, Gateway tools through the existing MCP/PCP boundary, dynamic identity, asynchronous OTEL tracing, policy, evaluations, registry operations, payments, Browser, Code Interpreter, and ARM64 CloudFormation deployment.

Those integrations are explicit. The application opts into the surfaces it needs. The module does not silently register tools, export prompt content, enable policy enforcement, or choose a model provider on the application's behalf.

TPipe-AgentCore depends on TPipe Core and TPipe-MCP. It does not depend on TPipe-Bedrock. Model invocation remains in the provider module selected by the application.

## Session-aware execution

AgentCore Runtime supplies a session identifier. TPipe-AgentCore uses that identifier to retain the corresponding TPipe root. The default mode creates one root for each session and serializes requests within that session. Independent sessions use independent roots and can execute concurrently.

Applications that intentionally want one shared root can select the shared session mode through `AgentCoreRuntimeHostConfig`. The choice stays in application configuration, where the state model is visible.

The runtime edge handles HTTP and WebSocket requests. The TPipe root handles the agent execution. Existing TPipe lifecycle, orchestration, P2P, memory, and tool code remains the application's execution surface.

## Deployment

The module includes an ARM64 CloudFormation deployment contract for a TPipe AgentCore Runtime container. The application supplies its ARM64 image URI and chooses the runtime protocol, network mode, capacity settings, and optional AgentCore resources.

Customer-owned IAM, VPC, KMS, and storage prerequisites remain customer-owned. The module describes the deployment surface without pretending to own the security perimeter around the application.

## Start here

The source module documentation is the reference for the current integration:

[TPipe-AgentCore on GitHub](https://github.com/Ten-Trillion-Triangles/TPipe/tree/main/TPipe-AgentCore)

[AgentCore integration documentation](https://github.com/Ten-Trillion-Triangles/TPipe/tree/main/docs/agentcore)

[TPipe documentation](https://www.tentrilliontriangles.com/docs/)

TPipe-AgentCore gives an existing TPipe agent a managed runtime boundary. The agent stays a TPipe agent.