AI Engineer · Published 2026-09-14

Harness Engineering: Building the Production Cage for Powerful Domain Agents — Mike Chambers, AWS

privateReview: unreviewedConfidence: high
Harness engineeringagentsawsMCPAgentCorestrandsharness-engineeringstrands-agentsagent-observabilityinfrastructure-as-codemulti-tenant-isolationagent-payments
Open on YouTube ↗

Summary

Overview

  • Speaker: Mike Chambers
  • Channel: AI Engineer
  • Main topic: Harness engineering and building production-ready AI agents on AWS
  • Purpose: To educate AI engineers on harness engineering, explaining the difference between using agents and building production agents at scale using AWS infrastructure, Strands Agents SDK, and AgentCore. Mike Chambers, Senior AI Specialist Developer Advocate at AWS, discusses harness engineering—the code, configuration, and execution logic that surrounds an AI model to make it production-ready. He contrasts agents we use (like coding assistants) with agents we build, introduces the Agentic AI Foundation, and demonstrates building and deploying agents using Strands Agents SDK and AgentCore.

Topic Map

Introduction and Background

  • Explanation: Mike Chambers introduces himself, his background at AWS, and his work on generative AI courses, MCP lambda handlers, and the Agentic AI Foundation.
  • Key claims:
    • AWS is a founding member of the Agentic AI Foundation within the Linux Foundation.
    • Chambers worked on deep learning courses with Andrew Ng reaching hundreds of thousands of enrollments.
  • Examples:
    • Building MCP lambda handler generating 35k downloads a month.
  • Terminology:
    • AWS
    • Agentic AI Foundation
    • Strands Agents SDK
  • Why it matters: Establishes speaker credibility and context around enterprise AI development.

Agents We Use vs Agents We Build

  • Explanation: Distinguishing between off-the-shelf consumer agent tools we use (like Claude Code, Cursor, Kiro) versus agents engineered and built internally for production workloads.
  • Key claims:
    • Agents we use rely on token maximization and local workflows.
    • Agents we build require structured harnesses, memory management, security, and scalability.
  • Examples:
    • Cursor and Claude Code as agents we use.
    • Custom enterprise agent applications built using AgentCore.
  • Terminology:
    • Agents we use
    • Agents we build
    • Token maxing
  • Why it matters: Highlights why software engineering best practices apply differently to agentic architectures.

Defining Harness Engineering

  • Explanation: Defining agent harness: Agent = Model + Harness. Harness engineering is the practice of engineering everything around the model.
  • Key claims:
    • A harness is every piece of code, configuration, and execution logic that is not the model itself.
    • Agent minus model equals harness.
  • Examples:
    • LangChain and Martin Fowler/Birgitta Böckeler definitions of agent harness engineering.
  • Terminology:
    • Harness engineering
    • Agent harness
  • Why it matters: Provides a clear mental model for separating base LLM capabilities from application scaffolding.

Components of an Agent Harness

  • Explanation: Breakdown of the various components required in a robust production agent harness.
  • Key claims:
    • Observability and evaluations must be prioritized first.
    • Harness components include loops, scaling, memory, identity, skills, tools/mcp, runtime, security, payments, and context management.
  • Examples:
    • Connecting to documentation servers via MCP servers.
  • Terminology:
    • MCP
    • Observability
    • Context management
    • Evaluations
  • Why it matters: Outlines the comprehensive architecture needed to scale agents beyond local experiments.

Live Coding and Deployment Demo with Strands and AgentCore

  • Explanation: Demonstrating local agent creation using Strands Agents SDK and AWS AgentCore CLI tools.
  • Key claims:
    • Strands Agents SDK allows rapid local prototyping of agents with tools and memory.
    • AgentCore provides CLI and infrastructure-as-code capabilities for deploying agents at cloud scale.
  • Examples:
    • Running python scripts with uv run and testing agent responses locally.
    • Using agentcore create and agentcore dev to spin up a web UI inspector.
  • Terminology:
    • Strands SDK
    • AgentCore
    • uv run
    • Multi-tenant isolation
  • Why it matters: Shows practical implementation of harness engineering using modern open-source tooling.

Key Points

Agent = Model + Harness

  • Explanation: The core formula defining an AI agent, where the model provides intelligence and the harness provides execution logic, tools, memory, and guardrails.
  • Evidence: Referenced articles by Birgitta Böckeler and Martin Fowler.
  • Practical implication: Engineers should focus development effort on building robust harnesses rather than training base models.

No more slop ops

  • Explanation: Moving away from ad-hoc manual console clicking (clickops) toward infrastructure-as-code managed by agents.
  • Evidence: Chambers' advocacy for infrastructure-as-code agent deployments.
  • Practical implication: Production agents must build and manage their own cloud infrastructure safely.

Observability and evaluations first

  • Explanation: Tracking traces, logging, and evaluation metrics should be foundational elements in agent harness design.
  • Evidence: Placement of observability and evaluations at the top of the AgentCore architecture diagram.
  • Practical implication: Without robust observability, debugging complex multi-turn agent loops at scale is impossible.

Frameworks, Models & Processes

AgentCore Architecture Framework

  • How it works: Provides modular components for building, deploying, and assessing production agents at cloud scale.
  • Components:
    • Harness (CLI, strands, models, tools, skills, memory)
    • Built-in tools (browser, code interpreter, knowledge base, search)
    • Gateway (APIs, lambda functions, configuration bundles)
    • Policy (authorization control)
    • Runtime (agents, tools)
    • Identity (inbound and outbound authentication)
    • Payments (automated microtransactions)
    • Registry (agents, MCP servers, tools, skills)
    • Memory (short and long term memory)
    • Observability and Evaluations
  • When to use: When deploying domain agents into enterprise production environments on AWS.

Examples & Case Studies

Building a simple calculator and time-checking agent in Python using Strands SDK.

  • Illustrates: How minimal boilerplate is needed to define tools and system prompts in a modern agent framework.
  • Lesson: Basic prototypes are easy to build locally, but production scaling requires dedicated harnesses.

Using AgentCore CLI to initialize an agent project, configure memory, model selection, and deployment options.

  • Illustrates: Automated provisioning of infrastructure-as-code for agent runtimes.
  • Lesson: CLI tools simplify scaffolding multi-tenant agent applications with secure memory and tool integration.

Actionable Takeaways

  • Immediate:
    • Distinguish clearly between consumer agents you use and production agents you build.
    • Explore Strands Agents SDK on GitHub for building model-first agent applications.
    • Utilize AgentCore for AWS agent deployments and infrastructure management.
  • Strategic:
    • Prioritize harness engineering over model fine-tuning for most application use cases.
    • Implement multi-tenant isolation and session management early in agent architecture.
    • Treat observability and evaluations as core requirements, not afterthoughts.
  • Questions to investigate:
    • How do different agent frameworks handle multi-turn context persistence at enterprise scale?
    • What are the best practices for securing Model Context Protocol (MCP) servers in production?

Claims Worth Verifying

  • AWS is a founding member of the Agentic AI Foundation under the Linux Foundation. (organizational fact)
  • Strands Agents SDK supports Python and TypeScript with model-first design. (technical feature)

Notable Quotes

"A harness is a set of straps and fastenings used to control an animal..." (at 6:42) "The term harness has emerged as a shorthand to mean everything in an AI agent except the model itself." (at 7:00) "agent minus model equals harness." (at 8:05) "I don't want to see any more slop ops." (at 10:22)

Compressed Summary

  • Agent harness engineering encompasses all code, tools, memory, and orchestration surrounding an LLM.
  • Distinguishes agents we use interactively from agents we engineer and build for production.
  • Strands SDK provides a fast open-source framework for building Python and TypeScript agents.
  • AWS AgentCore enables secure cloud-scale agent deployment, session management, and multi-tenant isolation.
  • Keywords: harness engineering, agents, aws, mcp, agentcore, strands
  • Core insight: Harness engineering—managing memory, tools, loops, and infrastructure around an LLM—is the critical discipline for deploying production-grade AI agents at scale.

Core insights

6
Mental Modelmedium noveltystrong evidence

An agent decomposes cleanly into model plus harness, where the harness is defined by subtraction: everything in the system that is not the model (code, configuration, execution logic, tools, memory, guardrails). This makes 'harness engineering' the primary lever for production readiness rather than model capability.

Why it matters

Gives engineers a partitioning rule for where to invest: if a production problem is not a model-weight problem, it is a harness problem, and most enterprise work belongs on the harness side.

Generalization

For any LLM-backed system, define the boundary by subtraction — the non-model remainder is the maintainable, testable engineering surface.

A harness is every piece of code, configuration, and execution logic that is not the model itself.
Open source video
Agent minus model equals harness.
Open source video
Architecturemedium noveltymoderate evidence

In the AgentCore architecture, observability and evaluations are placed at the top of the component diagram — treated as a first-order harness layer rather than a post-incident add-on, on the argument that multi-turn agent loops are undebuggable at scale without traces and eval metrics.

Why it matters

Changes build order: instrumentation and eval scaffolding get designed alongside the loop, not bolted on after launch, which affects debuggability, reliability, and cost attribution in production.

Generalization

For systems with non-deterministic control flow, observability infrastructure must be co-designed with the control loop because failures are not reproducible from logs alone.

Observability and evaluations must be prioritized first.
Open source video
Without robust observability, debugging complex multi-turn agent loops at scale is impossible.
Open source video
Architecturehigh noveltymoderate evidence

The harness component taxonomy is broader than the usual agent checklist: it explicitly includes identity, runtime, policy/authorization, registry, and payments (automated microtransactions) alongside loops, scaling, memory, skills, tools/MCP, and context management.

Why it matters

Treating payments, identity, and registry as harness components rather than external services implies the agent runtime needs first-class primitives for authenticated outbound actions and monetization, which most frameworks lack.

Generalization

Any agent that takes economically or legally consequential actions needs identity, policy, and settlement primitives inside the harness boundary, not in surrounding application code.

Harness components include loops, scaling, memory, identity, skills, tools/mcp, runtime, security, payments, and context management.
Open source video
Payments (automated microtransactions)
Open source video
Tradeoffmedium noveltymoderate evidence

Distinction between 'agents we use' and 'agents we build': consumer coding agents optimize for token maximization and local workflows, whereas built agents require structured harnesses, memory management, security, and scalability.

Why it matters

The optimization target differs, so copying the design assumptions of consumer coding assistants (single-user, local, generous token spend) into production domain agents produces the wrong architecture.

Generalization

Design patterns from single-tenant interactive tools do not transfer to multi-user production services; the cost, isolation, and concurrency models are inverted.

Agents we use rely on token maximization and local workflows.
Open source video
Agents we build require structured harnesses, memory management, security, and scalability.
Open source video
Practicehigh noveltyweak evidence

'No more slop ops' — the position that agent deployment should move from ad-hoc manual console clicking (clickops) to infrastructure-as-code that agents themselves build and manage.

Why it matters

Shifts the deployment responsibility boundary: the agent, not the human operator, provisions and manages cloud infrastructure, which changes permissioning, review, and blast-radius design.

Generalization

As agents gain write access to infrastructure, the reviewable artifact becomes the generated IaC plan rather than the console action, making plan-diff approval the new control point.

Moving away from ad-hoc manual console clicking (clickops) toward infrastructure-as-code managed by agents.
Open source video
Production agents must build and manage their own cloud infrastructure safely.
Open source video
Empirical Resultmedium noveltymoderate evidence

Local prototyping is cheap — a few lines of Python in Strands SDK define tools and system prompts — but production scaling requires a dedicated harness, and AgentCore CLI scaffolds multi-tenant isolation with secure memory and tool integration.

Why it matters

Sets realistic expectations about the prototype-to-production gap: boilerplate is near-zero locally while multi-tenancy and secure memory are framework/deployment concerns, not application code.

Generalization

The harder the isolation and state-sharing requirements, the more the framework/CLI layer, rather than application code, becomes the place to enforce them.

Basic prototypes are easy to build locally, but production scaling requires dedicated harnesses.
Open source video
CLI tools simplify scaffolding multi-tenant agent applications with secure memory and tool integration.
Open source video

Deep dives

5

Minimum viable trace and eval schema for multi-turn agent loops

Research question

What minimum set of trace spans, eval metrics, and state-transition records is sufficient to root-cause non-reproducible failures in multi-turn agent loops, and can that schema be defined independently of the model or framework?

Why

Without a coverage bar, observability-first claims remain unactionable; a minimal schema would let teams instrument before launch and make 'undebuggable at scale' falsifiable.

Without robust observability, debugging complex multi-turn agent loops at scale is impossible.
Open source video
Observability and evaluations must be prioritized first.
Open source video
Source video

Safe agent-managed infrastructure provisioning: policy, scoping, and plan review

Research question

What permission-scoping, policy-as-code, and plan-diff approval mechanisms are required for an agent to provision and manage cloud infrastructure with bounded blast radius?

Why

Agent-managed IaC is asserted as a production requirement but no safety mechanism is specified; without one, infrastructure write access is an unbounded risk.

Production agents must build and manage their own cloud infrastructure safely.
Open source video
Moving away from ad-hoc manual console clicking (clickops) toward infrastructure-as-code managed by agents.
Open source video
Source video

Decision procedure for the harness/model boundary

Research question

For a given agent capability, what criteria determine whether it should live in model weights/prompting versus harness logic, and can those criteria predict reliability, latency, and cost differences?

Why

The subtractive definition of harness gives no rule for where to put a capability, leaving engineers to guess; a decision procedure would make harness engineering systematic.

Agent minus model equals harness.
Open source video
A harness is every piece of code, configuration, and execution logic that is not the model itself.
Open source video
Source video

Identity-to-wallet scoping for autonomous agent payments

Research question

How should agent identity, wallet scoping, spend limits, and audit trails be coupled inside the harness to bound autonomous microtransactions without blocking legitimate purchases?

Why

Payments appear as a harness component with no interaction model for identity; unbounded spend is a direct financial and compliance risk.

Payments (automated microtransactions)
Open source video
Harness components include loops, scaling, memory, identity, skills, tools/mcp, runtime, security, payments, and context management.
Open source video
Source video

Multi-tenant isolation enforcement boundary in scaffolded agent deployments

Research question

Where is the multi-tenant isolation boundary actually enforced in CLI-scaffolded agent deployments (process, container, memory store, API), and what adversarial probes can verify it?

Why

If isolation is a scaffolding convenience rather than a runtime guarantee, cross-tenant leakage becomes a security vulnerability hidden in framework defaults.

CLI tools simplify scaffolding multi-tenant agent applications with secure memory and tool integration.
Open source video
Basic prototypes are easy to build locally, but production scaling requires dedicated harnesses.
Open source video
Source video

Article ideas

4

The Harness Is the Product: Why Production Agents Fail on Engineering, Not Model Capability

The bottleneck for enterprise agents is not model intelligence but the presence or absence of harness components (observability, identity, memory, runtime, policy); teams that keep optimizing models while under-investing in the harness will keep shipping demos that fail in production.

Angle

Contrarian engineering argument against model-centric AI narratives.

Source video

Observability Is a Launch Blocker: Designing Evals Before Your Agent Loop

Multi-turn agent loops are only debuggable when traces and eval metrics are co-designed with the control loop; treating observability as post-launch tooling guarantees undebuggable production incidents.

Angle

Process and architecture change for AI platform teams.

Source video

No More Slop Ops: When Agents Provision Their Own Infrastructure

Agent-managed infrastructure-as-code moves the safety control point from console actions to plan-diff approval and policy enforcement; without explicit authorization boundaries, agents with infrastructure write access widen blast radius faster than they reduce toil.

Angle

DevOps and security implications of agentic provisioning.

Source video

The Payments Primitive: Why Agent Harnesses Need Identity-Bound Wallets

Autonomous microtransactions cannot be a bolted-on billing integration; they require identity-bound wallet scoping and policy enforcement inside the harness, otherwise agents become unbounded financial actors.

Angle

Fintech and agent platform architecture.

Source video

Project ideas

4

Minimum Viable Agent Trace Schema (MVATS)

beyond-evals

A minimal multi-turn trace and eval schema (span types, tool-call outcomes, state transitions, cost attribution) enables root-causing injected failures in agent loops, whereas logs alone produce significantly longer time-to-diagnosis or failure to diagnose.

Proof of concept

Instrument a multi-turn agent (e.g., using Strands/AgentCore) with the proposed schema; inject a controlled set of failures (tool timeout, context loss, hallucinated tool call, wrong tool selection); compare root-cause time and success rate against a logs-only baseline.

Measurement

Time-to-diagnosis (median and 90th percentile), percentage of injected failures successfully root-caused, and number of additional diagnostic queries required per incident.

Source video

Agent IaC Plan Gate

gatehouse

Agent-generated infrastructure-as-code plans can be safely bounded by policy-as-code plus plan-diff approval gates, reducing blast radius from malformed or adversarial plans without eliminating legitimate provisioning.

Proof of concept

Build an agent that generates infrastructure-as-code plans; enforce policy checks (deny public buckets, wildcard IAM, destructive replacement) and require human approval on plan diffs; run adversarial and benign plans through the pipeline.

Measurement

Number of unsafe plans blocked, false-positive rate on benign plans, reduction in simulated blast radius (resources affected), and added approval latency per plan.

Source video

Identity-Bound Wallet Scoping

gatehouse

Scoping an agent's identity to a spend-limited wallet with per-transaction and aggregate limits, enforced at runtime, prevents runaway spend while allowing legitimate microtransactions, and does so with acceptable false-positive rates.

Proof of concept

Implement an agent with a scoped wallet, policy engine (limits, merchant allowlist, velocity checks), and audit log; simulate a mix of legitimate purchases and adversarial attempts (limit evasion, replay, spoofed identity).

Measurement

Prevented unauthorized spend (absolute and percentage), false-positive rate for legitimate transactions, audit completeness (every transaction traceable to identity and policy decision), and policy decision latency.

Source video

Cross-Tenant Leakage Test Suite for Scaffolded Agents

gatehouse

Multi-tenant isolation provided by CLI scaffolding (e.g., AgentCore) is enforced at a specific boundary (process, container, memory store, API) and can be verified by adversarial cross-tenant probes; leakage is possible when isolation relies on application code rather than runtime enforcement.

Proof of concept

Deploy two tenants using the same scaffolded agent framework with shared infrastructure (e.g., common memory store, vector DB, tool registry); attempt to read or mutate other tenant's memory, secrets, or tool outputs via prompt injection, API parameter tampering, and direct store access.

Measurement

Number of successful cross-tenant accesses (leakage incidents), isolation boundary failure rate, and time-to-detect leakage across probe types.

Source video

Architectural implications

4

Observability and evaluations are positioned at the top of the AgentCore architecture rather than as a peripheral tooling layer.

Before

Traces, logging, and evals added after launch in response to incidents.

After

Instrumentation and eval metrics designed as a first-class harness component before the agent loop ships.

Consequence

Debugging and cost attribution for multi-turn loops become tractable, but harness scope expands and eval coverage becomes a launch-blocking dependency.

Source video

Deployment moves from human clickops to infrastructure-as-code generated and managed by agents.

Before

Humans provision cloud resources through consoles; agents only invoke APIs at runtime.

After

Agents own provisioning via IaC, with policy and identity bounding what they can create.

Consequence

Authorization and plan-review mechanisms become the critical safety surface; the object under review shifts from runtime calls to generated infrastructure plans.

Source video

Payments and identity are modeled as harness components rather than application-level concerns.

Before

Billing and auth treated as external plumbing outside the agent's own architecture.

After

Settlement and authentication live beside memory, runtime, and tools in the harness.

Consequence

Agents can autonomously transact, but require policy enforcement and identity scoping inside the runtime to bound spend and abuse.

Source video

Multi-tenant isolation and secure memory are handled by CLI scaffolding rather than application code.

Before

Prototype agents with a single user, local state, and no isolation boundary.

After

Framework-provided per-tenant isolation and secure memory on deployment.

Consequence

The framework/CLI layer becomes the enforcement point for tenant boundaries, so framework version and config correctness carry security weight.

Source video

Tradeoffs and failure modes

5

Observability-first harness design

Benefit

Multi-turn agent loops at scale become debuggable and evaluable via traces and metrics.

Cost or risk

Upfront instrumentation and eval-suite investment before any agent behavior ships; observability becomes a gate on iteration speed.

Without robust observability, debugging complex multi-turn agent loops at scale is impossible.
Open source video
Source video

Agent-managed infrastructure provisioners

Benefit

Removes error-prone manual clickops and makes deployments reproducible via infrastructure-as-code.

Cost or risk

Agents with infrastructure write access widen blast radius; 'safely' is asserted but the constraint mechanism is not specified in the evidence.

Production agents must build and manage their own cloud infrastructure safely.
Open source video
Source video

Local prototype-to-production continuity

Benefit

Strands SDK allows minimal-boilerplate local agents with tools and memory, enabling fast iteration.

Cost or risk

Prototypes that work locally do not scale; the harness gap only becomes visible at production deployment time.

Basic prototypes are easy to build locally, but production scaling requires dedicated harnesses.
Open source video
Source video

Consumer-agent design assumptions in production

Benefit

Consumer agents demonstrate capable tool use with generous token budgets and local context.

Cost or risk

Token maximization and local-only workflows do not generalize to secure, multi-tenant, scalable services.

Agents we use rely on token maximization and local workflows.
Open source video
Source video

Automated microtransactions in the harness

Benefit

Agents can autonomously pay for resources or services as a first-class capability.

Cost or risk

Introduces spend control, authorization, and audit requirements inside the runtime; the summary gives no mechanism for bounding cost or preventing runaway spend.

Payments (automated microtransactions)
Open source video
Source video

Open questions

5

What concrete mechanisms let an agent provision and manage its own cloud infrastructure 'safely'?

Why unresolved

The summary asserts the safety requirement but names no policy, permission-scoping, or plan-review mechanism.

Research direction

Prototype agent-generated IaC with policy enforcement and plan-diff approval gates; measure blast radius under adversarial or malformed plans.

Source video

How should the harness/model boundary be drawn for a given problem — which capabilities belong in weights versus scaffolding?

Why unresolved

The summary gives a subtractive definition of the harness but no decision procedure for where a given capability should live.

Research direction

Build the same agent capability two ways (harness logic vs prompt/fine-tune) and benchmark reliability, latency, and cost per boundary decision.

Source video

What does adequate observability and eval coverage look like for multi-turn agent loops?

Why unresolved

Claims that observability is 'prioritized first' and that loops are undebuggable without it, but no coverage bar, metric set, or trace schema is described.

Research direction

Define a minimum trace and eval schema for multi-turn agents and test whether it enables root-causing injected failures.

Source video

How do identity and payments interact when an agent autonomously transacts?

Why unresolved

Identity and payments appear as separate harness components with no described interaction model for scoping, spend limits, or attribution.

Research direction

Design an agent identity-to-wallet scoping model and test spend-limit enforcement and auditability across multi-tenant deployments.

Source video

Why is multi-tenant isolation a CLI-scaffolding concern rather than a runtime-enforced guarantee?

Why unresolved

The summary states the CLI simplifies scaffolding multi-tenant applications with secure memory but does not describe the isolation mechanism or its failure modes.

Research direction

Elicit the isolation boundary (process, container, memory store) and attempt cross-tenant data leakage tests against scaffolded deployments.

Source video

Key claims

8
opinionVerification not requested

An agent equals a model plus a harness, where the harness is everything that is not the model.

Evidence

Agent minus model equals harness.

Source video
opinionVerification not requested

Observability and evaluations must be prioritized first in harness design.

Evidence

Observability and evaluations must be prioritized first.

Source video
causalVerification needed

Without robust observability, debugging complex multi-turn agent loops at scale is impossible.

Evidence

Without robust observability, debugging complex multi-turn agent loops at scale is impossible.

Question

Can analogous multi-turn agent failures be root-caused from logs alone, or do traces and eval metrics materially shorten time-to-diagnosis?

Source video
comparativeVerification needed

Agents built for production require structured harnesses, memory management, security, and scalability, unlike consumer agents that rely on token maximization and local workflows.

Evidence

Agents we build require structured harnesses, memory management, security, and scalability.

Question

Which specific production failures in domain agents trace to missing harness components rather than model capability?

Source video
predictionVerification needed

Production agents must build and manage their own cloud infrastructure safely, replacing manual clickops with infrastructure-as-code.

Evidence

Production agents must build and manage their own cloud infrastructure safely.

Question

What permission scoping and review gates are required before agent-managed infrastructure provisioning is safe in an enterprise account?

Source video
causalVerification needed

Strands Agents SDK allows rapid local prototyping of agents with tools and memory, but production scaling requires a dedicated harness.

Evidence

Basic prototypes are easy to build locally, but production scaling requires dedicated harnesses.

Question

What is the quantified effort delta between a Strands local prototype and the equivalent multi-tenant production deployment?

Source video
factualVerification needed

AWS is a founding member of the Agentic AI Foundation within the Linux Foundation.

Evidence

AWS is a founding member of the Agentic AI Foundation within the Linux Foundation.

Question

Is AWS listed as a founding member of the Agentic AI Foundation under the Linux Foundation?

Source video
factualVerification needed

An MCP lambda handler built by the speaker generates 35k downloads a month.

Evidence

Building MCP lambda handler generating 35k downloads a month.

Question

Which package or repository is the MCP lambda handler, and does its download or adoption count reach 35k per month?

Source video

Connections

5