I tried out the AWS MCP Server now that it supports the Tokyo region

Introduction

In an announcement on October 2, 2026, six additional regions were added to the AWS MCP Server's supported regions: Singapore, Sydney, Tokyo, Ireland, London, and Oregon, bringing the total to 8 regions.

https://aws.amazon.com/jp/about-aws/whats-new/2026/10/aws-mcp-server-six-additional-regions/

In this article, I created a Kiro agent that connects to the Tokyo endpoint and also tested its use from a sub-agent.

I compared response times between Tokyo and Virginia based on differences in MCP server connection destinations.

Creating a Kiro Agent for Tokyo

The Tokyo endpoint is listed in Endpoints and quotas. It is aws-mcp.ap-northeast-1.api.aws/mcp (HTTPS) for ap-northeast-1. I saved a Kiro agent using this as ~/.kiro/agents/aws-mcp.json.

https://docs.aws.amazon.com/general/latest/gr/aws-mcp.html

{
  "name": "aws-mcp",
  "description": "AWS MCP Server (Tokyo endpoint)",
  "mcpServers": {
    "aws-mcp": {
      "command": "uvx",
      "args": [
        "mcp-proxy-for-aws-cli@latest",
        "https://aws-mcp.ap-northeast-1.api.aws/mcp",
        "--metadata",
        "AWS_REGION=ap-northeast-1"
      ]
    }
  },
  "tools": ["*"]
}

For the proxy launched with uvx, I used mcp-proxy-for-aws-cli as guided by the official documentation.

The region of the MCP server to connect to is determined by the URL. The AWS_REGION metadata determines the default region when the MCP server operates AWS. Both default to us-east-1. If AWS_REGION is omitted, us-east-1 is used, and the URL in the official documentation's configuration example is also aws-mcp.us-east-1.api.aws/mcp for us-east-1. If you set only AWS_REGION to Tokyo while leaving the URL as us-east-1, the MCP server connection destination remains us-east-1.

https://docs.aws.amazon.com/aws-mcp/latest/userguide/getting-started-aws-mcp-server.html

The launch command is as follows.

kiro-cli chat --agent aws-mcp

After launching, running /mcp showed aws-mcp as running with 8 tools. With /tools, in addition to the built-in tools, 8 tools starting with aws___ were listed as mcp:aws-mcp.

For verification, I launched with --no-interactive --trust-all-tools and passed a prompt instructing only read operations. STS GetCallerIdentity executed via aws___run_script succeeded. It returned the same principal (Arn) as aws sts get-caller-identity executed on the host. No additional authentication configuration was required. The verified host had a default profile session obtained with aws login. No environment variable settings or credential file copying was done.

Using the Tokyo Agent from a Sub-agent

From the main Kiro session, you can use the subagent tool and specify an agent name in role to delegate work to that agent. Since the main session in this case does not have AWS MCP Server configured, I specified aws-mcp created in the previous section as the role and delegated work using the aws___ tools.

In a session with Trust All Tools enabled, tools are executed without approval. Therefore, I instructed only read operations in the prompt. This is an instruction via prompt and does not technically restrict tool execution.

The prompt passed was as follows.

Please perform the following 3 tasks in read-only mode and report the results concisely in Japanese. Do not perform any writes, creates, or deletes.
1. List the names of available MCP tools starting with aws___.
2. Execute STS GetCallerIdentity with aws___run_script and report only whether it succeeded. Do not write the Account and Arn values.
3. Execute aws___list_regions and report the total number of regions returned and whether ap-northeast-1 is included.

The sub-agent's report was as follows.

1. There are 8 available aws___ MCP tools: aws___get_presigned_url, aws___get_regional_availability, aws___get_tasks, aws___list_regions, aws___read_documentation, aws___retrieve_skill, aws___run_script, aws___search_documentation.
2. STS GetCallerIdentity succeeded. The first execution failed with a code validation error (use of `__name__` was blocked) and the AWS API was not called. The code was corrected and re-executed successfully. Account and Arn values are not output.
3. aws___list_regions returned a total of 37 regions. ap-northeast-1 (Tokyo) is included.
No writes, creates, or deletes were performed.

Comparing STS Response Times Between Tokyo and Virginia

The values from this point were measured by launching mcp-proxy-for-aws-cli (1.7.0) directly via stdio from a measurement script, separately from the sub-agent in the previous section. The launch command and arguments are the same as the settings in "Creating a Kiro Agent for Tokyo," with only the URL switched between Tokyo and Virginia for comparison. These are not times via Kiro or sub-agents.

Measurements were taken on October 3, 2026, on a single host within Japan, and the entire measurement script execution (including aws___list_regions) took about 4 minutes. STS GetCallerIdentity was executed via aws___run_script, alternating 30 times each between Tokyo and Virginia. The AWS_REGION metadata was fixed to ap-northeast-1 for both, with only the URL changed. Time is measured from sending tools/call to receiving the response, and does not include uvx and proxy startup or MCP initialization. Since aws___list_regions was called on the same connection after the 30 STS calls, the first call was not immediately after connection. The conditions differ from the first STS call, so for aws___list_regions, only calls from the second onward are shown in the table. There were 0 failures.

Units are seconds. The first call is a single measurement. The median and range from the 2nd onward are values from 29 calls excluding the first of each 30 calls.

Pairing Tokyo and Virginia calls for the same iteration (i-th call), Tokyo was faster in all 29 pairs for STS, with a median difference of 1.01 seconds per pair. Comparing medians, (2.94−1.91)/2.94 ≈ 35% reduction. The median difference for aws___list_regions was 0.13 seconds, with Tokyo being faster in 24 out of 29 pairs.

The measurement script is included in "Reference: Measurement Script" at the end of the article.

Summary

AWS MCP Server now supports the Tokyo region, and the Tokyo endpoint is available for use. When switching from Virginia to Tokyo on an execution environment within Japan, the response time for STS GetCallerIdentity via aws___run_script decreased by approximately 35% in median.

If you are using AWS MCP Server from within Japan with the default us-east-1 endpoint, changing the MCP server connection URL to Tokyo can be expected to reduce response times.

Also, as stated in the announcement, request data can now be kept within the region. Even in cases where use of overseas regions is restricted, specifying the Tokyo region endpoint explicitly may allow you to use AWS MCP Server, so please give it a try.

Reference: Measurement Script

Measurements can be reproduced with the following commands. Python 3 (standard library only) and uvx are required. Since the measurement script appends output, specify a different filename when re-measuring. The script launches mcp-proxy-for-aws-cli@latest, so the version when re-measuring may not be 1.7.0 as at the time of measurement. The summarize script summarize.py assumes 30 iterations.

python3 measure-mcp-latency.py latency.jsonl 30
python3 summarize.py latency.jsonl

#!/usr/bin/env python3
"""Measures response times for the AWS MCP Server Tokyo/Virginia endpoints alternately from the same host.

- Standard library only. Launches mcp-proxy-for-aws via stdio and sends tools/call via JSON-RPC.
- Authentication uses the host's default profile (no environment variable or file extraction).
- Appends JSONL immediately for each call (records remain even if stopped midway).
- Swap call order per iteration to avoid order bias.
Usage: measure-mcp-latency.py <output jsonl> <number of iterations>
"""
import json, select, subprocess, sys, time

OUT, N = sys.argv[1], int(sys.argv[2])
UVX = "uvx"
ENDPOINTS = ["ap-northeast-1", "us-east-1"]
STS_CODE = ('r = await call_boto3(service_name="sts", operation_name="GetCallerIdentity")\n'
            'result = {"has_arn": "Arn" in r}\nresult')
TOOLS = [
    ("sts_run_script", "aws___run_script", {"code": STS_CODE}),
    ("list_regions", "aws___list_regions", {}),
]

class Proxy:
    def __init__(self, ep):
        self.ep, self.seq = ep, 0
        self.p = subprocess.Popen(
            [UVX, "mcp-proxy-for-aws-cli@latest", f"https://aws-mcp.{ep}.api.aws/mcp",
             "--metadata", "AWS_REGION=ap-northeast-1"],
            stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
            text=True, bufsize=1)

    def send(self, o):
        self.p.stdin.write(json.dumps(o) + "\n")
        self.p.stdin.flush()

    def recv(self, id_, timeout=90):
        end = time.time() + timeout
        while time.time() < end:
            r, _, _ = select.select([self.p.stdout], [], [], 1)
            if not r:
                continue
            line = self.p.stdout.readline()
            if not line:
                return None
            try:
                m = json.loads(line)
            except ValueError:
                continue
            if m.get("id") == id_:
                return m
        return None

    def init(self):
        self.send({"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {
            "protocolVersion": "2025-03-26", "capabilities": {},
            "clientInfo": {"name": "latency-probe", "version": "1"}}})
        m = self.recv(1, 120)
        self.send({"jsonrpc": "2.0", "method": "notifications/initialized"})
        self.seq = 1
        return bool(m and "result" in m)

    def call(self, name, args):
        self.seq += 1
        t0 = time.perf_counter()
        self.send({"jsonrpc": "2.0", "id": self.seq, "method": "tools/call",
                   "params": {"name": name, "arguments": args}})
        m = self.recv(self.seq)
        dt = time.perf_counter() - t0
        ok = bool(m and "result" in m and not m["result"].get("isError"))
        err = None if ok else json.dumps(m, ensure_ascii=False)[:300]
        return dt, ok, err

def main():
    px = {ep: Proxy(ep) for ep in ENDPOINTS}
    with open(OUT, "a", buffering=1) as f:
        def rec(**kw):
            kw["wall_time"] = time.strftime("%Y-%m-%dT%H:%M:%S%z")
            f.write(json.dumps(kw, ensure_ascii=False) + "\n")

        for ep in ENDPOINTS:
            t = time.perf_counter()
            ok = px[ep].init()
            rec(kind="init", endpoint=ep, seconds=round(time.perf_counter() - t, 4), ok=ok)
        for label, tool, args in TOOLS:
            for i in range(N):
                order = ENDPOINTS if i % 2 == 0 else ENDPOINTS[::-1]
                for ep in order:
                    dt, ok, err = px[ep].call(tool, args)
                    rec(kind="call", test=label, endpoint=ep, iter=i,
                        seconds=round(dt, 4), ok=ok, error=err)
        for q in px.values():
            q.p.terminate()

main()

import json,sys,statistics as s
rows=[json.loads(l) for l in open(sys.argv[1])]
print("init:",[(r["endpoint"],r["seconds"],r["ok"]) for r in rows if r["kind"]=="init"])
calls=[r for r in rows if r["kind"]=="call"]
print("failures:",[r for r in calls if not r["ok"]] or "none")
def q(v,p): v=sorted(v); return v[min(len(v)-1,int(round(p*(len(v)-1))))]
for t in ("sts_run_script","list_regions"):
    for ep in ("ap-northeast-1","us-east-1"):
        a=[r for r in calls if r["test"]==t and r["endpoint"]==ep]
        first=a[0]["seconds"]; rest=[r["seconds"] for r in a[1:]]
        print(f"{t:15s} {ep:15s} first={first:.2f}s  from 2nd onward n={len(rest)} min={min(rest):.2f} med={s.median(rest):.2f} p90={q(rest,.9):.2f} max={max(rest):.2f} mean={s.mean(rest):.2f}")
    # Paired differences (Tokyo - Virginia for the same iteration)
    d=[]
    for i in range(1,30):
        tk=[r for r in calls if r["test"]==t and r["iter"]==i and r["endpoint"]=="ap-northeast-1"][0]["seconds"]
        us=[r for r in calls if r["test"]==t and r["iter"]==i and r["endpoint"]=="us-east-1"][0]["seconds"]
        d.append(us-tk)
    print(f"{t:15s} paired diff (Virginia-Tokyo) med={s.median(d):+.2f}s mean={s.mean(d):+.2f}s Tokyo faster={sum(x>0 for x in d)}/{len(d)}")