# Jalankan A/B pengujian dengan perutean berbasis target
Gunakan pola routing berbasis target ketika perubahan yang Anda uji melibatkan perubahan kode, upgrade kerangka kerja, atau implementasi agen yang sama sekali berbeda. Target-based routing merutekan lalu lintas antara beberapa versi AgentCore Runtime yang sama (bernama endpoint), atau antara Runtime yang sama sekali berbeda. AgentCore AgentCore Gateway mendaftarkan setiap titik akhir sebagai target terpisah dan merutekan setiap sesi ke satu titik akhir atau yang lain berdasarkan bobot lalu lintas A/B pengujian.
Konfigurasi kunci untuk A/B pengujian berbasis target:
+ Konfigurasi varian: `variantConfiguration.target` dengan nama target AgentCore Gateway
+ Konfigurasi evaluasi: `perVariantOnlineEvaluationConfig` (satu konfigurasi evaluasi online per varian, karena setiap titik akhir memiliki grup lognya sendiri)
+ Filter gateway: `gatewayFilter.targetPaths` cakupan AgentCore Gateway mana yang dilalui oleh A/B tes yang dicegat
Panduan ini menyebarkan dua versi agen dukungan pelanggan - satu menggunakan Claude Sonnet (kontrol) dan satu menggunakan Claude Opus (perawatan) - membuat titik akhir bernama untuk setiap versi, membuat A/B tes, mengirim lalu lintas, meninjau hasil, dan menyebarkan pemenang.
**catatan**
Panduan ini untuk agen yang dihosting di Runtime. AgentCore Jika agen Anda berjalan **di luar** AgentCore Runtime (agen pihak ketiga atau yang dihosting sendiri — misalnya di AWS Lambda), lihat [Menjalankan A/B pengujian untuk agen yang dihosting di](ab-testing-3p-agents.md) luar. AgentCore
Untuk perbandingan rinci pola A/B pengujian, lihat [Memilih pola](ab-testing.md#ab-testing-pattern-comparison).
## Langkah 1: Buat proyek
Buat proyek dengan AgentCore CLI:
```
agentcore create --name ABTestTargetBased --no-agent
cd ABTestTargetBased
```
## Langkah 2: Tambahkan runtime
Tambahkan runtime agen. Anda akan menerapkan dua versi runtime ini — satu untuk kontrol dan satu untuk perawatan — lalu membuat titik akhir bernama ke alias setiap versi.
```
agentcore add agent \
--name csAgent \
--language Python \
--framework Strands \
--model-provider Bedrock \
--memory none \
--build CodeZip
```
Struktur proyek:
```
ABTestTargetBased/
├── agentcore/
│ ├── agentcore.json
│ ├── aws-targets.json
│ └── cdk/
└── app/
└── csAgent/
├── main.py
└── pyproject.toml
```
## Langkah 3: Menyebarkan versi kontrol dan perawatan
Ganti `app/csAgent/main.py` dengan versi kontrol (menggunakan Claude Sonnet):
```
"""Customer support agent — control variant."""
from strands import Agent, tool
from strands.models.bedrock import BedrockModel
from bedrock_agentcore.runtime import BedrockAgentCoreApp
app = BedrockAgentCoreApp()
MODEL_ID = "global.anthropic.claude-sonnet-4-5-20250929-v1:0"
SYSTEM_PROMPT = "You are a helpful customer support assistant for Acme Store."
@tool
def lookup_order(order_id: str) -> str:
"""Look up an order by ID."""
orders = {
"ORD-1001": {"status": "delivered", "item": "Blue T-Shirt", "total": "$29.99"},
"ORD-1002": {"status": "in_transit", "item": "Running Shoes", "est_delivery": "2026-04-05"},
"ORD-1003": {"status": "delayed", "item": "Wireless Headphones", "days_late": 5},
}
return str(orders.get(order_id, {"error": f"Order {order_id} not found"}))
@tool
def initiate_return(order_id: str, reason: str) -> str:
"""Initiate a return for an order."""
return f"Return initiated for {order_id}. Reason: {reason}. Return label sent to customer email."
@tool
def apply_discount(order_id: str, discount_percent: int, reason: str) -> str:
"""Apply a discount to an order."""
return f"Applied {discount_percent}% discount to {order_id}. Reason: {reason}."
agent = Agent(
model=BedrockModel(model_id=MODEL_ID),
tools=[lookup_order, initiate_return, apply_discount],
system_prompt=SYSTEM_PROMPT,
)
@app.entrypoint
def invoke(payload, context):
result = agent(payload.get("prompt", "Hello"))
return {"response": result.message["content"][0]["text"]}
if __name__ == "__main__":
app.run()
```
Perbarui `app/csAgent/pyproject.toml` dependensi:
```
dependencies = [
"aws-opentelemetry-distro",
"bedrock-agentcore >= 1.8.0",
"boto3",
"botocore[crt] >= 1.35.0",
"strands-agents[otel] >= 1.13.0",
"opentelemetry-distro",
"opentelemetry-instrumentation",
]
```
Terapkan versi kontrol (ini membuat versi 1):
```
agentcore deploy
```
Sekarang perbarui `main.py` untuk menggunakan model yang berbeda untuk varian perawatan dan terapkan (ini membuat versi 2):
```
MODEL_ID = "global.anthropic.claude-opus-4-6-v1"
```
```
agentcore deploy
```
Buat titik akhir bernama untuk setiap versi dan terapkan:
```
agentcore add runtime-endpoint \
--runtime csAgent \
--endpoint control \
--version 1 \
--description "Control variant — Claude Sonnet"
agentcore add runtime-endpoint \
--runtime csAgent \
--endpoint treatment \
--version 2 \
--description "Treatment variant — Claude Opus"
agentcore deploy
```
Anda sekarang memiliki:
+ Runtime endpoint `control` — melayani versi 1 dengan Claude Sonnet.
+ Runtime endpoint `treatment` — melayani versi 2 dengan Claude Opus.
Verifikasi bahwa runtime berfungsi:
```
agentcore invoke --runtime csAgent --prompt "What is the status of order ORD-1003?"
```
Anda sekarang memiliki:
+ Runtime endpoint `control` — melayani versi 1 dengan Claude Sonnet.
+ Runtime endpoint `treatment` — melayani versi 2 dengan Claude Opus.
## Langkah 4: Buat konfigurasi evaluasi online
Setiap titik akhir memiliki grup lognya sendiri (nama grup log diakhiri dengan nama titik akhir), jadi Anda memerlukan satu konfigurasi evaluasi online per varian:
```
agentcore add online-eval \
--name controlEvalTb \
--runtime csAgent \
--endpoint control \
--evaluator "Builtin.Helpfulness" \
--sampling-rate 100.0 \
--enable-on-create
agentcore add online-eval \
--name treatmentEvalTb \
--runtime csAgent \
--endpoint treatment \
--evaluator "Builtin.Helpfulness" \
--sampling-rate 100.0 \
--enable-on-create
agentcore deploy
```
Setelah setiap penerapan, perhatikan konfigurasi evaluasi online ARN — Anda akan memerlukan keduanya saat membuat pengujian. A/B
Untuk detail selengkapnya tentang opsi dan konfigurasi evaluator, lihat [Membuat evaluasi online](create-online-evaluations.md).
## Langkah 5: Buat gateway dan target
A/B Pengujian berbasis target merutekan lalu lintas melalui AgentCore Gateway, jadi gateway dan dua targetnya harus sudah digunakan sebelum Anda memulai pengujian. Tambahkan gateway dan daftarkan setiap titik akhir runtime sebagai `http-runtime` target, lalu terapkan:
```
agentcore add gateway --name csGateway
agentcore add gateway-target \
--name customer-support-control \
--gateway csGateway \
--type http-runtime \
--runtime csAgent \
--runtime-endpoint control
agentcore add gateway-target \
--name customer-support-treatment \
--gateway csGateway \
--type http-runtime \
--runtime csAgent \
--runtime-endpoint treatment
agentcore deploy
```
## Langkah 6: Buat A/B tes
Mulai A/B tes dengan`agentcore run ab-test`. Setiap varian mereferensikan salah satu target gateway yang Anda buat dan memiliki konfigurasi evaluasi online-nya sendiri. Perintah memulai pengujian langsung pada layanan terhadap gateway yang sudah digunakan.
**Example**
```
agentcore run ab-test \
--mode target-based \
--name customerSupportTargetTest \
--gateway csGateway \
--runtime csAgent \
--control-target customer-support-control \
--treatment-target customer-support-treatment \
--control-online-eval controlEvalTb \
--treatment-online-eval treatmentEvalTb \
--control-weight 80 \
--treatment-weight 20
```
Tes berjalan segera setelah perintah kembali. Pass `--disable-on-create` untuk membuatnya berhenti. `--gateway`Bendera diperlukan dan harus mereferensikan gateway yang Anda gunakan di Langkah 5. Hanya satu tes yang dapat DIJALANKAN per gateway pada satu waktu. Perintah mencetak ID pekerjaan pengujian, yang juga tersedia dari `--json` sebagai `id` bidang. Anda memerlukan ID ini untuk perintah siklus hidup di bawah ini.
```
import boto3
import uuid
REGION = "us-west-2"
ACCOUNT_ID = "123456789012"
# Runtime ARNs from Step 2 deployment output
CONTROL_RUNTIME_ARN = f"arn:aws:bedrock-agentcore:{REGION}:{ACCOUNT_ID}:runtime/ABTestTargetBased_CustomerSupportControl-abc123"
TREATMENT_RUNTIME_ARN = f"arn:aws:bedrock-agentcore:{REGION}:{ACCOUNT_ID}:runtime/ABTestTargetBased_CustomerSupportTreatment-def456"
# Online evaluation config ARNs from Step 3
CONTROL_EVAL_ARN = f"arn:aws:bedrock-agentcore:{REGION}:{ACCOUNT_ID}:online-evaluation-config/controlEvalTb-abc123"
TREATMENT_EVAL_ARN = f"arn:aws:bedrock-agentcore:{REGION}:{ACCOUNT_ID}:online-evaluation-config/treatmentEvalTb-def456"
# IAM roles
GATEWAY_ROLE_ARN = f"arn:aws:iam::{ACCOUNT_ID}:role/AgentCoreGatewayRole"
AB_TEST_ROLE_ARN = f"arn:aws:iam::{ACCOUNT_ID}:role/ABTestRole"
cp_client = boto3.client("bedrock-agentcore-control", region_name=REGION)
dp_client = boto3.client("bedrock-agentcore", region_name=REGION)
# 1. Create an AgentCore Gateway
gateway_response = cp_client.create_gateway(
name="customerSupportTargetTest-gw",
roleArn=GATEWAY_ROLE_ARN,
authorizerType="AWS_IAM",
clientToken=str(uuid.uuid4()),
)
gateway_id = gateway_response["gatewayId"]
gateway_arn = gateway_response["gatewayArn"]
print(f"Created AgentCore Gateway: {gateway_id}")
# 2. Add control runtime as an AgentCore Gateway target
cp_client.create_gateway_target(
gatewayIdentifier=gateway_id,
name="customer-support-control",
targetConfiguration={
"http": {
"agentcoreRuntime": {
"arn": CONTROL_RUNTIME_ARN,
"qualifier": "DEFAULT"
}
}
},
clientToken=str(uuid.uuid4()),
)
print("Added target: customer-support-control")
# 3. Add treatment runtime as an AgentCore Gateway target
cp_client.create_gateway_target(
gatewayIdentifier=gateway_id,
name="customer-support-treatment",
targetConfiguration={
"http": {
"agentcoreRuntime": {
"arn": TREATMENT_RUNTIME_ARN,
"qualifier": "DEFAULT"
}
}
},
clientToken=str(uuid.uuid4()),
)
print("Added target: customer-support-treatment")
# 4. Create the A/B test
response = dp_client.create_ab_test(
name="customerSupportTargetTest",
gatewayArn=gateway_arn,
roleArn=AB_TEST_ROLE_ARN,
evaluationConfig={
"perVariantOnlineEvaluationConfig": [
{"name": "C", "onlineEvaluationConfigArn": CONTROL_EVAL_ARN},
{"name": "T1", "onlineEvaluationConfigArn": TREATMENT_EVAL_ARN}
]
},
gatewayFilter={
"targetPaths": ["/customer-support-control/*"]
},
variants=[
{
"name": "C",
"weight": 80,
"variantConfiguration": {
"target": {"name": "customer-support-control"}
}
},
{
"name": "T1",
"weight": 20,
"variantConfiguration": {
"target": {"name": "customer-support-treatment"}
}
}
],
enableOnCreate=True,
clientToken=str(uuid.uuid4()),
)
ab_test_id = response["abTestId"]
print(f"Created A/B test: {ab_test_id}")
print(f"Status: {response['status']}")
print(f"Execution status: {response['executionStatus']}")
```
## Langkah 7: Kirim lalu lintas melalui AgentCore Gateway
Setelah A/B pengujian berjalan, kirim lalu lintas melalui titik akhir HTTP AgentCore Gateway. AgentCore Gateway menetapkan setiap permintaan ke varian (kontrol atau perlakuan) berdasarkan ID sesi runtime.
### Cara kerja penugasan varian
AgentCore Gateway menggunakan `X-Amzn-Bedrock-AgentCore-Runtime-Session-Id` header untuk menentukan target mana yang akan mengarahkan lalu lintas ke. Header ini **opsional** — jika Anda tidak menyediakannya, runtime akan menghasilkan ID sesi secara otomatis. AgentCore Gateway kemudian menggunakan ID sesi (apakah Anda menyediakannya atau runtime yang dihasilkannya) untuk menetapkan permintaan ke varian berdasarkan bobot lalu lintas yang dikonfigurasi.
Penugasan sesi bersifat **lengket**: setelah ID sesi ditetapkan ke varian, semua permintaan berikutnya dengan ID sesi yang sama merutekan ke target yang sama. Ini memastikan pengalaman yang konsisten dalam sesi sambil tetap mendistribusikan sesi baru di seluruh varian sesuai dengan pembagian lalu lintas Anda.
### Menghasilkan lalu lintas untuk pengujian
Simpan skrip berikut sebagai`loadgen.sh`, ganti `` dan `` dengan nilai dari output penyebaran Anda. Anda juga dapat menyalin URL pemanggilan lengkap dari: `agentcore view ab-test `
```
#!/bin/bash
export AWS_ACCESS_KEY_ID=$(aws configure get aws_access_key_id)
export AWS_SECRET_ACCESS_KEY=$(aws configure get aws_secret_access_key)
export AWS_SESSION_TOKEN=$(aws configure get aws_session_token)
GATEWAY_URL="https://.gateway.bedrock-agentcore.us-west-2.amazonaws.com//invocations"
PROMPTS=(
"What is the status of order ORD-1003?"
"I want to return order ORD-1001, it doesn't fit."
"My order ORD-1003 is late. Can I get a discount?"
"Where is my order ORD-1002?"
"I need help with a return for order ORD-1001. The color is wrong."
"Can you check on order ORD-1003? I've been waiting forever."
"I'd like to cancel order ORD-1002 if it hasn't shipped yet."
"Order ORD-1003 is delayed again. This is unacceptable."
"What's your return policy for order ORD-1001?"
"My headphones order ORD-1003 still hasn't arrived. What can you do?"
)
for i in $(seq 1 30); do
PROMPT="${PROMPTS[$(( (i - 1) % ${#PROMPTS[@]} ))]}"
echo "=== Request $i: $PROMPT ==="
curl -s --aws-sigv4 "aws:amz:us-west-2:bedrock-agentcore" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "Content-Type: application/json" \
-H "X-Amzn-Bedrock-AgentCore-Runtime-Session-Id: $(uuidgen)" \
-d "{\"prompt\": \"$PROMPT\"}" \
-X POST \
"$GATEWAY_URL"
echo ""
sleep 2
done
```
Jalankan skrip .
```
bash loadgen.sh
```
## Langkah 8: Dapatkan hasil
Jajak pendapat A/B tes untuk memantau hasil saat ukuran sampel bertambah. Polling tidak mempengaruhi validitas statistik.
**Example**
Dapatkan hasil saat ini (ganti `` dengan ID pekerjaan dari Langkah 6):
```
agentcore view ab-test
```
Dapatkan hasil sebagai JSON:
```
agentcore view ab-test --json
```
Polling sampai hasil mencapai signifikansi statistik:
```
import boto3
import time
client = boto3.client("bedrock-agentcore", region_name="us-west-2")
ab_test_id = "customerSupportTargetTest-Ab1Cd2Ef3G"
while True:
response = client.get_ab_test(abTestId=ab_test_id)
status = response["status"]
exec_status = response["executionStatus"]
print(f"Status: {status}, Execution: {exec_status}")
results = response.get("results")
if results:
print(f"Analysis timestamp: {results.get('analysisTimestamp')}")
for metric in results["evaluatorMetrics"]:
evaluator = metric["evaluatorArn"]
control = metric["controlStats"]
print(f"\nEvaluator: {evaluator}")
print(f" Control: mean={control['mean']:.3f}, n={control['sampleSize']}")
for variant in metric["variantResults"]:
print(f" {variant['variantName']}: mean={variant['mean']:.3f}, "
f"n={variant['sampleSize']}, "
f"pValue={variant.get('pValue', 'N/A')}, "
f"significant={variant['isSignificant']}")
if variant["isSignificant"]:
print(f" >>> Statistically significant! "
f"Change: {variant.get('percentChange', 0):.1f}%")
# Check if any evaluator has reached significance
all_significant = all(
variant["isSignificant"]
for metric in results["evaluatorMetrics"]
for variant in metric["variantResults"]
)
if all_significant:
print("\nAll evaluators have reached statistical significance.")
break
time.sleep(300) # Poll every 5 minutes
```
**catatan**
Waktu yang diperlukan agar hasil muncul tergantung terutama pada batas waktu sesi yang dikonfigurasi dalam konfigurasi evaluasi online Anda. Sesi dianggap selesai setelah tidak ada permintaan baru yang tiba dalam jendela batas waktu. Setelah sesi berakhir, hasil biasanya muncul dalam 15 menit. Hasil terakumulasi karena lebih banyak sesi selesai — signifikansi statistik meningkat dengan ukuran sampel.
+ **P-nilai < 0,05 dan positif`percentChange`:** Perawatan secara signifikan lebih baik daripada kontrol. Pertimbangkan untuk menerapkan perawatan.
+ **nilai-p < 0,05 dan negatif`percentChange`:** Perawatannya jauh lebih buruk. Jaga kontrolnya.
+ **P-value >= 0.05:** Tidak cukup bukti untuk menyimpulkan perbedaan. Lanjutkan mengumpulkan sampel atau meningkatkan lalu lintas ke perawatan.
+ **Periksa semua evaluator:** Perawatan dapat meningkatkan satu metrik sementara regresi yang lain. Tinjau semua hasil evaluator sebelum memutuskan.
## Langkah 9: Konfirmasikan hasil dan hentikan A/B tes
Setelah A/B tes mencapai signifikansi statistik, tinjau hasilnya dan hentikan percobaan.
1. **Konfirmasikan signifikansi.** Verifikasi bahwa evaluator target memiliki `isSignificant: true` dan positif `percentChange` pada varian pengobatan (atau konfirmasikan kontrol adalah pemenang jika pengobatan mengalami kemunduran).
1. **Hentikan A/B tes.** Jalankan `agentcore stop ab-test -i `. Perutean lalu lintas segera berakhir dan semua permintaan kembali ke target default. Lihat [Lihat, jeda, lanjutkan, dan hentikan](ab-testing-manage.md#manage-ab-test-start-stop).
## Langkah 10: Menyebarkan pemenang
Setelah menghentikan A/B tes, rute semua lalu lintas ke varian pemenang.
```
agentcore promote ab-test -i
agentcore deploy
```
`promote`menghentikan A/B pengujian (jika masih berjalan), memperbarui titik akhir kontrol untuk menunjuk ke versi perawatan (misalnya, memperbarui `control` dari versi 1 ke versi 2), dan menghapus titik akhir perawatan. Jalankan `agentcore deploy` untuk menerapkan perubahan.
Atau, Anda dapat menyebarkan pemenang secara manual dengan melakukan salah satu hal berikut:
+ **Opsi A:** Gunakan [aturan perutean AgentCore Gateway](gateway-rules.md) untuk mengarahkan lalu lintas dari kedua target ke target pemenang.
+ **Opsi B:** Hapus target yang hilang dari AgentCore Gateway dan rute semua lalu lintas ke pemenang.
+ **Opsi C:** Perbarui target yang kalah untuk menunjuk ke titik akhir yang menang.
Setelah menyebarkan pemenang:
+ **Hapus A/B tes** untuk membersihkan sumber daya. Lihat [Menghapus A/B tes](ab-testing-manage.md#manage-ab-test-remove).
+ **Pantau baseline baru.** Evaluasi online melanjutkan sesi penilaian pada konfigurasi pemenang. Perhatikan regresi.
+ **Mulai iterasi berikutnya.** Jejak baru dari konfigurasi pemenang memberikan dasar untuk siklus rekomendasi berikutnya. Lihat [Cara Kerjanya](optimization-how-it-works.md).
## Memahami hasil
Saat Anda menelepon`GetABTest`, respons menyertakan `results` objek setelah pipeline agregasi telah memproses sesi yang cukup. Hasilnya berisi metrik per-evaluator yang dipecah berdasarkan varian.
### Struktur hasil
```
{
"results": {
"analysisTimestamp": "2026-04-30T18:45:00Z",
"evaluatorMetrics": [
{
"evaluatorArn": "arn:aws:bedrock-agentcore:us-west-2:123456789012:evaluator/Builtin.Helpfulness",
"controlStats": {
"variantName": "C",
"sampleSize": 24,
"mean": 0.72
},
"variantResults": [
{
"variantName": "T1",
"sampleSize": 6,
"mean": 0.85,
"absoluteChange": 0.13,
"percentChange": 18.1,
"pValue": 0.032,
"confidenceInterval": {
"lower": 0.02,
"upper": 0.24
},
"isSignificant": true
}
]
}
]
}
}
```
### Referensi bidang
| Bidang | Deskripsi |
| --- | --- |
| `analysisTimestamp` | Ketika layanan terakhir dihitung statistik. |
| `evaluatorMetrics` | Satu entri per evaluator dalam konfigurasi evaluasi online. |
| `controlStats.mean` | Skor evaluator rata-rata di semua sesi kontrol. |
| `controlStats.sampleSize` | Jumlah sesi skor untuk varian kontrol. |
| `variantResults[].mean` | Skor evaluator rata-rata di semua sesi perawatan. |
| `variantResults[].sampleSize` | Jumlah sesi yang dinilai untuk varian pengobatan. |
| `variantResults[].absoluteChange` | Perbedaan antara rata-rata pengobatan dan rata-rata kontrol. |
| `variantResults[].percentChange` | Persentase peningkatan (positif) atau regresi (negatif) relatif terhadap kontrol. |
| `variantResults[].pValue` | Probabilitas perbedaan yang diamati adalah karena kebetulan. Di bawah 0,05 menunjukkan signifikansi statistik. |
| `variantResults[].confidenceInterval` | Interval kepercayaan 95% untuk perubahan absolut (`lower`dan `upper` batas). |
| `variantResults[].isSignificant` | `true`ketika nilai-p < 0,05 dan ukuran sampel sudah cukup. |
## Pemecahan masalah
### A/B tes tidak menunjukkan hasil setelah mengirim lalu lintas
Hasil tidak segera muncul. Waktu yang dibutuhkan tergantung pada batas waktu sesi yang dikonfigurasi dalam konfigurasi evaluasi online Anda — sesi dianggap selesai hanya setelah tidak ada permintaan baru yang tiba dalam jendela batas waktu. Setelah sesi berakhir, harapkan hasil dalam waktu sekitar 15 menit.
Jika hasil masih tidak muncul setelah jendela ini:
+ **Verifikasi grup log eval online.** Konfigurasi evaluasi online harus mengarah ke grup log keluaran agen runtime. Jika konfigurasi eval online mereferensikan grup log yang berbeda (atau yang tidak menerima rentang dari runtime Anda), sesi tidak akan dinilai dan A/B tes tidak akan pernah membuahkan hasil.
+ **Periksa nama grup log.** Untuk perutean berbasis target, setiap titik akhir memiliki grup lognya sendiri (nama grup log diakhiri dengan nama titik akhir). Pastikan setiap konfigurasi eval online mereferensikan grup log titik akhir yang benar.
+ **Konfirmasikan bahwa runtime memancarkan rentang.** Periksa CloudWatch Log untuk grup log yang diharapkan. Atribut kunci yang Anda cari pada setiap rentang:
+ `aws.agentcore.gateway.routing_experiment_arn`
+ `aws.agentcore.gateway.routing_experiment_variant_name`(nilai: `C` atau`T1`)
+ `session.id`
+ **Verifikasi CLI-created vs konfigurasi manual.** Jika Anda menggunakan`agentcore add online-eval --runtime `, CLI secara otomatis mengkonfigurasi grup log yang benar. Jika Anda membuat konfigurasi eval online secara manual melalui API, pastikan AgentCore Online Eval `dataSourceConfig.cloudWatchLogs.logGroupNames` Config cocok dengan grup log rentang waktu proses Anda.