AWS Loom: Enterprise AI Agent Platform on Bedrock AgentCore

WHAT IT DOES

AWS Loom for AWS is an open-source enterprise-grade platform (Apache 2.0, released July 9, 2026, featured in AWS Weekly Roundup July 13) for building, deploying, and operating AI agents on Amazon Bedrock AgentCore Runtime and AWS Strands Agents. Created by Heeki Park and published in AWS Labs, Loom provides a unified management UI with Cognito-based authentication, scope-based authorization, multi-persona navigation, and full lifecycle management for agents, memory, MCP servers, A2A integrations, and AWS Agent Registry governance. It seamlessly weaves together agents, memory stores, MCP servers, and agent-to-agent integrations in a unified platform while handling the complexity of IAM roles, credential providers, authentication flows, and resource tagging. Key enterprise features include on-behalf-of (OBO) token exchange (RFC 8693) enabling agents to access downstream resources with user-scoped permissions, human-in-the-loop (HITL) approval policies with four methods (agentic loop hooks, tool context interrupts, MCP elicitation, and harness inline functions), two-dimensional group-based authorization (Type groups for UI view and Resource groups for access control across 21 scopes), and AWS Agent Registry integration for governance and discovery of agents and tools.

BUSINESS PROBLEM

Standing up one AI agent is a weekend project. Running a whole platform of agents across an enterprise organization is where it stops being fun. According to an AWS analysis published with Loom, enterprise platform engineering teams spend 60-80% of their agent-platform time on non-agent concerns: identity management, access control, credential management, resource tagging, audit logging, deployment pipelines, and cost tracking. When an agent needs to act on behalf of a user to access a downstream resource, teams must implement token exchange, scoped permissions, and audit trails from scratch. When an agent makes a sensitive action (deleting a database record, updating a financial document), there is no built-in human review gate. AWS launched Loom to provide all of this infrastructure out of the box — an opinionated, paved-path implementation that abstracts the security and governance complexity while still allowing platform engineering teams to customize and extend.

WHO BENEFITS

For a platform engineering team at an enterprise deploying AI agents. Situation: Building an internal agent platform on AWS. Team spends 60% of sprint time on identity, auth, governance, and deployment pipelines — not on agent logic. Payoff: Loom provides Cognito auth, 21-scope authorization, HITL approval, OBO token exchange, and Agent Registry governance out of the box. Team focuses on agent capabilities, not infrastructure. For a security architect governing AI agent access. Situation: Agents need to access downstream resources (databases, APIs, SaaS tools) with user-scoped permissions. Current approach requires custom IAM role per agent per resource. Payoff: Loom's OBO token exchange (RFC 8693) propagates user identity through agent chains. One configuration per MCP server, not per agent. Audit trail captures every identity delegation. For a compliance officer reviewing AI agent operations. Situation: Need to demonstrate compliance with SOX, SOC 2, or HIPAA for AI agent actions. Current approach has no structured audit trail. Payoff: Loom's HITL approval policies record every sensitive action, who approved it, and what identity context was used. Agent Registry maintains a governance-reviewed catalog of all agents and tools.

HOW IT WORKS

Phase 1. Deploy Loom locally (40 min). Clone awslabs/loom, configure .env with Cognito pool and OAuth settings. Run docker-compose up. Access the management UI at localhost:5173. Test agent creation with SQLite backend. This phase validates the setup before committing to AWS infrastructure. Phase 2. Deploy database to AWS (40 min). Deploy RDS Postgres in a private VPC with RDS Proxy for connection pooling. Use the provided Makefile templates and SSM bastion tunnel. Run database migrations. This phase transitions from local SQLite to production-grade Postgres. Phase 3. Full deployment to AWS (30 min). Deploy frontend (shadcn/ui + Vite) and backend (FastAPI) containers on ECS Fargate behind an Application Load Balancer. TLS termination via ACM certificate. Route 53 for custom domain. The entire stack runs as managed AWS services with auto-scaling. Phase 4. Configure identity federation (30 min). Connect Cognito to Microsoft Entra ID, Okta, or Auth0 via Authorization Code + PKCE flow. Map IdP group claims to Loom groups. Configure client_type (public/confidential). Test admin and user persona views. Phase 5. Create and deploy agents (ongoing). Use the Loom UI to create agents with natural language descriptions. Loom deploys agents to AgentCore Runtime via pre-written Python templates. Configure MCP servers and A2A agents with OAuth settings. Agents are registered in Agent Registry in DRAFT status. Phase 6. Enable HITL approval (config). Configure approval policies for sensitive tool actions. Choose from four HITL methods: agentic loop hooks, tool context interrupts, MCP elicitation, or harness inline functions. Test with a sensitive action and verify the approval flow.

TOOL INTEGRATION

TOOL: Loom for AWS v1.6.0 (Apache 2.0, AWS Labs). Role: Enterprise-grade agent platform for Bedrock AgentCore with full lifecycle management, governance, and security. API access: github.com/awslabs/loom. Auth: Cognito (built-in), federated IdP (Entra ID, Okta, Auth0, Generic OIDC). Cost: Free, open-source (AWS infrastructure costs apply for deployed resources). Gotcha: Loom is provided as-is without AWS support or SLAs. Breaking changes may occur between releases. Organizations with strict compliance requirements should evaluate the governance model before adoption. TOOL: Amazon Bedrock AgentCore Runtime (AWS). Role: Managed agent runtime that hosts and executes the agents Loom deploys. API access: AWS Console / SDK. Auth: IAM roles. Cost: Pay-per-use (AWS pricing). Gotcha: AgentCore Runtime is a managed service with its own pricing and limits. Loom deploys agents as zip files to S3, then deploys to AgentCore — not all AgentCore features are exposed through Loom's abstraction. TOOL: AWS Agent Registry (Public Preview, AWS). Role: Governance catalog for agents, MCP servers, and tools with approval workflow and discovery. API access: AWS Console / SDK. Auth: IAM roles. Cost: Included with AWS (public preview). Gotcha: Agent Registry is in public preview. API and behavior may change. Loom's Agent Registry integration is opt-in via Settings page (ARN configuration).

ROI METRICS

Metric Without Loom With Loom Source Agent platform setup time 3-6 months 2-3 days Architecture estimate Identity/access control effort 60% of sprint 10% of sprint AWS Open Source Blog Sensitive action coverage ~0% (no HITL) 100% (configurable) Product architecture Agent governance readiness 0% (no catalog) Registry (DRAFT/APPROVED) Product architecture

The week-1 win: clone Loom, deploy locally with docker-compose, and create your first agent in the management UI. Connect to a free-tier LLM and test a simple tool call. The strategic implication: Loom represents AWS's recognition that agent governance is the bottleneck for enterprise AI adoption. The open-source approach means any organization can adopt the same patterns AWS uses internally.

CAVEATS

1. (significant risk) No AWS support: Loom is open-source community software published in AWS Labs, not an AWS managed service. There are no SLAs, no support response time guarantees, and no AWS commitment to roadmap. Mitigation: Evaluate Loom as a reference architecture and starting point, not a production-managed service. Plan to fork and customize for production deployments.
2. (moderate risk) AgentCore Runtime limits: AgentCore Runtime is the execution target for Loom agents. It has specific limits on concurrency, memory, execution duration, and tool availability. Not all agent architectures work within AgentCore's constraints. Mitigation: Review AgentCore documentation for limits before designing agent architectures. Test complex multi-step agents early.
3. (moderate risk) Breaking changes: Loom is actively developed. The v1.x series may include breaking changes between releases. API and UI are not stable. Mitigation: Pin to a specific Loom release for production deployments. Test upgrades in a staging environment before applying to production.
4. (minor risk) AWS vendor lock-in: Loom is deeply integrated with AWS services (Cognito, ECS, RDS, Bedrock, AgentCore). Migrating to another cloud provider would require significant reimplementation. Mitigation: For multi-cloud strategies, evaluate whether Loom's AWS-native architecture aligns with your infrastructure strategy. Consider using Loom as a reference architecture and reimplementing abstracted patterns on your chosen cloud.