Blog
Strands Agents SDK Deploy — Visualize Agent Traces with OpenTelemetry
Enable the Strands Agents SDK's built-in OpenTelemetry support to visualize agent reasoning and tool calls as traces in Jaeger. Only 2 lines of code change required.
← All Tags
Tag: #ai-agents
Content tagged with "ai-agents"
Blog Posts
Blog
Strands Agents SDK Deploy — Managed Deployment with AgentCore CLI
Use the AgentCore CLI (Node.js) to deploy a Strands agent to Bedrock AgentCore with just agentcore create + deploy. Verified that session isolation enables conversation continuity across invocations.
Blog
Strands Agents SDK Deploy — Serverless Deployment to AWS Lambda
Deploy a Strands Agents SDK agent to AWS Lambda using the official Lambda Layer. Measured cold start Init Duration at ~1 second and warm start at under 1 second.
Blog
Strands Agents SDK Deploy — Turn Your Agent into an HTTP API with Docker
Wrap a Strands Agents SDK agent with FastAPI to create an HTTP API, then package it as a Docker container. Covers the async def hang pitfall and SSO credential issues encountered during verification.
Blog
Edge Cases to Verify Before Using Stateful MCP in Production
Tested Stateful MCP's 3 capabilities with a DynamoDB-backed expense tracker. Verified data integrity on Elicitation decline/cancel and fallback behavior on Sampling failure to provide production design guidance.
Blog
Strands Agents SDK Multi-Agent — Choosing the Right Multi-Agent Pattern
Run the same task with Agents as Tools, Swarm, and Graph, then compare structural differences via metrics. Establish selection criteria for choosing the right pattern per use case.
Blog
Strands Agents SDK Multi-Agent — Nest Swarm and Graph Together
Embed a Swarm as a node in a Graph to combine autonomous collaboration with structured workflows. Verify nested execution results and multi-agent Hooks for node monitoring.
Blog
Strands Agents SDK Multi-Agent — Structure Workflows with Graph
Build deterministic workflows with Strands Agents SDK's Graph pattern. Define sequential, parallel, conditional, and feedback loop workflows with GraphBuilder, verified with real execution results.
Blog
Strands Agents SDK Multi-Agent — Autonomous Agent Collaboration with Swarm
Run Strands Agents SDK's Swarm pattern hands-on and verify how agents autonomously hand off tasks to each other. Compare with the Agents as Tools pattern from the intro series.
Blog
Strands Agents SDK Practical — Optimize Agents with Metrics
Deep dive into Strands Agents SDK's result.metrics to analyze cycle counts, token usage, and tool execution times. Compare how tool design choices impact performance and identify optimization targets.
Blog
Strands Agents SDK Practical — Filter Agent I/O with Guardrails
Apply Bedrock Guardrails to Strands Agents SDK for automatic input/output filtering. Verify guardrail intervention behavior and implement shadow mode (monitor-only) using Hooks.
Blog
Strands Agents SDK Practical — Control the Agent Loop with Hooks
Use Strands Agents SDK Hooks to intercept the agent loop. Log tool calls, limit invocation counts, and modify results with real code examples showing how to control agent behavior in real time.
Blog
Strands Agents SDK Practical — Persist Conversations with Session Management
Use Strands Agents SDK's FileSessionManager to persist conversations to files and restore them after process restarts. Examine the stored data structure and the migration path to S3.
Blog
Strands Agents SDK Practical — Type-Safe LLM Output with Structured Output
Use Strands Agents SDK's Structured Output to convert LLM responses into type-safe Pydantic objects. Verify tool integration, automatic validation retries, and conversation history extraction with code and metrics.
Blog
Agentic AI security starts with treating agents like employees: Unpacking the 7 principles for financial services
A deep dive into the AWS Security Blog's agentic AI security framework for financial services. Reorganizes the 7 design principles into three axes—permissions, traceability, and controls—with Bedrock AgentCore implementation guidance.
Blog
Verifying AI-driven A/B test decision-making with Bedrock tool use
Hands-on verification of the AI-powered A/B testing engine from the AWS blog — implementing context-dependent variant selection with Bedrock Converse API tool use. Discovered that omitting context from the prompt reverses the variant choice, highlighting prompt design as the critical factor.
Blog
Persist agent workspace across stop/resume with Bedrock AgentCore Runtime managed session storage
Hands-on verification of AgentCore Runtime's new managed session storage. Tested file restoration after stop/resume, pip/git workspace persistence, session isolation, and graceful shutdown behavior with real measurement data.
Blog
AgentCore CLI in Practice — Build a Tech Trend Advisor with Key Features Combined
Combine Runtime, Memory, Gateway, and Evaluations into a single AgentCore CLI project to build a personalized tech trend advisor that remembers user expertise, searches the web for latest trends, and auto-measures response quality.
Blog
AgentCore CLI in Practice — Measure Agent Quality with Evaluations
Hands-on verification of AgentCore CLI Evaluations with a custom LLM-as-a-Judge evaluator. Covers on-demand evaluation of agent traces, region constraints for the Evaluator CloudFormation resource, and trace indexing timing.
Blog
AgentCore CLI in Practice — Connect External MCP Servers via Gateway
Hands-on verification of AgentCore CLI Gateway with an external MCP server target. Covers the critical project setup order, deployment-time connectivity checks, and the split between Gateway API and CloudFormation deployment.
Blog
AgentCore CLI in Practice — Persist Conversation Memory Across Sessions
Hands-on verification of AgentCore CLI Memory with SEMANTIC, USER_PREFERENCE, SUMMARIZATION, and EPISODIC strategies. Covers async extraction timing, session ID constraints, and the gap between local dev and deployed behavior.
Blog
AgentCore CLI in Practice — Deploy an AI Agent to AWS in Four Commands
Hands-on verification of the AgentCore CLI — from creating a Strands Agents project to local development, AWS deployment, and observability. CDK knowledge not required; initial deployment completes in about 90 seconds.
Blog
Agentic AI on EKS — Cognito Auth UI and HPA for the Agent Platform
Deploying Gradio + Cognito OAuth Web UI and HPA autoscaling to complete the full workshop architecture. Includes measured resource consumption across all 4 components.
Blog
Agentic AI on EKS — Multi-Agent Coordination with A2A
Validating A2A delegation from Travel Agent to Weather Agent on EKS. Two gotchas: agent card URL defaults to 0.0.0.0, and S3 session history poisons LLM context with stale URLs.
Blog
Agentic AI on EKS — Deploying AI Agents
Hands-on validation of the AWS 'Agentic AI on EKS' workshop. Covers Strands Agents SDK, MCP-based tool auto-discovery, and building container images with Kaniko on EKS.
Blog
Building a Voice Agent with Bedrock AgentCore Runtime WebRTC Support
Deploy a bidirectional voice streaming agent using AgentCore Runtime's new WebRTC support with Nova Sonic. Key finding: TURN-only mode is strongly recommended for AgentCore Runtime deployments.
Blog
Evaluating AI Agents with Strands Evals — Hands-on Testing of 6 Key Features
A practical walkthrough of Strands Evals' core features: deterministic checks, LLM-based scoring, multi-turn simulation, and auto-generated test cases. Includes gotchas discovered through real testing.
Blog
Install and Use Custom Libraries in Bedrock AgentCore Code Interpreter
Hands-on verification of AgentCore Code Interpreter's S3 integration and PUBLIC mode. Covers direct pip install, S3 wheel offline installation, sys.path import, and cross-session persistence behavior.
Blog
Execute Shell Commands in Bedrock AgentCore Runtime Sessions with InvokeAgentRuntimeCommand
Hands-on verification of AgentCore Runtime's new shell command API. Covers HTTP/2 streaming, in-session file persistence, cross-session microVM isolation, and concurrent execution behavior.
Blog
Controlling Agent Tool Access with Bedrock AgentCore Policy and Cedar Authorization
Hands-on verification of Bedrock AgentCore Policy: Cedar-based tool access control via Gateway, natural language policy generation, and default deny behavior validated with real API calls.
Blog
Real-Time Memory Change Detection with Bedrock AgentCore Memory Streaming
Hands-on verification of AgentCore Memory Record Streaming. Covers Kinesis push delivery, FULL_CONTENT vs METADATA_ONLY behavior, and async extraction events with real test data.
Blog
Hands-On with Stateful MCP Servers on Bedrock AgentCore Runtime: Elicitation, Sampling, and Progress Notifications
Verifying AgentCore Runtime's new stateful MCP features. Tested elicitation (server-initiated input), sampling (LLM generation requests), and progress notifications both locally and on AgentCore.
Blog
Strands Agents SDK Guide — Building a Team of Specialists with Multi-Agent
Coordinate multiple agents using the Agents as Tools pattern in Strands Agents SDK. Build a summarizer and translator as specialized agents, orchestrated by a coordinator — verified with real code and metrics.
Blog
Strands Agents SDK Guide — Conversation Memory and Context Management
Explore multi-turn conversations and SlidingWindowConversationManager in Strands Agents SDK. See how agents remember past exchanges and what happens when the context window fills up — verified with real code.
Blog
Strands Agents SDK Guide — Connecting External Tools with MCP
Connect MCP (Model Context Protocol) servers to Strands Agents SDK and extend your agent with external tools. Walk through the AWS documentation search MCP server hands-on, and combine MCP tools with custom @tool functions.
Blog
Strands Agents SDK Guide — Custom Tool Design Patterns
Deep dive into Strands Agents SDK custom tools. Build multi-step tool chains, observe how the LLM handles tool errors gracefully, and control agent behavior with system prompts — all verified with real code and metrics.
Blog
Strands Agents SDK Guide — Understanding the Agent Loop with Quickstart
Walk through the Strands Agents SDK Python Quickstart hands-on, explaining the agent loop, custom tools, and metrics with working code. A few dozen lines of Python is all it takes.