Video summary

How to Build & Deploy an AI Agent with AWS Strands Agents SDK | Devpost Build Session

Main summary

Key takeaways

Technology

Overview of the Workshop (Agent Speedrun)

The session is a hands-on guide to ideate, validate, and deploy an AI agent using the AWS Strands Agents SDK (referred to as “Strands agents” / “strands”).

The presenter emphasizes building agents for production-grade reliability and deterministic control, not just demo success.

Key Concepts & Features Covered

1) Agents “you use” vs “agents you build”

  • Agents that you use
    • Integrated systems like coding assistants/chat tools that already include agent behavior.
  • Agents you build (the hackathon goal)
    • You build an agentic system using primitives, then host/deploy it so others can use it later.

2) Strands Agents SDK (AWS open-source agent harness)

  • What it is
    • An open-source agent harness SDK built by AWS.
  • Model agnostic / bring your own model
    • No built-in model; works with Bedrock models and also with local/open-weight models and other model providers.
  • Lightweight + future-proof
    • You can swap in new models without redoing the architecture or rewriting system prompts.
  • Multi-agent primitives
    • Supports stacking multiple agents to create more complex systems.
  • Portability
    • Can be hosted anywhere, not only on AWS.

3) Bedrock Agent Core Runtime for Deployment (managed runtime)

  • What it is
    • A managed runtime service for agent deployments.
  • Deployment simplicity
    • Described as ~five lines of code to deploy.
  • Production capabilities provided
    • Memory
    • Gateway
    • Observability
    • Identity & permissions
    • Payments
    • Multi-tenant architecture support
  • Security focus
    • Highlighted for enterprise-grade security (e.g., VPC/private-link style integration mentioned).
  • Compatibility
    • Works with Strands and also supports other frameworks (e.g., LangGraph / LlamaIndex / noted in subtitles).

Workshop Modules (Practical Tutorial Flow)

Module 1: Build a Basic Agent Loop with Tools

Teaches the “reasoning loop” concept:

  1. User asks a question
  2. LLM reasons about the task
  3. Agent selects and calls the appropriate tool
  4. Tool returns data
  5. LLM uses tool output to produce the final response

Example built: a customer service agent for an e-commerce store

  • Example tools:
    • lookup customer
    • get order history
    • process refund

Implementation notes:

  • Starting pattern described as a small amount of code to define the agent and register tools.
  • Demonstrates tool calling under the hood (e.g., inferring customer ID from context).
  • Includes a multi-turn variant (separate chat.py-like code).

Module 2: Deterministic Control Using “Hooks” (Guardrails)

Hooks are described as deterministic code injected into the agent loop to enforce rules.

Use cases explained:

  • Pre-LLM validation
    • Refuse invalid requests/users without wasting LLM calls.
  • Before tool call
    • Rate limiting and stopping runaway behavior if a tool is failing.
  • After tool results
    • Block unsafe/undesired outputs from being returned.

Demonstrated: rate limiter hook

  • Registers a hook that tracks tool calls (example: max calls = 3).
  • When the limit is exceeded, the tool call is blocked and the user gets a controlled message.

This is framed as runtime governance: the agent can think, but behavior is constrained.

Module 3: “Skills” and “Steering”

Skills (context management via modular instructions)

Problem addressed: don’t put everything in a giant system prompt.

Skills approach:

  • Put detailed workflows/instructions in a separate skills folder (e.g., Markdown files).
  • A skills plugin loads only the relevant skill when needed.

Example skills mentioned:

  • account/support issues
  • order tracking
  • refund processing

Demonstration behavior:

  • The agent decides to use a skill (e.g., refund) and follows the steps defined there.

Steering (buddy agent / deterministic enforcement of behavior + tone)

Steering goal:

  • Correct bad actions or unwanted behavior before/after execution.

Mechanism:

  • A buddy agent or deterministic code steps in to approve/guide/reject actions.

Steering can enforce:

  • workflow correctness
    • e.g., must look up customer and check order history before refund
  • response tone and formatting constraints
    • e.g., “don’t use M dashes”
    • don’t overpromise/blame the user
    • acknowledge frustration

Demonstrated refund flow:

  • Checks required prerequisites (customer verified/order history retrieved).
  • Evaluates response and tone; only proceeds if checks pass.

Also mentions: session management / session persistence

  • Without it, the agent may forget earlier conversation context.
  • Deployment to Agent Core includes session handling support.

Workshop Logistics & Learning Resources

  • Uses AWS Workshop Studio
    • Fully free, available for ~72 hours
    • Provides a Jupyter notebook environment and workshop materials
  • Access notes
    • Avoid logging in via an existing Amazon account.
    • Use an email that won’t associate with a billed AWS account.
  • Provides
    • a code editor URL to open notebooks
    • a GitHub repository and workshop materials for later reference (screenshot/repo access emphasized)
  • Presenter guidance
    • Only module 1 is sufficient to submit for the hackathon.
    • Additional modules improve determinism and reliability.

Main Speakers / Sources

  • Sandy — Senior Developer Advocate at AWS (primary presenter)
  • Darlles / Dar Developer — Devpost Developer Marketing Manager (host/introducer)

Original video