AetherTest: Autonomous AI testing with Amazon Nova. Describe -> Generate -> Execute -> Validate. No scripts. No selectors. Pure AI magic.

AetherTest — Autonomous AI-Powered Software Testing with Amazon Nova

A generative AI application built on AWS using Amazon Nova as the core foundation model.

Describe what to test in plain English. Watch AI agents analyze requirements, generate test cases, execute them in a live browser, validate results with computer vision, and deliver a quality report — entirely autonomously. No scripts. No selectors. No manual translation.

📹 Demo Video `#AmazonNova`

▶️ Click the image above to watch the demo video · Recorded from a locally running instance via Docker Compose

🏆 Amazon Nova Hackathon Submission

Field	Details
Project	AetherTest — The Autonomous STLC Engine
Category	Agentic AI · UI Automation · Multimodal Understanding
Core Model	Amazon Nova Lite (`amazon.nova-lite-v1:0`) on Amazon Bedrock
Agentic Framework	Strands Agents SDK with Amazon Bedrock
UI Automation	Amazon Nova Act (integration implemented, see Nova Act note)
Vision	Claude Haiku 4.5 via Bedrock (primary) + Amazon Nova Pro (fallback)
Demo Video	▶️ Watch Demo Video `#AmazonNova`
Repository	This repository — see Quick Start for setup

Short Description

AetherTest is an autonomous software testing platform that uses Amazon Nova foundation models on AWS Bedrock to eliminate the gap between requirements and test execution. Users describe tests in plain English; a multi-agent AI pipeline powered by Strands Agents and Amazon Nova orchestrates the entire testing lifecycle — from requirement analysis through browser execution to vision-validated quality reports — with zero manual scripting.

How Amazon Nova Powers AetherTest

AetherTest is built from the ground up on Amazon Nova and AWS Bedrock services:

Amazon Nova Component	Role in AetherTest	Implementation
Amazon Nova Lite (`amazon.nova-lite-v1:0`)	Primary orchestrator and reasoning model — plans test strategies, dispatches tools, manages the 5-agent pipeline	`backend/app/agents/orchestrator.py` — Bedrock Converse API
Amazon Nova Pro (`amazon.nova-pro-v1:0`)	Strands Agents orchestration model + vision fallback for screenshot analysis	`backend/app/agents/strands_orchestrator.py`, `backend/app/tools/vision_tools.py`
Amazon Nova Act	UI automation — browser interaction via natural language commands	Integration code implemented (see Nova Act section)
Amazon Nova Lite (memory)	AI-powered memory consolidation and semantic querying of past test sessions	`backend/app/memory/service.py`

Model Usage Breakdown

┌─────────────────────────────────────────────────────────────────────────────────┐
│                              AMAZON BEDROCK                                      │
│                                                                                  │
│  ┌──────────────────────┐  ┌──────────────────────┐  ┌───────────────────────┐  │
│  │  Amazon Nova Lite    │  │  Amazon Nova Pro     │  │  Claude Haiku 4.5     │  │
│  │  (Orchestrator)      │  │  (Strands Agent +    │  │  (Vision Analysis +   │  │
│  │  Planning, Reasoning │  │   Vision Fallback)   │  │   Browser Automation) │  │
│  │  Tool Dispatch       │  │                      │  │                       │  │
│  └──────────────────────┘  └──────────────────────┘  └───────────────────────┘  │
│                                                                                  │
│  ┌──────────────────────┐  ┌──────────────────────┐                             │
│  │  Amazon Nova Act     │  │  Amazon Nova Lite    │                             │
│  │  (UI Automation)     │  │  (Memory Layer)      │                             │
│  │  Browser Interaction │  │  Consolidation &     │                             │
│  │  via NL Commands     │  │  Semantic Queries    │                             │
│  └──────────────────────┘  └──────────────────────┘                             │
└─────────────────────────────────────────────────────────────────────────────────┘

Hackathon Categories Addressed

1. Agentic AI

AetherTest implements a full agentic AI pipeline using Strands Agents SDK on Amazon Bedrock:

A 5-agent pipeline (Requirement Analyst → Test Case Architect → Browser Specialist → Monitor Validator → Report Generator) orchestrated by Amazon Nova
Each agent has specialized tools and responsibilities, coordinated through Bedrock's Converse API
Strands Agents SDK provides the agent loop, streaming, and tool orchestration (USE_STRANDS=true)
The orchestrator uses Amazon Nova Pro (amazon.nova-pro-v1:0) as the BedrockModel in Strands mode

2. UI Automation

Amazon Nova Act integration for natural-language-driven browser automation (see Nova Act section)
CDP-based browser control with vision-guided element identification
Self-healing test execution — AI adapts to UI changes without brittle selectors

3. Multimodal Understanding

Screenshot capture and vision analysis using Claude Haiku 4.5 via Bedrock (primary)
Amazon Nova Pro as a vision fallback — analyzes screenshots when Claude Haiku is unavailable
The AI validates test results by visually inspecting browser state, not DOM assertions

🤖 Amazon Nova Act Integration

AetherTest includes integration code for Amazon Nova Act, Amazon's foundation model purpose-built for UI automation and browser interaction.

What Nova Act Enables

Natural language browser commands (e.g., "Click the login button and enter credentials")
Vision-based element targeting without DOM selectors
Resilient UI automation that adapts to layout changes

Setup

To enable Nova Act, create a local .env file with the following:

# Amazon Nova Act Configuration
NOVA_ACT_ENABLED=true
NOVA_ACT_API_KEY=your-nova-act-api-key
AWS_REGION=us-east-1

⚠️ Important Note on Nova Act Testing

Nova Act could not be fully end-to-end tested due to lack of available AWS credits during the hackathon period. The integration code is fully implemented and wired into the tool dispatch pipeline, but live validation against the Nova Act API was not possible. The architecture is designed so that enabling NOVA_ACT_ENABLED=true activates Nova Act as the primary browser automation engine, with the existing CDP + browser-use pipeline serving as the fallback.

The current working browser automation uses:

browser-use library with Claude Haiku 4.5 via ChatAWSBedrock for AI-driven navigation
Chrome DevTools Protocol (CDP) for direct browser control (navigate, click, type, screenshot)
PageAgent bridge for indexed DOM element interactions

The Problem — The Translation Gap

Current tools don't solve this. Selenium, Cypress, even "low-code" tools still require:

Manual authoring of test scripts
DOM selector maintenance (breaks on every UI change)
Testing can only start after code is "stable"

Dimension	Selenium / Cypress	AetherTest + Amazon Nova
Test Creation	Manual scripting	Plain English description (seconds)
Element Targeting	DOM selectors	Vision-based — identifies by appearance
UI Change Resilience	Breaks, manual fix	Self-heals via Amazon Nova reasoning
Maintenance	30% of tester time	Near-zero — AI adapts automatically

AetherTest eliminates this translation gap entirely.

Architecture

Local Development Architecture (Demo Environment)

📹 The demo video showcases AetherTest running entirely locally via Docker Compose on a developer machine. All 3 services (backend, frontend, browser sandbox) run as local containers, with Amazon Bedrock accessed over the internet for AI model inference.

┌─ Developer Machine (Docker Compose) ────────────────────────────────────────────┐
│                                                                                  │
│  ┌───────────────────────┐  ┌───────────────────┐  ┌───────────────────────────┐│
│  │   FastAPI Backend     │  │   Next.js 14      │  │   Browser Sandbox         ││
│  │   • Nova Orchestrator │  │   • Dashboard     │  │   • Chromium + CDP        ││
│  │   • Strands Agents    │  │   • Live VNC      │  │   • Xvfb + x11vnc        ││
│  │   • WebSocket         │  │   • Test Results  │  │   • noVNC streaming       ││
│  │   • Memory (SQLite)   │  │   • 3D Visuals    │  │   • FFmpeg recording      ││
│  │   Port: 8001          │  │   Port: 3001      │  │   Ports: 9222, 6080, 8888 ││
│  └──────────┬────────────┘  └───────────────────┘  └───────────────────────────┘│
│             │                                                                    │
└─────────────┼────────────────────────────────────────────────────────────────────┘
              │ HTTPS (Bedrock API)
              ▼
┌─────────────────────────────────────────────────────────────────────────────────┐
│                          AWS CLOUD (Amazon Bedrock)                               │
│                                                                                  │
│  ┌──────────────────────┐  ┌──────────────────────┐  ┌───────────────────────┐  │
│  │  Amazon Nova Lite    │  │  Amazon Nova Pro     │  │  Claude Haiku 4.5     │  │
│  │  (Orchestrator)      │  │  (Strands + Vision)  │  │  (Vision + Browser)   │  │
│  └──────────────────────┘  └──────────────────────┘  └───────────────────────┘  │
│                                                                                  │
│  ┌──────────────────────┐                                                       │
│  │  Amazon Nova Act     │                                                       │
│  │  (UI Automation)     │                                                       │
│  └──────────────────────┘                                                       │
└─────────────────────────────────────────────────────────────────────────────────┘

Local ports:

Port	Service	Description
3001	Frontend	Next.js dashboard
8001	Backend	FastAPI + WebSocket
6080	noVNC	Live browser view
5900	VNC	Raw VNC connection
9222	CDP	Chrome DevTools Protocol
8888	Recorder	FFmpeg recording API

Proposed Production Architecture (AWS Cloud)

┌─────────────────────────────────────────────────────────────────────────────────┐
│                              AWS CLOUD                                           │
│                                                                                  │
│  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────────────────┐   │
│  │  CloudFront      │  │  API Gateway     │  │  Cognito                     │   │
│  │  CDN + Frontend  │  │  REST + WS       │  │  User Authentication         │   │
│  └────────┬─────────┘  └────────┬─────────┘  └──────────────────────────────┘   │
│           │                     │                                                │
│           ▼                     ▼                                                │
│  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────────────────┐   │
│  │  S3              │  │  AgentCore       │  │  ECS Fargate                 │   │
│  │  Static Assets   │  │  Runtime         │  │  Browser Sandbox             │   │
│  │  Reports         │  │  Strands Agent   │  │  Chromium + CDP + noVNC      │   │
│  │  Recordings      │  │  (Nova Pro)      │  │  FFmpeg Recording            │   │
│  └──────────────────┘  └────────┬─────────┘  └──────────────────────────────┘   │
│                                 │                                                │
│           ┌─────────────────────┼─────────────────────┐                         │
│           ▼                     ▼                     ▼                          │
│  ┌──────────────────┐  ┌──────────────────┐  ┌──────────────────────────────┐   │
│  │  Amazon Bedrock   │  │  AgentCore      │  │  DynamoDB                    │   │
│  │  Nova Lite/Pro    │  │  Memory         │  │  Sessions + Test Cases       │   │
│  │  Claude Haiku     │  │  Short/Long     │  │                              │   │
│  │  Nova Act         │  │  Term Memory    │  │                              │   │
│  └──────────────────┘  └──────────────────┘  └──────────────────────────────┘   │
│                                                                                  │
│  ┌──────────────────┐  ┌──────────────────┐                                     │
│  │  CloudWatch      │  │  X-Ray           │                                     │
│  │  Logs + Metrics  │  │  Distributed     │                                     │
│  │  Alarms          │  │  Tracing         │                                     │
│  └──────────────────┘  └──────────────────┘                                     │
└─────────────────────────────────────────────────────────────────────────────────┘

Key differences from local to production:

Aspect	Local (Demo)	Production (AWS)
Frontend hosting	Docker container (port 3001)	CloudFront + S3
Backend hosting	Docker container (port 8001)	Bedrock AgentCore Runtime
Browser sandbox	Docker container (Chromium)	ECS Fargate (auto-scaling)
Database	SQLite files	DynamoDB
Memory layer	SQLite (`local_store.py`)	AgentCore Memory (`agentcore_store.py`)
Authentication	None (local dev)	Amazon Cognito
API access	Direct HTTP	API Gateway + WebSocket
Storage	Local filesystem	S3 (reports, recordings, screenshots)
Observability	Console logs	CloudWatch + X-Ray

5-Agent Pipeline (Powered by Amazon Nova)

Phase	Agent	Amazon Nova Role	Tools	Output
1	Requirement Analyst	Nova Lite plans analysis	—	Structured breakdown
2	Test Case Architect	Nova Lite generates cases	`register_test_cases`	BDD test cases
3	Browser Specialist	Nova Act / CDP execution	`execute_browser_task`, `get_credentials`, CDP tools	Live browser actions
4	Monitor Validator	Nova Pro / Haiku vision	`capture_screenshot`, `analyze_screenshot`	PASS/FAIL verdicts
5	Report Generator	Nova Lite summarizes	`save_report`	Quality report

Quick Start

Prerequisites

Docker Desktop
AWS Account with Bedrock access (Amazon Nova Lite, Nova Pro, Claude Haiku 4.5)
(Optional) Amazon Nova Act API key for UI automation

1. Clone the Repository

git clone <repository-url>
cd AetherTest-Amazon-Nova

2. Configure Environment

cp .env.example .env

Edit .env with your AWS credentials:

# Required — AWS Bedrock access
AWS_ACCESS_KEY_ID=AKIA...
AWS_SECRET_ACCESS_KEY=...
AWS_REGION=us-east-1

# Optional — Enable Strands Agents SDK
USE_STRANDS=true

# Optional — Enable Amazon Nova Act for UI automation
NOVA_ACT_ENABLED=true
NOVA_ACT_API_KEY=your-nova-act-api-key

3. Launch with Docker

docker compose up --build

4. Access the Application

Service	URL
Dashboard	http://localhost:3001
Live Browser (noVNC)	http://localhost:6080
API Docs (Swagger)	http://localhost:8001/docs

5. Run a Test

Enter a requirement: "Test login with valid and invalid credentials"
Enter target URL: "https://the-internet.herokuapp.com/login"
Select test scope (Quick / Standard / Thorough)
Click Launch and watch Amazon Nova orchestrate the test pipeline

AWS Services Used

AWS Service	Purpose	Model ID
Amazon Bedrock	AI platform for all model access	—
Amazon Nova Lite	Primary orchestrator — planning, reasoning, tool dispatch, memory queries	`amazon.nova-lite-v1:0`
Amazon Nova Pro	Strands Agent model + vision analysis fallback	`amazon.nova-pro-v1:0`
Amazon Nova Act	UI automation via natural language (integration implemented)	—
Claude Haiku 4.5 (via Bedrock)	Primary vision analysis + browser-use automation	`us.anthropic.claude-haiku-4-5-20251001-v1:0`
Strands Agents SDK	Agentic orchestration framework on Bedrock	—
Bedrock AgentCore Memory	Production memory persistence (target deployment)	—
Bedrock AgentCore Runtime	Production agent hosting (target deployment)	—

Strands Agents SDK

AetherTest supports the Strands Agents SDK for agentic orchestration:

# Enable Strands mode in .env
USE_STRANDS=true

In Strands mode:

Amazon Nova Pro serves as the BedrockModel for the agent loop
Tools are registered as Strands-compatible functions
Built-in streaming, callback support, and memory integration
Ready for deployment to AWS Bedrock AgentCore Runtime

Vision Pipeline

Vision-related tasks are handled through a tiered approach using Bedrock models:

Primary: Claude Haiku 4.5 (us.anthropic.claude-haiku-4-5-20251001-v1:0) via invoke_model — optimized for screenshot analysis with vision support
Fallback: Amazon Nova Pro (amazon.nova-pro-v1:0) via Bedrock Converse API — used when Claude Haiku is unavailable or throttled
Memory queries: Amazon Nova Lite (amazon.nova-lite-v1:0) — fast AI-powered consolidation and semantic search over past test sessions

# Vision analysis flow (vision_tools.py)
# 1. Try Claude Haiku 4.5 (3 attempts with exponential backoff)
# 2. If all fail → fallback to Amazon Nova Pro vision
# 3. Both use Bedrock — no external API calls

Memory Layer (Always-On, Nova-Powered)

The memory layer uses Amazon Nova Lite for AI-powered operations:

Feature	Description	Model
Memory Storage	Structured memories with entities, topics, importance	SQLite / AgentCore
Semantic Search	Text-based memory retrieval	Amazon Nova Lite
Consolidation	Pattern discovery across sessions	Amazon Nova Lite
Query	Natural language memory queries	Amazon Nova Lite

Configuration

# Local development (SQLite)
MEMORY_STORE_TYPE=local
MEMORY_DB_PATH=./data/memory.db

# Production (AWS Bedrock AgentCore Memory)
MEMORY_STORE_TYPE=agentcore
AGENTCORE_MEMORY_ID=your-memory-id
AGENTCORE_MEMORY_REGION=us-west-2

Tech Stack

Backend

Component	Technology
API Framework	FastAPI 0.115.0
AI Platform	Amazon Bedrock
Orchestrator Model	Amazon Nova Lite
Agentic Framework	Strands Agents SDK
Vision (Primary)	Claude Haiku 4.5 via Bedrock
Vision (Fallback)	Amazon Nova Pro via Bedrock
UI Automation	Amazon Nova Act (implemented)
Browser Automation	browser-use + CDP
Memory AI	Amazon Nova Lite
Database	SQLite (aiosqlite)

Frontend

Component	Technology
Framework	Next.js 14 (App Router)
Styling	Tailwind CSS 3.4
State	Zustand 4.5
Animations	Framer Motion
3D Visuals	React Three Fiber
Live Browser	noVNC iframe

Infrastructure

Component	Technology
Containers	Docker Compose (3 services)
Browser Sandbox	Chromium + CDP + noVNC
Recording	FFmpeg
VNC	x11vnc + noVNC

Project Structure

AetherTest-Amazon-Nova/
├── docker-compose.yml          # 3 services: frontend, backend, sandbox
├── .env.example                # Environment template
│
├── backend/
│   ├── app/
│   │   ├── agents/
│   │   │   ├── orchestrator.py         # Amazon Nova Lite — Bedrock Converse loop
│   │   │   └── strands_orchestrator.py # Amazon Nova Pro — Strands SDK agent
│   │   ├── memory/
│   │   │   ├── service.py              # Amazon Nova Lite — AI memory queries
│   │   │   ├── local_store.py          # SQLite store (dev)
│   │   │   └── agentcore_store.py      # AWS AgentCore (prod)
│   │   ├── tools/
│   │   │   ├── browser_tools.py        # browser-use + CDP automation
│   │   │   ├── cdp_tools.py            # Direct CDP WebSocket tools
│   │   │   ├── nova_act_tools.py       # Amazon Nova Act UI automation
│   │   │   ├── pageagent_bridge.py     # Indexed DOM interactions
│   │   │   ├── vision_tools.py         # Claude Haiku 4.5 + Nova Pro vision
│   │   │   └── storage_tools.py        # Reports + credentials
│   │   └── api/
│   │       ├── sessions.py             # Session management
│   │       ├── credentials.py          # Encrypted credentials
│   │       ├── recording.py            # Screen recording
│   │       └── memory.py               # Memory Layer API
│   └── requirements.txt
│
├── frontend/                   # Next.js 14 frontend
│   ├── app/                    # App Router pages
│   ├── components/             # React components (3D, animations, UI)
│   ├── hooks/                  # WebSocket + state hooks
│   └── store/                  # Zustand stores
│
└── sandbox/
    ├── Dockerfile              # Debian + Chromium + noVNC
    ├── start.sh                # Container entrypoint
    └── recorder.py             # FFmpeg recording API

Demo

📹 The demo video is recorded from a locally running instance of AetherTest using Docker Compose. All AI inference calls go to Amazon Bedrock in the cloud, but the application itself (frontend, backend, browser sandbox) runs entirely on the developer's local machine. This demonstrates the full end-to-end flow without requiring any cloud infrastructure beyond Bedrock model access.

Demo flow (tag: #AmazonNova):

Type a test requirement in plain English
Select test scope (Quick: 3 / Standard: 5 / Thorough: 20 test cases)
Click Launch — watch the Amazon Nova-powered 5-agent pipeline activate
Live browser panel shows real Chromium executing tests via CDP (running locally in Docker)
Test cases populate with live PASS/FAIL status (vision-validated by Bedrock models)
Quality report generated with score, summary, and MP4 recording

Code Repository Access

Clone this repository
Copy .env.example to .env and fill in your AWS credentials
Run docker compose up --build to start all 3 services
Open http://localhost:3001 to access the dashboard

For local development without Docker:

# Backend
cd backend
python -m venv .venv && source .venv/bin/activate  # or .venv\Scripts\activate on Windows
pip install -r requirements.txt
playwright install chromium
uvicorn app.main:app --host 0.0.0.0 --port 8001 --reload

# Frontend (separate terminal)
cd frontend
npm install
npm run dev

Cost Estimate

Component	Model	Cost per Test
Orchestration	Amazon Nova Lite	~$0.005
Vision analysis	Claude Haiku 4.5 / Nova Pro	~$0.01
Browser task	Claude Haiku 4.5	~$0.02
Per test case		~$0.035
100 test cases		~$3.50

License

MIT License

Built with ❤️ for the Amazon Nova Hackathon using Amazon Nova on Amazon Bedrock
#AmazonNova

Built With

amazon
awsbedrock
browser-use
cdp
dockerfile
fastapi
ffmpeg
langchain
nextjs
novnc
sanbox
sqlite
strandsagents
typescript

Submitted to

Amazon Nova AI Hackathon

Created by

AetherTest — The Autonomous STLC Engine is a generative AI application that revolutionizes software testing by eliminating the gap between test requirements and execution.

Core Contribution:
I built an end-to-end autonomous AI-powered testing platform that leverages Amazon Nova foundation models on AWS Bedrock to orchestrate intelligent test generation, execution, and validation—entirely without manual scripting or DOM selector maintenance.

Key Innovations:
Agentic AI Pipeline

Architected a 5-agent pipeline (Requirement Analyst → Test Case Architect → Browser Specialist → Monitor Validator �� Report Generator) powered by Strands Agents SDK
Amazon Nova Lite manages orchestration, planning, and tool dispatch
Each agent has specialized responsibilities coordinated through Bedrock's Converse API
Natural Language Test Generation

Users describe tests in plain English—no coding required
AI autonomously generates BDD-style test cases
Self-healing tests adapt to UI changes without brittle selectors
Multimodal Vision-Based Validation

Claude Haiku 4.5 (primary) + Amazon Nova Pro (fallback) analyze screenshots
Computer vision validates test results instead of DOM assertions
Real-time vision-guided element identification
UI Automation without Selectors

Browser automation via browser-use + CDP (Chrome DevTools Protocol)
Amazon Nova Act integration for natural language browser commands
Vision-based element targeting
Full-Stack Architecture

Backend: FastAPI + Python with Amazon Bedrock integration
Frontend: Next.js 14 with real-time WebSocket updates, 3D visualizations (React Three Fiber), and live browser streaming (noVNC)
Infrastructure: Docker Compose (local) → AWS cloud-native (production with ECS Fargate, DynamoDB, CloudFront)
Memory & Intelligence Layer

Amazon Nova Lite powers AI-driven semantic search and memory consolidation
Tracks test history, patterns, and entities across sessions
Natural language memory queries
Technical Achievements:
Zero Manual Scripting: Tests generated automatically from plain English requirements
Zero Selector Maintenance: Vision-based element targeting adapts to UI changes
Production-Ready: Designed for AWS Bedrock AgentCore Runtime deployment
Strands Agents Integration: Ready for enterprise agentic orchestration
Cost-Efficient: ~$0.035 per test case using Nova Lite/Pro
What Makes It Unique:
Aspect Traditional Tools (Selenium/Cypress) AetherTest + Amazon Nova
Test Creation Manual scripting (hours) Plain English (seconds)
Element Targeting DOM selectors (brittle) Vision-based (adaptive)
UI Change Resilience Manual fixes required Self-heals automatically
Maintenance Burden 30% of tester time Near-zero
Technologies Used:
Languages: Python (52.8%), TypeScript (42.9%)
AI/Cloud: Amazon Bedrock, Amazon Nova Lite/Pro, Claude Haiku 4.5, Strands Agents SDK
Backend: FastAPI, boto3, LangChain, browser-use, Playwright
Frontend: Next.js 14, Tailwind CSS, Zustand, Framer Motion, React Three Fiber
Infrastructure: Docker Compose, Chromium + CDP, noVNC, FFmpeg, SQLite/DynamoDB
Impact & Vision:
AetherTest eliminates the "translation gap"—the manual effort required to convert business requirements into executable test scripts. By combining Amazon Nova's reasoning capabilities with vision-based validation, it enables QA teams to shift from manual scripting to intelligent requirement description, reducing test maintenance by ~70% while improving coverage and adaptability.

This is built for the Amazon Nova Hackathon and demonstrates how foundation models can transform enterprise testing workflows into autonomous, self-healing, vision-validated processes.

Repository: https://github.com/natarajan0007/AetherTest-Amazon-Nova
Demo: See the 90-second demo showing autonomous test orchestration, live browser execution, and vision-validated results.

Natarajan M