---
type: "post"
id: "connect-amazon-bedrock-agentcore-gateway-to-private-apis-3de588"
slug: "connect-amazon-bedrock-agentcore-gateway-to-private-apis-3de588"
title: "Connect Amazon Bedrock AgentCore Gateway to private APIs in a hub-and-spoke network with centralized inspection"
description: "AWS describes a hub-and-spoke network pattern for connecting Amazon Bedrock AgentCore Gateway to private APIs while routing inter-VPC traffic through a central firewall in both directions."
retrieval_nugget: "AWS describes a hub-and-spoke network pattern for connecting Amazon Bedrock AgentCore Gateway to private APIs while routing inter-VPC traffic through a central firewall in both directions. For teams with centrally owned subnets, the design provides a concrete way to separate network, application, and agent-platform responsibilities without making private tools publicly reachable."
published_at: "2026-11-21"
updated_at: "2026-11-21"
record_date: "2026-11-21"
date_kind: "published_at"
topics: ["agent-tools","security","infrastructure"]
entities: ["Amazon Bedrock AgentCore","Amazon Bedrock AgentCore Gateway","Amazon VPC Lattice","AWS Transit Gateway","AWS Network Firewall","AWS"]
related_patterns: ["agent-security-moves-to-runtime-boundaries"]
novelty_label: "new_fact"
what_changed: null
prior_refs: []
source_url: "https://aws.amazon.com/blogs/machine-learning/connect-amazon-bedrock-agentcore-gateway-to-private-apis-in-a-hub-and-spoke-network-with-centralized-inspection"
source_urls: ["https://aws.amazon.com/blogs/machine-learning/connect-amazon-bedrock-agentcore-gateway-to-private-apis-in-a-hub-and-spoke-network-with-centralized-inspection"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:connect-amazon-bedrock-agentcore-gateway-to-private-apis-3de588"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/connect-amazon-bedrock-agentcore-gateway-to-private-apis-3de588/","markdown":"https://newruntime.com/posts/connect-amazon-bedrock-agentcore-gateway-to-private-apis-3de588.md","json":"https://newruntime.com/posts/connect-amazon-bedrock-agentcore-gateway-to-private-apis-3de588.json"}
markdown_url: "https://newruntime.com/posts/connect-amazon-bedrock-agentcore-gateway-to-private-apis-3de588.md"
---

# Connect Amazon Bedrock AgentCore Gateway to private APIs in a hub-and-spoke network with centralized inspection

## Retrieval answer

AWS describes a hub-and-spoke network pattern for connecting Amazon Bedrock AgentCore Gateway to private APIs while routing inter-VPC traffic through a central firewall in both directions. For teams with centrally owned subnets, the design provides a concrete way to separate network, application, and agent-platform responsibilities without making private tools publicly reachable.

## Summary
AWS describes a hub-and-spoke network pattern for connecting Amazon Bedrock AgentCore Gateway to private APIs while routing inter-VPC traffic through a central firewall in both directions. For teams with centrally owned subnets, the design provides a concrete way to separate network, application, and agent-platform responsibilities without making private tools publicly reachable.

## What happened
AWS’s architecture post presents a reference pattern for enterprises where a central network team owns every VPC, subnet, and AWS Transit Gateway attachment, while application teams manage their own resources and security groups. It addresses two requirements at once: AgentCore Gateway must reach internal REST APIs or MCP servers, and traffic between the Gateway and those tools must pass through a central firewall on the request and response paths. AWS built and tested the pattern in a lab in the US East (N. Virginia) Region (`us-east-1`), using three member accounts and a management account in AWS Organizations. The accompanying GitHub repository contains CloudFormation templates, test scripts, test evidence, address plans, validation checks, and troubleshooting guidance.

The design uses Amazon VPC Lattice in self-managed mode, with one important placement choice: the network account owns a dedicated VPC and subnets for the resource gateway. Those subnets are not shared and contain neither backends nor central endpoints. Routes send traffic from them through the Transit Gateway and inspection VPC. For each backend, the network team creates a VPC Lattice resource configuration and shares it with the AgentCore account through AWS Resource Access Manager. AgentCore Gateway targets then reference those shared configurations. AWS recommends one resource gateway per trust zone.

The request path starts with an agent in a shared subnet calling the Gateway URL through a private interface endpoint. The Gateway evaluates its resource policy and inbound JWT, selects a target, obtains an OAuth token for the tool account, and sends the call through VPC Lattice to the resource gateway. From there, routing carries it through the Transit Gateway and inspection VPC to an internal Application Load Balancer or private API Gateway endpoint. The tool-side ALB or API validates the token before forwarding to the backend. The response returns along the corresponding inspected route. AWS says VPC Lattice delivers the connection from its service network to the resource gateway’s network interfaces; the AgentCore account does not need its own Transit Gateway attachment for that hop.

AWS divides setup across three teams. The network team creates the gateway VPC, routes, firewall rules, interface endpoint, and RAM share. The tool team configures an ALB certificate and listener JWT validation, or an API authorizer and endpoint policy. The AgentCore team creates the Gateway, inbound authorizer, resource policy, optional AWS WAF web ACL, targets, and OAuth credential providers. AWS’s examples include stateful firewall allows for resource-gateway-to-tool traffic on port 443 and ALB-to-identity-provider JWKS retrieval. To demonstrate return-path inspection, its lab inserted a temporary drop rule for replies, observed calls time out and logged drops, then removed the rule and restored calls.

## What the archive adds
New Runtime’s earlier coverage includes an [October 1, 2026 note on a multi-account agent interface](https://newruntime.com/posts/getting-started-with-web-answer-on-amazon-bedrock-7b64a7/), but that story concerns a different design. This is a new event: a network reference architecture for private AgentCore Gateway targets and centralized inspection.

## Trend signal
This supports [agent security moving to runtime boundaries](https://newruntime.com/patterns/agent-security-moves-to-runtime-boundaries/): the design puts security enforcement in network routes, firewall policy, Gateway authorization, and tool-side token validation rather than relying on the agent prompt. It is a specific AWS network pattern, not evidence that the approach is already standard across agent deployments.

## Why now
The architecture addresses environments where organizations are adopting Gateway-mediated access to private APIs without relaxing existing central-network ownership or inspection requirements. AWS’s post frames the need around making the Gateway’s private endpoint connectivity compatible with those existing controls.

## Why it matters
Private tool access is a consequential deployment boundary for enterprise agents. This pattern gives network, application, and AgentCore teams distinct responsibilities and a way to enforce them technically: the network team controls routes and firewall policy, tool owners validate the Gateway’s OAuth token, and the Gateway applies inbound authorization before choosing a target. That separation can make a multi-account deployment easier to review than a design in which one team owns every layer.

The limits matter just as much as the route. AWS says TLS remains end to end between Gateway and ALB, so the firewall sees flow metadata and SNI rather than request payloads. The agent-to-interface-endpoint leg and Gateway-to-resource-gateway leg do not cross the firewall, nor do token-provider requests. Calls reaching tools with the client-credentials grant carry the Gateway’s client identity, not an end-user identity; AWS points to inbound JWT claims in Gateway application logs for caller tracing. Teams should compare these controls and gaps with their own inspection and audit requirements before adoption.

## What happens next
- **More AWS reference designs will document centralized network controls for agent-to-tool access** (6 months, 60%). Watch for: additional AWS architecture posts or sample repositories covering other private endpoint and inspection topologies.

## Limits and uncertainty
AWS reports that it tested the pattern in a lab, not that it has validated the design across a range of production deployments or firewall vendors. The example uses AWS Network Firewall and Cognito in its tests, and the post says teams should adapt the pattern to their own account architecture. Its controls do not provide payload inspection at the central firewall or end-user identity at the tool under the described client-credentials flow. AWS also identifies prerequisites, including AWS Organizations with RAM sharing enabled and minimum AWS CLI or Boto3 versions for a certificate configuration parameter. Production performance, operational overhead, and cost depend on each deployment and are not established by the lab results.

## Skill to build now
If your team uses a stateful central firewall, reproduce the return-path check in a non-production environment: allow the intended gateway-to-tool flow, temporarily block the reply direction, confirm that calls time out and firewall logs identify the drops, then remove the test rule and verify recovery. Use the result to validate both routing symmetry and the team’s troubleshooting path before connecting production tools.

## Reader takeaway
For centrally governed AWS networks, private AgentCore Gateway access can be routed through an inspection VPC using a network-account-owned VPC Lattice resource gateway and shared per-backend configurations. Treat the firewall as one layer, not the whole security model: pair it with tool-side token validation, explicit Gateway authorization, and a clear account of which traffic and identities the design does not inspect.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Agent Tools](https://newruntime.com/topics/agent-tools.md): Explore the agent-tools topic hub.
- topic hub: [Security](https://newruntime.com/topics/security.md): Explore the security topic hub.
- topic hub: [Infrastructure](https://newruntime.com/topics/infrastructure.md): Explore the infrastructure topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)
