Quality assurance teams working on complex products face a grinding operational burden: each test failure requires manual documentation—steps to reproduce, screenshots, failure rates, regression labels—consuming 10-15 minutes per incident. With 30+ failures weekly across a team, an entire engineering day disappears into paperwork that should be automated.

An autonomous agent can eliminate this work entirely. Rather than dashboards or notification systems, such an agent observes test results, makes judgment calls about whether failures are new bugs, duplicates, or regressions, and takes action without human intervention. It files structured tickets, attaches evidence, calculates reproducibility metrics, detects regressions across builds, and routes notifications to the right people. Teams mark failures as FAIL and move forward.

This approach works well on AWS Lambda for a single team. The question becomes architectural when demand grows: what happens when 10, 50, or 100 teams need the same capability? The answer depends not on Lambda's limitations, but on how workload characteristics evolve as the system scales.

Why Lambda works for one team

The initial architecture is straightforward: an EventBridge rule triggers a Lambda function every 15 minutes. The function polls a test management API, processes failures through a decision engine (checking DynamoDB for duplicates, comparing against previous build results for regressions), and files bugs via JIRA API. Monthly infrastructure cost stays under $5.

Lambda proved correct for three reasons:

  • Zero operational overhead: no servers to manage, no scaling configuration, no patching cycles. Deploy and forget.
  • Cost aligned with usage: one team generates roughly 200 invocations monthly, making the service essentially free at Lambda pricing.
  • Rapid iteration: the decision engine underwent 20+ revisions in the first month, and Lambda's deployment model enabled shipping changes in seconds.

Within weeks, the system filed more complete and consistent bugs than manual processes had ever produced. Zero missed failures. Regressions caught in minutes rather than days. QA interruptions dropped to zero because teams could query the system directly via Slack. The system saved 8-10 hours per week.

Other teams noticed. The question "Can we have that?" became routine. The obvious answer seemed to be deploying another instance per team. But at multi-tenant scale, workload characteristics shift in ways that change the architectural calculus.

The scaling challenge

Lambda handles single-tenant agentic workloads well. The challenge at multi-tenant scale isn't Lambda's capability; it's how workload characteristics transform:

From stateless events to long-running context: A single team's poll cycle completes in seconds. Cross-project correlation—determining whether the same failure pattern appears across three teams—requires analyzing hundreds of results and their relationships in one pass. This represents a fundamentally different compute profile.

From isolated invocations to shared resource contention: When 50 functions trigger on the same EventBridge schedule, they simultaneously hit TestRail and JIRA APIs. This demands centralized rate limiting, connection pooling, and backpressure—patterns that benefit from persistent, shared infrastructure.

From single-team to multi-tenant isolation: Each team requires guaranteed resources, network boundaries, and scoped credentials. The isolation model becomes as critical as the compute model.

Lambda's recent launches address many of these individually. Managed Instances solve connection persistence. Durable Functions break the 15-minute ceiling for long-running workflows. Tenant Isolation provides native tenant boundaries. For many multi-tenant workloads, these capabilities narrow the gap significantly.

For this specific workload—long-running agents needing persistent connections, cross-tenant analysis, GPU inference, and namespace-level isolation simultaneously—the decision framework points toward a container-native execution model with serverless-like operations. EKS Auto Mode fits this profile.

The decision framework

Rather than framing this as Lambda versus containers, the question becomes: which characteristics does your workload actually require?

Lambda with Managed Instances and Durable Functions provides stateless event handling, rapid scaling, and pay-per-invocation economics. Kubernetes natively offers namespaces, RBAC, NetworkPolicies, persistent connections, shared memory for cross-tenant analysis, and centralized rate limiting.

The deciding factor for my workload: I need all of the right-column characteristics simultaneously. Together, they compose more naturally in a container-native environment.

Cross-team pattern detection requires shared analysis context. ML-based bug classification requires burst GPU capacity. Per-team isolation requires namespace-level boundaries. Centralized rate limiting requires a persistent shared service. Each is individually solvable in Lambda. Together, they compose more naturally in a container-native environment.

What emerges at scale: cross-team intelligence

The most valuable architectural capability that emerges at multi-tenant scale isn't per-team automation—it's cross-team pattern detection. This is what makes the scaling exercise worthwhile.

Cross-team failure correlation

When 50 teams run test suites independently, failures appear isolated. But patterns emerge across teams that no single team can observe:

  • Three teams report navigation failures on the same firmware build → systemic regression, not three independent bugs
  • Test failures correlate with deployment timing across unrelated services → infrastructure issue, not product bugs
  • Identical error signatures across teams with different test suites → shared dependency failure

This requires an analysis engine holding context from all teams simultaneously—comparing fingerprints, correlating timestamps, identifying shared root causes. That's a persistent, long-running workload with access to cross-tenant state. It runs naturally as a shared service in a platform namespace, consuming events from all tenant agents.

ML-based bug classification

With sufficient historical data—thousands of bugs filed across teams—patterns become classifiable:

  • Auto-assign bugs to the correct component owner based on failure signature
  • Predict severity based on failure characteristics (crash versus degraded behavior versus cosmetic)
  • Suggest related bugs for investigation ("this looks like the same root cause as PROJ-4521")
  • Detect anomalous failure rates before they become incident-scale

This inference workload is bursty—GPU capacity is needed when bugs arrive, not 24/7. A GPU NodePool scaling to zero when idle and provisioning g5 instances only during inference keeps costs proportional to actual usage. The same pod filing a bug can synchronously call the classification service, receive a component assignment, and include it in the ticket—all within one request path.

Queryable knowledge base via Slack

The agent becomes more than an automation tool—it becomes the organization's queryable QA state. Via Slack, anyone can ask:

  • "What's the failure rate for navigation this week across all teams?"
  • "Show me regressions introduced in build 2.4.1"
  • "Which teams are seeing the most P0 bugs right now?"

This transforms the agent from a task automator into an intelligence layer. Answers require cross-team state aggregation, trend computation, and natural language interpretation—all served from persistent, indexed state accumulating over time.

EKS Auto Mode for multi-tenant platforms

EKS Auto Mode, launched at re:Invent 2024, promises full Kubernetes without node management. For a multi-tenant agent platform, this means:

  • Nodes appear on demand. Deploy a tenant namespace with an auto-filer pod. The Karpenter-based scheduler provisions a node within seconds. When the pod is deleted (tenant offboarded), the node is consolidated or terminated automatically. EC2 instances never require manual attention.
  • Security is not a configuration burden. Nodes run immutable Bottlerocket AMIs—read-only root filesystem, SELinux enforcing, no SSH access. Nodes rotate every 21 days automatically. For long-running agent pods, this means a graceful drain roughly every three weeks, at most one missed poll cycle.
  • Scaling reacts to demand. During off-hours when agents are idle between polls, Auto Mode consolidates workloads onto fewer nodes. You pay for what you use.
  • GPU workloads integrate without architectural changes. Define a GPU NodePool for the ML classification service. EKS Auto Mode provisions g5 instances only when inference pods are scheduled and terminates them when done.

The multi-tenant architecture

At scale, the system would consist of three layers:

  1. Shared platform services: a rate limiter preventing any single tenant from exhausting external API quotas, a connection pool manager maintaining persistent sessions to TestRail and JIRA, and a Prometheus instance collecting metrics across all tenants.
  2. Per-tenant agent namespaces: each team gets an isolated namespace containing their auto-filer pod, reporter pod, and Slack bot pod. ResourceQuotas guarantee resources. NetworkPolicies enforce that Team A's pods cannot communicate with Team B's pods. Each namespace's service account assumes a tenant-scoped IAM role via IRSA.
  3. Shared ML inference namespace: GPU-enabled pods running classification models that all tenants can invoke. This namespace has its own NodePool scaling to zero when no inference is happening.

The agent code remains essentially the same Python running on Lambda today—the core decision engine (observe, dedup, decide, act) doesn't change. What changes is the execution model: instead of being invoked per-event and destroyed, the agent runs as a long-lived async loop with persistent connections, graceful shutdown handling, and internal scheduling.

The AWS portfolio working together

The right framing isn't "migrate off Lambda onto EKS." It's "use each service where it fits":

  • Lambda remains the entry point. New teams start here. Single-team automation at $5/month with zero ops. Event-driven triggers, rapid iteration, pay-per-invocation economics.
  • Lambda with Durable Functions handles teams needing longer analysis windows or multi-step orchestration without leaving the serverless model.
  • EKS Auto Mode serves the platform layer when you need persistent multi-tenant services, cross-team intelligence, GPU inference, and namespace-level isolation working together.
  • DynamoDB persists state across all layers—dedup records, bug history, trend data.
  • EventBridge orchestrates events whether the consumer is a Lambda function or a Kubernetes pod.

A team needing 30-minute analysis windows or multi-step workflows (poll → correlate → file → notify → wait for response → update) benefits from Durable Functions without leaving serverless. You remain here until needing cross-tenant shared state or GPU—that's the signal to evaluate Auto Mode.

Lambda validates the pattern. EKS Auto Mode operationalizes it at scale. They're stages in a journey, not competitors.

Intelligence moves up the stack as organizational needs mature. Lambda validates the pattern. EKS Auto Mode operationalizes it at scale. They're stages in a journey, not competitors.

Key takeaways

  • Start serverless: Lambda lets you validate the agentic pattern at zero operational cost. The $5/month price point removes all friction for proving the concept works. Don't prematurely optimize for scale you don't have.
  • Design for portability from day one: Structure your Lambda function as a pure decision engine with external state. Containerizing it means wrapping it in an async loop and adding a health endpoint. If you build Lambda functions as self-contained decision engines rather than tightly coupled to the invocation model, the transition is a one-day exercise whenever you need it.
  • The decision trigger isn't scale—it's workload characteristics: Don't move because you hit 50 teams. Move when you need capabilities that benefit from persistent, shared infrastructure: cross-team correlation, centralized rate limiting, GPU inference, streaming connections.
  • Multi-tenancy is an isolation problem, not a compute problem: Both Lambda (Tenant Isolation) and Kubernetes (namespaces) solve this. Choose based on what other characteristics your workload needs alongside isolation.
  • EKS Auto Mode closes the operational gap: Before Auto Mode, choosing EKS meant accepting node management overhead. Auto Mode removes that tradeoff. You get container-native execution with serverless-like operations.

The cost math

Single team on Lambda today: $3-5/month, saving 8-10 hours per week. That's a 67x ROI. Fifty teams on EKS Auto Mode would cost approximately $200-250/month total—roughly $4-5 per team per month. The per-team economics match Lambda, but you gain namespace isolation, persistent connections, GPU-ready infrastructure, centralized observability, and built-in organizational governance.

The cost-per-team barely changes. What changes is what you get for it.

What comes next

The agentic pattern—observe, decide, act—is infrastructure-agnostic. The decision logic doesn't care about its deployment target. What changes is what becomes possible when agents stop operating in isolation.

The next frontier isn't single agents doing single tasks faster. It's agents coordinating with other agents.

An auto-filer agent detects a failure pattern and hands context to a root-cause agent, which traces the dependency chain across services, identifies the offending commit, and drafts a fix recommendation—all before a human sees the bug ticket. Agent-to-agent delegation, where one agent's output becomes another's input without human routing in between.

Beyond that: agents that build their own decision models. Today, the dedup logic and regression detection rules are hand-coded. Tomorrow, the agent observes which filed bugs humans close as duplicates, learns from those corrections, and tightens its own classification boundaries. The system improves not because better code ships, but because it accumulates organizational judgment over time.

The system started as a weekend project to stop filing bugs manually. It now runs in production, eliminating an entire category of manual work from QA operations. The infrastructure question stays the same—serverless for validation, containers for scale. But the agents running on that infrastructure are about to get significantly more capable. Teams with the platform layer ready will be the ones that can adopt those capabilities without rearchitecting.