# Always install the @preview tag
npm install -g @aws/agentcore@preview
agentcore --version   # should show 1.0.0-preview.x

# Prerequisites
# Node.js 20.x or later
# uv for Python agents: brew install uv
# AWS credentials: aws configure

# Upgrading from old Python toolkit
pip uninstall bedrock-agentcore-starter-toolkit

# Check for updates
agentcore update          # Check and install
agentcore update --check  # Check only

agentcore deploy -y
agentcore status --json
agentcore invoke "Hello"
agentcore help modes   # Explains both modes in detail

# Human-readable status
agentcore status

# Machine-readable JSON
agentcore status --json

# Pipe through jq to extract specific fields
agentcore status --json | jq '.resources[] | select(.resourceType == "agent")'

# Invoke and extract just the response text
agentcore invoke "Hello" --json | jq -r '.response'

# Use in CI — check deployment success
agentcore deploy -y --json | jq '.success'

agentcore deploy --dry-run     # Show what CDK would deploy
agentcore deploy --diff        # Show CDK diff (what changes)
agentcore remove all --dry-run # Preview what would be removed
agentcore create --name Foo --defaults --dry-run  # Preview project creation

agentcore validate           # Validate project.json in current dir
agentcore validate -d ./path # Validate a specific project directory

agentcore status              # All resources in default target
agentcore status --json       # JSON output
agentcore status --runtime MyAgent     # Filter to one agent
agentcore status --type memory         # Filter by resource type
agentcore status --state deployed      # Filter by state

# Resource types: agent, harness, runtime-endpoint, memory, credential,
#                 gateway, evaluator, online-eval, policy-engine, policy,
#                 config-bundle, ab-test

# Minimal — wizard fills the rest
agentcore create

# Fully non-interactive agent project (requires ALL THREE: --framework, --model-provider, --memory)
agentcore create \
  --name MyProject \
  --framework Strands \
  --model-provider Bedrock \
  --memory shortTerm

# With long-and-short-term memory
agentcore create \
  --name MyProject \
  --framework Strands \
  --model-provider Bedrock \
  --memory longAndShortTerm

# VPC networking (for private environments)
agentcore create \
  --name MyProject \
  --defaults \
  --network-mode VPC \
  --subnets subnet-abc,subnet-def \
  --security-groups sg-123

# Preview without creating
agentcore create --name MyProject --defaults --dry-run

# Note: --defaults creates a HARNESS project. For an agent project, use --framework instead.
agentcore create \
  --name MyProject \
  --framework Strands \
  --model-provider Bedrock \
  --memory none

MyProject/
├── agentcore/
│   ├── project.json            # Resource config (one agent already defined)
│   ├── aws-targets.json        # Default target (your account + region)
│   └── .env.local              # Gitignored secrets placeholder
├── cdk/                        # Generated CDK app (at project ROOT)
└── app/
    └── MyAgent/                # Agent source code
        ├── main.py             # Entry point with @app.entrypoint decorator
        └── pyproject.toml      # Python deps

agentcore validate           # Validates current directory
agentcore validate -d ./path # Validate a specific project

agentcore validate && agentcore deploy -y

# Preview before deploying
agentcore deploy --diff        # Show what changes in CloudFormation
agentcore deploy --dry-run     # Full synthesis without deploying

# Deploy with verbose output
agentcore deploy -y -v

# Deploy to a named target
agentcore deploy --target staging -y

# JSON output for CI/CD
agentcore deploy -y --json

agentcore status              # All resources
agentcore status --json       # JSON output
agentcore status --type agent
agentcore status --type memory
agentcore status --runtime MyAgent
agentcore status --state deployed
agentcore status --state pending-removal

agentcore package                      # Package all runtimes
agentcore package --runtime MyAgent    # Package one runtime
agentcore package -d ./my-project      # Specify project directory

# aws-targets.json
[
  { "name": "default", "description": "Development", "account": "123456789012", "region": "us-east-1" },
  { "name": "staging", "description": "Staging", "account": "987654321098", "region": "us-east-1" }
]

# Deploy to a specific environment
agentcore deploy --target staging -y
agentcore status --target staging
agentcore invoke "Hello" --target staging

agentcore remove agent --name MyAgent -y
agentcore remove memory --name SharedMemory -y
agentcore remove credential --name OpenAI
agentcore remove gateway --name MyGateway

# Nuclear option — remove everything
agentcore remove all -y
agentcore remove all --dry-run  # Preview first

# Add to project.json → deploy → deployed-state.json updated with ARNs
# Remove from project.json → deploy → resource deleted from AWS

# deployed-state.json is auto-managed — NEVER edit it manually
# It tracks: ARNs, endpoint URLs, last deploy timestamps

agentcore add agent \
  --name MyAgent \
  --framework Strands \
  --model-provider Bedrock \
  --memory shortTerm

agentcore add agent \
  --name MyAgent \
  --type byo \
  --code-location ./my-existing-agent \
  --entrypoint main.py \
  --language Python

agentcore add agent \
  --name MyAgent \
  --type import \
  --agent-id AGENT123 \
  --agent-alias-id ALIAS456 \
  --region us-east-1 \
  --framework Strands \
  --memory none

agentcore add agent \
  --name <name>               # Agent name (max 48 chars)
  --type create|byo|import    # How to create the agent
  --framework <fw>            # Strands, LangChain_LangGraph, etc.
  --model-provider <p>        # Bedrock, Anthropic, OpenAI, Gemini
  --api-key <key>             # For non-Bedrock providers
  --memory none|shortTerm|longAndShortTerm
  --build CodeZip|Container
  --protocol HTTP|MCP|A2A
  --network-mode PUBLIC|VPC
  --authorizer-type AWS_IAM|CUSTOM_JWT
  --idle-timeout <seconds>    # Kill session after N seconds idle
  --max-lifetime <seconds>    # Max session lifetime
  --code-location <path>      # BYO only
  --entrypoint <file>         # BYO only, default: main.py
  --agent-id <id>             # Import only
  --agent-alias-id <id>       # Import only

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from strands import Agent
from strands.models import BedrockModel

app = BedrockAgentCoreApp()

@app.entrypoint
async def invoke(payload, context):
    session_id = getattr(context, 'session_id', 'default-session')
    user_id = getattr(context, 'user_id', 'default-user')

    agent = Agent(
        model=BedrockModel(model_id="us.anthropic.claude-sonnet-4-5-20250514-v1:0"),
        system_prompt="You are a helpful assistant.",
    )

    response = await agent.invoke_async(payload)
    return {"response": str(response)}

# Start dev server (opens browser chat UI by default)
agentcore dev

# Use terminal TUI instead of browser
agentcore dev --no-browser

# Non-interactive — logs to stdout (useful in one terminal, invoke in another)
agentcore dev --logs

# Target a specific runtime (required when multiple agents in project)
agentcore dev --runtime MyAgent

# Use a different port
agentcore dev --port 3000

# While agentcore dev is running in one terminal, invoke from another:
agentcore dev "What can you do?"
agentcore dev "Tell me a long story" --stream
agentcore dev "Hello" --runtime MyAgent

# MCP protocol dev commands
agentcore dev list-tools
agentcore dev call-tool --tool myTool --input '{"arg": "value"}'

# Basic invocation
agentcore invoke "What can you do?"

# Stream the response in real-time
agentcore invoke "Explain quantum computing" --stream

# Continue an existing session (multi-turn conversation)
agentcore invoke "What did I ask before?" --session-id abc123

# Invoke a specific runtime
agentcore invoke --runtime MyAgent "Hello"

# Invoke against a specific deployment target
agentcore invoke "Hello" --target staging

# JSON output
agentcore invoke "Hello" --json

# Set a user ID (for memory namespacing)
agentcore invoke "Hello" --user-id alice

# Long structured prompt from file
agentcore invoke --prompt-file ./test-prompt.json --json

# MCP protocol agents
agentcore invoke call-tool --tool myTool --input '{"key": "value"}'

# JWT auth agents
agentcore invoke "Hello" --bearer-token <your-jwt-token>

# List files in the agent directory
agentcore invoke --exec "ls -la /app"

# Check environment variables
agentcore invoke --exec "env | grep MEMORY"

# Check OS/environment
agentcore invoke --exec "cat /etc/os-release"

# Run a Python script inside the runtime
agentcore invoke --exec "python script.py"

# With timeout (default: 60s)
agentcore invoke --exec "python long-script.py" --timeout 120

# Also works locally
agentcore dev --exec "pip list"

# After deploying, these are auto-injected into agentcore dev:
AGENTCORE_GATEWAY_MYGATEWAY_URL=https://bedrock-agentcore.us-east-1.amazonaws.com/...
AGENTCORE_GATEWAY_MYGATEWAY_MANAGED_OAUTH_TOKEN=...

SEMANTIC     → /users/{actorId}/facts
USER_PREFERENCE → /users/{actorId}/preferences
SUMMARIZATION → /summaries/{actorId}/{sessionId}
EPISODIC     → /episodes/{actorId}/{sessionId}
             → /episodes/{actorId} (reflections)

agentcore add memory \
  --name SharedMemory \
  --strategies SEMANTIC,SUMMARIZATION,USER_PREFERENCE,EPISODIC \
  --expiry 30           # Days until events expire (7-365, default 30)

# With Kinesis streaming
agentcore add memory \
  --name MyMemory \
  --strategies SEMANTIC \
  --data-stream-arn arn:aws:kinesis:us-east-1:123456789012:stream/my-stream \
  --stream-content-level FULL_CONTENT

{
  "memories": [
    {
      "name": "MyMemory",
      "eventExpiryDuration": 30,
      "strategies": [
        { "type": "SEMANTIC" },
        { "type": "SUMMARIZATION" },
        { "type": "USER_PREFERENCE" },
        { "type": "EPISODIC", "reflectionNamespaces": ["/episodes/{actorId}"] }
      ]
    }
  ]
}

import os
memory_id = os.getenv("MEMORY_MYMEMORY_ID")

import os
from bedrock_agentcore.memory.integrations.strands.config import AgentCoreMemoryConfig, RetrievalConfig
from bedrock_agentcore.memory.integrations.strands.session_manager import AgentCoreMemorySessionManager

MEMORY_ID = os.getenv("MEMORY_MYMEMORY_ID")
REGION = os.getenv("AWS_REGION")

def get_memory_session_manager(session_id: str, actor_id: str):
    if not MEMORY_ID:
        return None
    retrieval_config = {
        f"/users/{actor_id}/facts": RetrievalConfig(top_k=3, relevance_score=0.5),
        f"/summaries/{actor_id}/{session_id}": RetrievalConfig(top_k=3, relevance_score=0.5)
    }
    return AgentCoreMemorySessionManager(
        AgentCoreMemoryConfig(
            memory_id=MEMORY_ID, session_id=session_id,
            actor_id=actor_id, retrieval_config=retrieval_config,
        ), REGION
    )

# 1. Add memory resource
agentcore add memory --name MyMemory --strategies SEMANTIC,SUMMARIZATION

# 2. Create memory directory
mkdir -p app/MyAgent/memory

# 3. Create app/MyAgent/memory/session.py with session manager code (see above)

# 4. Update main.py to import and use it:
# from memory.session import get_memory_session_manager
# session_manager = get_memory_session_manager(session_id, user_id)
# agent = Agent(model=..., session_manager=session_manager)

# 5. Deploy
agentcore deploy

# Recommended order: gateway BEFORE agent (new agents auto-wire gateway client code)
# 1. Create project
agentcore create --name MyProject --framework Strands --model-provider Bedrock --memory none
cd MyProject

# 2. Add gateway
agentcore add gateway --name my-gateway

# 3. Add target(s)
agentcore add gateway-target \
  --type mcp-server \
  --name weather-tools \
  --endpoint https://mcp.example.com/mcp \
  --gateway my-gateway

# 4. Create agent (automatically gets gateway client code)
agentcore add agent --name MyAgent --framework Strands --model-provider Bedrock --memory none

# 5. Deploy
agentcore deploy -y

# Simplest (no auth — dev/testing)
agentcore add gateway --name my-gateway

# Production with CUSTOM_JWT
agentcore add gateway \
  --name my-gateway \
  --authorizer-type CUSTOM_JWT \
  --discovery-url https://idp.example.com/.well-known/openid-configuration \
  --allowed-audience my-api \
  --allowed-clients my-client-id \
  --client-id agent-client-id \
  --client-secret agent-client-secret

agentcore add gateway-target \
  --type mcp-server \
  --name weather-tools \
  --endpoint https://mcp.example.com/mcp \
  --gateway my-gateway \
  --outbound-auth oauth \
  --oauth-client-id my-client \
  --oauth-client-secret my-secret \
  --oauth-discovery-url https://auth.example.com/.well-known/openid-configuration

agentcore add gateway-target \
  --type api-gateway \
  --name PetStore \
  --rest-api-id abc123 \
  --stage prod \
  --tool-filter-path '/pets/*' \
  --tool-filter-methods GET,POST \
  --gateway my-gateway

# Requires outbound auth (oauth or api-key)
agentcore add gateway-target \
  --type open-api-schema \
  --name PetStoreAPI \
  --schema specs/petstore.json \
  --gateway my-gateway \
  --outbound-auth oauth \
  --credential-name MyOAuth

# IAM role auth exclusively — no outbound auth flags needed
agentcore add gateway-target \
  --type smithy-model \
  --name MyService \
  --schema models/service.json \
  --gateway my-gateway

# IAM role auth exclusively
agentcore add gateway-target \
  --type lambda-function-arn \
  --name MyLambdaTools \
  --lambda-arn arn:aws:lambda:us-east-1:123456789012:function:my-func \
  --tool-schema-file tools.json \
  --gateway my-gateway

agentcore add credential \
  --name OpenAI \
  --api-key sk-...

# Or just name it — CLI will prompt for the key
agentcore add credential --name MyTool

agentcore add credential \
  --name MyOAuthProvider \
  --type oauth \
  --discovery-url https://idp.example.com/.well-known/openid-configuration \
  --client-id my-client-id \
  --client-secret my-client-secret \
  --scopes read,write

{
  "credentials": [
    { "authorizerType": "ApiKeyCredentialProvider", "name": "OpenAI" },
    {
      "authorizerType": "OAuthCredentialProvider",
      "name": "MyOAuthProvider",
      "discoveryUrl": "https://idp.example.com/.well-known/openid-configuration",
      "scopes": ["read", "write"]
    }
  ]
}

# API key credential named "OpenAI" in project "MyProject"
AGENTCORE_CREDENTIAL_MYPROJECTOPENAI=sk-...

# OAuth credential named "MyOAuth" in project "MyProject"
AGENTCORE_CREDENTIAL_MYPROJECTMYOAUTH_CLIENT_ID=my-client-id
AGENTCORE_CREDENTIAL_MYPROJECTMYOAUTH_CLIENT_SECRET=my-secret

# Named credential (reusable across multiple targets)
agentcore add credential \
  --name MyOAuthProvider \
  --type oauth \
  --discovery-url https://auth.example.com/.well-known/openid-configuration \
  --client-id my-client \
  --client-secret my-secret

agentcore add gateway-target \
  --type mcp-server \
  --name secure-tools \
  --endpoint https://api.example.com/mcp \
  --gateway my-gateway \
  --outbound-auth oauth \
  --credential-name MyOAuthProvider

# Inline (single-target, not reusable)
agentcore add gateway-target \
  --type mcp-server \
  --name secure-tools \
  --endpoint https://api.example.com/mcp \
  --gateway my-gateway \
  --outbound-auth oauth \
  --oauth-client-id my-client \
  --oauth-client-secret my-secret \
  --oauth-discovery-url https://auth.example.com/.well-known/openid-configuration

agentcore add agent \
  --name MyAgent \
  --framework Strands \
  --authorizer-type CUSTOM_JWT \
  --discovery-url https://idp.example.com/.well-known/openid-configuration \
  --allowed-audience my-api \
  --allowed-clients my-client-id \
  --allowed-scopes read write \
  --client-id agent-bearer-client \
  --client-secret agent-bearer-secret \
  --custom-claims '[{"claim": "tenant_id", "value": "acme-corp"}]'

# Stream logs in real-time (follow mode — Ctrl+C to stop)
agentcore logs

# Target a specific runtime
agentcore logs --runtime MyAgent

# Search historical logs (last 1 hour for errors)
agentcore logs --since 1h --level error

# Search a time range
agentcore logs --since 2d --until 1d --query "timeout"

# JSON Lines output (one JSON object per line)
agentcore logs --json

# Limit number of lines
agentcore logs --since 1h -n 100

# List recent traces
agentcore traces list
agentcore traces list --runtime MyAgent --limit 50
agentcore traces list --since 1h

# Download a full trace by ID
agentcore traces get <traceId>
agentcore traces get abc123 --output ./debug-trace.json
agentcore traces get abc123 --runtime MyAgent

# Pattern 1: Find recent errors
agentcore logs --since 1h --level error

# Pattern 2: Debug a specific invocation
agentcore invoke "Hello" --json > response.json
agentcore traces list --runtime MyAgent --limit 5
agentcore traces get <traceId> --output ./debug.json

# Pattern 3: Real-time monitoring while testing
# Terminal 1: agentcore logs --runtime MyAgent
# Terminal 2: agentcore invoke "Test message"

# Pattern 4: Search for a specific error
agentcore logs --since 24h --level error --query "timeout"

# Pattern 5: JSON pipeline for custom analysis
agentcore logs --since 1h --level error --json | \
  jq -r '[.timestamp, .message] | @tsv'

# Interactive wizard
agentcore add evaluator

# Non-interactive
agentcore add evaluator \
  --name ResponseQuality \
  --level SESSION \
  --model us.anthropic.claude-sonnet-4-5-20250514-v1:0 \
  --instructions "Evaluate the agent response quality. Context: {context}" \
  --rating-scale 1-5-quality

# SESSION — did the agent complete the task?
"Evaluate whether the agent fulfilled the user's request. Context: {context}"

# TRACE — per-turn accuracy
"Rate the accuracy of this response. Context: {context}. Response: {assistant_turn}"

# TOOL_CALL — did it pick the right tool?
"Evaluate tool selection. Context: {context}. Tool call: {tool_turn}"

# Evaluate a specific agent against recent traces
agentcore run eval \
  --runtime MyAgent \
  --evaluator ResponseQuality \
  --days 7

# Multiple evaluators
agentcore run eval \
  --runtime MyAgent \
  --evaluator ResponseQuality Builtin.Faithfulness \
  --days 14

# Target a specific session
agentcore run eval \
  --runtime MyAgent \
  --evaluator ResponseQuality \
  --session-id abc123 \
  --days 7

# Save results to file
agentcore run eval --runtime MyAgent --evaluator ResponseQuality --days 7 --output ./eval-result.json

# View eval history
agentcore evals history
agentcore evals history --runtime MyAgent --limit 5
agentcore evals history --json

# Set up continuous evaluation (samples X% of live requests)
agentcore add online-eval \
  --name QualityMonitor \
  --runtime MyAgent \
  --evaluator ResponseQuality Builtin.Faithfulness \
  --sampling-rate 10   # evaluate 10% of requests

# Enable immediately on deploy
agentcore add online-eval \
  --name QualityMonitor \
  --runtime MyAgent \
  --evaluator ResponseQuality \
  --sampling-rate 5 \
  --enable-on-create

# Pause and resume
agentcore pause online-eval QualityMonitor
agentcore resume online-eval QualityMonitor

# Use a builtin — no custom definition needed
agentcore run eval --runtime MyAgent --evaluator Builtin.Faithfulness

# Mix builtins with custom evaluators
agentcore run eval --runtime MyAgent --evaluator ResponseQuality Builtin.Faithfulness

# Wrong order — will fail if referenced by an online eval config
agentcore remove evaluator --name ResponseQuality

# Right order: remove online eval config first
agentcore remove online-eval --name QualityMonitor
agentcore remove evaluator --name ResponseQuality

# Run eval and fail pipeline if score is below threshold
result=$(agentcore run eval --runtime MyAgent --evaluator ResponseQuality --days 1 --json)
score=$(echo "$result" | jq '.run.results[0].aggregateScore')

if (( $(echo "$score < 0.7" | bc -l) )); then
  echo "Quality gate FAILED: score $score < 0.7"
  exit 1
fi

echo "Quality gate PASSED: score $score"

# 1. Add a custom evaluator
agentcore add evaluator \
  --name ResponseQuality \
  --level SESSION \
  --model us.anthropic.claude-sonnet-4-5-20250514-v1:0 \
  --instructions "Evaluate whether the agent fulfilled the user's request. Context: {context}"

# 2. Deploy (creates the evaluator in AWS)
agentcore deploy -y

# 3. Generate traces
agentcore invoke "Hello, what can you do?"
agentcore invoke "Search AWS docs for S3 pricing"

# 4. Wait ~10 min, then run on-demand eval
agentcore run eval --runtime MyAgent --evaluator ResponseQuality --days 1

# 5. Review results
agentcore evals history --runtime MyAgent

# 6. Set up continuous monitoring
agentcore add online-eval \
  --name QualityMonitor \
  --runtime MyAgent \
  --evaluator ResponseQuality \
  --sampling-rate 10
agentcore deploy -y

# Add a config bundle to your project
agentcore add config-bundle --name MyBundle

# List versions of a bundle
agentcore config-bundle versions MyBundle
# or: agentcore cb versions MyBundle

# Diff two versions
agentcore cb diff MyBundle --v1 1 --v2 2

# Create a new branch (for A/B testing)
agentcore cb create-branch MyBundle --branch experiment-a

# Promote a version (make it the primary)
agentcore promote config-bundle MyBundle --version 3

# View A/B test details and results
agentcore ab-test <testName>

# List A/B tests (use status, not list)
agentcore status --type ab-test

agentcore add agent \
  --name MyAgent \
  --framework Strands \
  --model-provider Bedrock \
  --with-config-bundle

{
  "runtimes": [
    {
      "name": "MyAgent",
      "configBundleName": "MyBundle"
    }
  ]
}

# Run batch evaluation
agentcore run batch-evaluation \
  --runtime MyAgent \
  --evaluator ResponseQuality \
  --days 30

# Stop a running batch evaluation
agentcore stop batch-evaluation <jobId>

# View batch eval history
agentcore evals history --runtime MyAgent

# Run recommendation analysis
agentcore run recommendation \
  --runtime MyAgent \
  --evaluator ResponseQuality \
  --days 7

# View recommendation history
agentcore recommendations
agentcore recommendations --runtime MyAgent

# Add a policy engine (attached to a gateway)
agentcore add policy-engine \
  --name MyPolicyEngine \
  --gateway my-gateway \
  --mode ENFORCE   # or LOG_ONLY

# Add a Cedar policy to the engine
agentcore add policy \
  --name AllowReadonly \
  --engine MyPolicyEngine \
  --policy-file ./policies/readonly.cedar

# Create gateway with policy engine
agentcore add gateway \
  --name my-gateway \
  --policy-engine MyPolicyEngine \
  --policy-engine-mode ENFORCE

# Import from starter toolkit project
agentcore import --source ./old-toolkit-project

# Import a specific runtime by ARN
agentcore import --runtime-arn arn:aws:bedrock-agentcore:...

# Import a memory by ARN
agentcore import --memory-arn arn:aws:bedrock-agentcore:...

# Import a gateway
agentcore import --gateway-arn arn:aws:bedrock-agentcore:...

# Create an agent that exposes the A2A protocol
agentcore add agent \
  --name WorkerAgent \
  --framework Strands \
  --protocol A2A

agentcore add agent \
  --name SpecialistAgent \
  --framework Strands \
  --protocol MCP

# Create with container build
agentcore add agent \
  --name MyAgent \
  --build Container \
  --framework Strands

# Customize the Dockerfile
cat app/MyAgent/Dockerfile

# Dev with container
agentcore dev            # builds and runs Docker locally
agentcore dev --exec "pip list"  # exec into local container

agentcore add agent \
  --name PrivateAgent \
  --framework Strands \
  --network-mode VPC \
  --subnets subnet-abc123,subnet-def456 \
  --security-groups sg-abc123

#!/bin/bash
# 1. Validate config
agentcore validate || exit 1

# 2. Preview changes
agentcore deploy --diff

# 3. Deploy
agentcore deploy -y --json

# 4. Verify deployment
agentcore status --json | jq '.resources[] | select(.state != "deployed")' | \
  grep -q '.' && { echo "Some resources not deployed!"; exit 1; }

# 5. Run smoke test
agentcore invoke "Health check" --json | jq -e '.response' || exit 1

# 6. Wait for traces
sleep 300  # 5 min

# 7. Quality gate
score=$(agentcore run eval --runtime MyAgent --evaluator QualityCheck --days 1 --json | \
  jq '.run.results[0].aggregateScore')
if (( $(echo "$score < 0.7" | bc -l) )); then
  echo "Quality gate failed: $score < 0.7"
  exit 1
fi
echo "Pipeline passed! Score: $score"

agentcore telemetry --status    # Check current setting
agentcore telemetry --enable    # Opt in to anonymous analytics
agentcore telemetry --disable   # Opt out

{
  "name": "MyProject",
  "tags": {
    "Environment": "production",
    "Team": "platform",
    "CostCenter": "engineering"
  },
  "runtimes": [
    {
      "name": "MyAgent",
      "tags": {
        "Environment": "staging"
      }
    }
  ]
}