Amazon AMET Payments Accelerated Test Case Generation 20x: How a Multi-Agent AI System Transformed QA

The Amazon AMET Payments team, managing payment systems for 10 million customers across five countries, releases about five new features monthly. Previously, in-depth testing for each feature consumed a full week of manual labor: analyzing documentation, mockups, requirements, and past test preparations. After implementing a multi-agent AI system, the same workload now takes only a few hours. This resulted in a 20x acceleration, and the resource that once required one full-time engineer for an entire year ceased to be a bottleneck.

In development teams, routine test case generation is an invisible resource drain. Weeks are spent manually dissecting documentation, mockups, and requirements: engineers perform essential but mechanical work that creates no new value. Multiply one week by five features a month, and you get a constant bottleneck that slows releases, increases development costs, and burns out people hired for strategic thinking. This problem is solvable, and the Amazon AMET Payments case shows exactly how.

The Process Before AI Agents

Before automation, every new project at Amazon AMET Payments began the same way: a QA engineer would take a stack of documents and start analyzing them manually. Business requirements, design documentation, user interface mockups, records of past test campaigns — all had to be read, collated, and transformed into a specific set of test cases. One project took a full week. With five new features per month, this meant one engineer spent virtually the entire year solely on this task.

The problem wasn't just about the hours spent. Engineers, hired for their ability to think about product quality, spent a significant portion of their time working as operators: reading, copying, structuring. This was tiring and demotivating. Furthermore, the manual approach didn't scale: if the volume of features grew, the team simply couldn't keep up with testing everything, and some features went into release with insufficient coverage and increased risks.

Why Simple AI Couldn't Solve the Problem

Initial attempts to solve the problem with simple AI tools, such as feeding all documentation as a single stream to one agent, proved ineffective. The results were too vague. Instead of a concrete test case, the system would output something like "check that payment works correctly," which provided no practical value to the engineer. It became clear that the task required a different approach.

Test case generation isn't just about searching a document or rephrasing requirements. It's a cognitive process: understanding the user, their journey, where the system might behave unexpectedly, and which edge cases are crucial for a payment service. An experienced QA engineer does this intuitively because they simultaneously hold multiple layers in mind: business logic, UX, customer segments, state transitions. A single agent with a large context couldn't replicate this process: it either skimmed the surface or drowned in details without structure.

The Amazon AMET Payments team reframed the task: not "how to teach AI to read documentation," but "how should AI think like an experienced QA engineer?" The answer was a multi-agent architecture, where each agent is responsible for a narrow layer of the task, and an orchestrator assembles the results into a cohesive whole.

How the Multi-Agent System Was Designed

The system was named SAARAM (QA Lifecycle App). Its core idea was to decompose a complex task into manageable subtasks, each performed by a specialized agent. This approach mimics the work of a real team, where different specialists are responsible for different aspects of testing.

• Document Analysis Agents. The first layer of the system, responsible for information extraction and structuring. These agents parsed business requirements, design documentation, and mockups, identifying acceptance criteria, user scenarios, UX requirements, and target user data. The result was a primary knowledge base for subsequent agents.
• Test Development Agents. The second layer, systematically creating test cases. Agents analyzed user journeys, identified potential scenarios, mapped data flows, and based on all this, generated concrete, detailed test cases with step-by-step instructions and expected outcomes. Not "check payment," but a precise scenario with input data, actions, and expected results.
• Specialized Iteration Agents. The third layer was responsible for coverage depth. Separate agents handled customer segmentation: "new users," "loyal customers," "users from different countries" — each segment received its own set of scenarios. Other agents mapped user journeys for each segment, analyzed coverage, and managed state transitions within the system: "before payment," "in progress," "after payment," "on error."

An orchestrator coordinated the entire chain: receiving source materials, distributing tasks among agents, collecting results, and forming the final set of test cases. The modular architecture achieved what a single agent could not: high accuracy through specialization and comprehensive coverage through parallel work of multiple layers.

Implementation and Team Adaptation

Implementation began with a pilot group. The fundamental decision was not to disrupt existing workflows but to integrate the system into them. SAARAM augmented the most labor-intensive stages without requiring engineers to learn a fundamentally new interface or change their work logic. Agents took over analysis and initial generation; the engineer received a ready set of test cases and continued working with them.

Feedback from early users went directly into agent refinement. If a certain type of scenario proved weak, it was clarified and calibrated. This quickly raised accuracy to a level where engineers stopped viewing the system as an experiment and began using it as a standard work tool. Gradually, the scale expanded. Engineers, convinced of the quality of the generated test cases, began to connect new projects themselves. The time saved was redirected to exploratory testing, risk analysis, and improving test architecture — precisely the work they were hired for. Following the pilot, the system was deemed successful and planned for rollout to other QA teams within the company.

Results

A twentyfold acceleration is not just a nice number. For a team releasing five features a month, it means testing is no longer a bottleneck: every feature receives full coverage on time, regardless of the team's workload. Engineers regained time for work that truly requires human judgment.

How to Apply This to Your Business

The SAARAM logic can be applied to any process where a valuable specialist spends a significant amount of time analyzing documents and creating similar structured artifacts. If your company has such a bottleneck, here's where to start:

• Identify tasks requiring large-volume text analysis. QA, legal departments, compliance, analytics — wherever specialists regularly review documentation and create structured insights based on it, AI agents can handle primary analysis and draft generation.
• Decompose the task into narrow layers. One agent, one specialization. An agent that extracts requirements should not simultaneously generate test cases. Layer separation provides accuracy that a single, universal agent cannot achieve.
• Emulate the thinking of your best specialist, not the average. Before designing agents, talk to the most experienced person on the team: how they decompose the task, what they prioritize, which segments and edge cases they check. This logic should form the basis of your agents.
• Integrate, don't replace. Agents should complement existing workflows, not demand their overhaul. The less engineers have to change their habits, the faster the system will become part of daily work, not an experiment.
• Start with a pilot and iterate based on feedback. Launch the system on one type of task, gather feedback from early users, and calibrate the agents. Only then scale to other teams.

If this case sounds like what's happening in your company, our manager can help: he'll analyze your business and niche for free and point out where an AI agent would bring a real result in your case. Message the manager