AivexaNewsSearch
AI news for builders and product teamsChecked every hour

How TCS built an agentic test orchestrator with Amazon Bedrock AgentCore

Collected Nov 10, 2026

TCS has put its Agentic Test Orchestrator into production for banking, financial services and insurance (BFSI) clients, with the architecture described in an AWS Machine Learning Blog post co-written by Varun Valsan of TCS. The platform takes a tester's inputs (Jira stories, business requirement documents, Swagger specifications, uploaded documents, GitLab source folders or captured UI flows) and generates test scenarios, Gherkin feature files and executable Java or Python tests, then runs them and returns artifacts and reports through a per-tenant web application.

TCS framed the problem as the stretch after application code is written. Designing scenarios, writing and maintaining automation, preparing environments, investigating failures and assembling evidence consume engineering time, and a traditional automation suite leaves that work in place. Scripts tied to one user story go stale when a linked story changes, and a single generative AI prompt does not give a regulated workflow the control it needs. TCS listed four requirements: tests grounded in project context rather than generic prompts, coverage of both API and browser UI testing, isolated data and knowledge stores per tenant, and a repeatable path from requirement ingestion to test evidence.

The orchestrator decomposes testing into specialized tasks, each with its own agent, tools, validation rules and context. A deterministic supervisor routes work, and an execution workflow governs retries, error classification, persistence and reporting. The agents run as containerized services in Amazon Bedrock AgentCore runtime, built with the Strands Agents SDK. TCS cited three reasons for choosing AgentCore: model choice through Amazon Bedrock, so each agent can use the model that suits its task and newer models can be adopted later; a runtime that scales with demand so many tenants can run sessions concurrently without TCS provisioning servers; and per-session isolation in microVMs, which supplies the multi-tenant separation TCS would otherwise have had to build.

The platform separates a shared control plane from tenant application planes. The control plane holds the Amazon EKS cluster, container registry, administrative portal, tenant registry, onboarding automation, CloudFront distributions and AWS WAF protection. Each tenant gets its own Kubernetes namespace, Cognito user pool, KMS key, S3 bucket, DynamoDB tables and Bedrock Knowledge Bases. Onboarding is event driven: the admin API writes a pending tenant record, emits an event through EventBridge, and CodeBuild deploys that tenant's infrastructure with the AWS CDK.

Grounding comes from documents and synchronized source files indexed in Bedrock Knowledge Bases as vector embeddings, with retrieval filtered by tenant, project and session before anything reaches an agent. That is effectively retrieval-augmented generation scoped to a single client's repository. A separate capture service uses Puppeteer to turn a URL and a natural-language goal into a UI flow document and an XPath locator document, which is how browser interactions become reusable structured artifacts rather than improvised prompts.

The agent lineup maps to lifecycle stages. A generation agent writes structured scenarios, converts them to Gherkin, produces Java or Python automation and validates the code. A chat agent sorts each request into an information query or an update and answers or revises the active artifact. A dynamic task agent pulls BRD context and produces a structured user story with requirements and acceptance criteria. An incremental agent extends scenarios, Gherkin or tests across a linked chain of Jira stories instead of regenerating from scratch. An execution agent fetches artifacts, picks an environment, runs tests, classifies failures, applies controlled fixes and saves results.

Execution routing depends on test type, detected from the generated code. API tests run on Amazon ECS with AWS Fargate; Selenium UI tests run on an ECS cluster backed by EC2 instances running Chrome with a virtual display. For UI runs the executor can capture that display with FFmpeg and publish an HTTP Live Streaming feed to S3 for delivery through CloudFront, so a reviewer can watch a failing browser test rather than read only its stack trace. Logs go to CloudWatch, and Cucumber reports are stored in S3 with time-limited access.

The correction loop is a LangGraph workflow with fixed fetch, execute, fix and save steps and a bounded retry count. Fetch retrieves the test project and assets, sanitizes files and detects the framework. Execute launches the chosen ECS task, monitors status, gathers logs and parses results. A failure classified as a code error, within the retry policy, goes to a fixing agent with constrained error context and a targeted correction; safety checks reject empty files, unexpected new files and extreme size changes, and environment failures such as connectivity or authentication problems never reach the code fixer. Save persists code, status, attempt count, logs, parsed results and report location.

Security is layered. Separate Cognito user pools serve administrators and each tenant, with JWT validation and role-based authorization. Data controls include per-tenant KMS keys and encrypted S3, tenant-scoped DynamoDB access, and Secrets Manager for Jira and GitLab credentials. On EKS, namespaces, NetworkPolicy and ResourceQuota separate tenants, containers run as non-root with Linux capabilities dropped, and WAF managed rules and rate limits guard the edge. OpenTelemetry traces follow agent activity, with CloudWatch and Container Insights for observability.

The headline number is effort. Against a representative workload of about 100 scenarios, TCS measured roughly two hours of engineer effort per scenario manually, or about 200 hours total, versus about 14 minutes per scenario, or about 24 hours, with the orchestrator; TCS reports that as an 88 percent reduction and notes the figure comes from a controlled internal benchmark, with results varying by workload, complexity and team. This is a self-reported comparison on one workload, so the number is best read as directional rather than a general claim, and it measures engineer effort captured by the process rather than total cost of the platform.

Why it matters: teams building internal tooling for regulated industries now have a documented pattern for multi-agent systems where isolation, bounded retries and auditability are design constraints rather than afterthoughts. The architecture suggests a likely split for adopters: orchestration logic and context hygiene are where the engineering effort goes, while runtime scaling and session isolation can be outsourced to a managed agent service. Engineers in QA organizations are the most directly affected; in TCS's account they move from hand-building scripts to reviewing and governing generated artifacts, which shifts the skill mix toward risk analysis and exploratory testing. The 88 percent figure should be validated on your own workload before it informs a business case.

Read at AWS Machine Learning Blog

Based on reporting from the original publisher. Visit the source for full context and later updates.

Publisher excerpt

Tata Consultancy Services (TCS) built an agentic test orchestrator on Amazon Bedrock AgentCore that turns requirements into executable, governed tests for its Banking, Financial Services, and Insurance (BFSI) clients. Learn how specialized agents, per-tenant isolation, and workload-aware execution cut testing effort by 88% in an internal benchmark.