Menu
Activate when discussing deployment, AgentCore CLI, or production infrastructure
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Basé sur la classification professionnelle SOC
Activate when the user needs help with AWS access, credentials, Workshop Studio login, or environment setup
Activate when discussing game rules, player actions, scoring, fouls, cards, or match format
Activate when discussing strategy, tactics, or agent behavior design
Activate when the user chooses LangGraph or asks about LangChain/ReAct patterns
Activate when the user chooses Strands or asks about Strands SDK concepts
| name | bedrock-agentcore |
| description | Activate when discussing deployment, AgentCore CLI, or production infrastructure |
Enterprise-grade services for deploying and operating AI agents at scale. AgentCore eliminates undifferentiated infrastructure work — identity, memory, tool management, observability — so you can focus on agent logic.
AgentCore works with any framework (Strands, LangGraph, CrewAI, LlamaIndex) and any foundation model in or outside Amazon Bedrock.
Securely deploy and run agents at scale. Runtime provides:
Football context: Runtime hosts your football agent so it can respond to game ticks in real-time. Each deployed agent gets a unique Runtime ARN used for match registration.
Configuration file: .bedrock_agentcore.yaml in your agent project root defines runtime settings.
Context-aware agents with managed memory infrastructure:
Football context: Your agent can remember opponent tendencies from previous matches (long-term) and track patterns within the current match (short-term). Memory can be shared across your team — when one defender learns an opponent's dribbling pattern, all defenders gain that knowledge.
Secure tool discovery and management for agents:
Football context: Instead of hardcoding every tool into every player agent, Gateway lets agents discover the right tool for the moment — a midfielder under pressure finds the "quick pass" tool, while a striker in the box discovers the "power shot" tool.
Secure agent identity and access management:
Football context: Each player agent gets a unique identity with role-specific permissions. Your striker accesses shooting tools, your goalkeeper controls the penalty area, and your midfielder accesses passing tools — each agent only accesses actions relevant to their role.
Trace, debug, and monitor agent performance in production:
Football context: Trace your agent's decision-making step by step — which tools it called, what data it received, where logic failed. Monitor all 5 player agents simultaneously, identify performance bottlenecks, and optimize responsiveness.
Secure code execution in isolated sandbox environments:
Football context: Your agent can run physics calculations in real-time — given positions of players, goalkeeper, and defenders, calculate the optimal shooting angle and power dynamically instead of pre-programming every scenario.
Cloud-based browser runtime for AI agents:
Football context: Agents can browse tactical analysis sites, watch video clips of professional players, and extract positioning patterns to bring real-world football intelligence into your simulation.
.bedrock_agentcore.yaml config file# Test without LLM (rule-based fallback)
python test_local.py
# Test with LLM (Bedrock model)
python test_local.py --llm
Install from the Bedrock AgentCore Starter Toolkit:
https://github.com/aws/bedrock-agentcore-starter-toolkit
agentcore deploy
This packages your agent code, uploads it to AgentCore Runtime, and starts the service. On success you receive a Runtime ARN — a unique Amazon Resource Name identifying your deployed agent.
Find your Runtime ARN in the Bedrock AgentCore console:
https://us-east-1.console.aws.amazon.com/bedrock-agentcore/agents?region=us-east-1
The Runtime ARN looks like:
arn:aws:bedrock-agentcore:<region>:<account-id>:runtime/<runtime-id>
Use the Runtime ARN to register your agent for football matches. Options:
Monitor your deployed agent with CloudWatch Logs:
aws logs tail /aws/bedrock-agentcore/runtimes/<runtime-id>-DEFAULT \
--log-stream-name-prefix "$(date +%Y/%m/%d)/[runtime-logs" \
--follow
This streams real-time logs showing:
After watching your agent play:
python test_local.py --llmagentcore deploy.bedrock_agentcore.yamlThis file in your agent project root configures the Runtime deployment:
# Example configuration
runtime:
name: my-football-agent
entry_point: src/main.py
requirements: requirements.txt
Enable detailed logging in your agent code to leverage AgentCore Observability:
For Strands agents:
import logging
logging.getLogger("strands").setLevel(logging.DEBUG)
logging.basicConfig(
format="%(levelname)s | %(name)s | %(message)s",
handlers=[logging.StreamHandler()]
)
For LangGraph agents:
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# Log key decision points
logger.info(f"Game state received: {state_summary}")
logger.info(f"Agent action: {action}")
Metrics via Strands SDK:
result = agent("Analyze game state...")
summary = result.metrics.get_summary()
print(f"Tokens used: {summary['accumulated_usage']['totalTokens']}")
print(f"Latency: {summary['accumulated_metrics']['latencyMs']}ms")
print(f"Tool calls: {summary['tool_usage']}")
After deployment, the Runtime ARN is your agent's identity in the competition system:
You can update your agent code and redeploy without changing the ARN (the runtime endpoint stays the same).
| Issue | Solution |
|---|---|
agentcore deploy fails | Check AWS credentials: aws sts get-caller-identity |
| Agent times out during match | Ensure response time < 500ms; use a faster model (Nova Micro) |
| No logs appearing | Verify the runtime ID in the log group path; check region |
| Runtime ARN not found | Check the AgentCore console; deployment may still be in progress |
| Model throttling errors | Add retry strategy in agent code; reduce token usage |