TAMASH Autonomous Quality Engineering Platform
The Repository-Native QA Layer Across the Entire SDLC & STLC
5 Unified Products: tamash-agent • tamash-qe • tamash-playwright • tamash-playwright-dashboard • tamash-admin-portal
What We'll Cover
1. The Testing Dilemma & TAMASH Vision
Why traditional QA silos fail, and how TAMASH becomes the repository QA layer.
2. The 5 Products at a Glance
Clear, focused roles: agent, qe, playwright, dashboard, and admin portal.
3. End-to-End SDLC & STLC Workflow
The 6 continuous stages: from user stories to autonomous production maintenance.
4. Architectural Deep-Dives
Engine tools, Git branching parity, 4-tier self-healing, and Ed25519 licensing.
5. Live Screenshots & Empirical Proof
Real heal logs, test health analytics, and zero-server cross-run dashboards.
6. Business Value, ROI & Next Steps
Eliminating $150,000+ in annual maintenance and launching a 15-minute pilot.
Where Traditional Test Automation Runs Into Trouble
Engineering teams have automation, but keeping it green consumes up to 40% of sprint capacity.
Brittle Locators & Waits
Cosmetic UI shifts break hardcoded selectors and manual waits, blocking CI/CD pipelines daily.
Disconnected QA Silos
Tools like TestRail and Zephyr live in external databases completely disconnected from Git feature branches.
Costly Reporting Servers
Solutions like ReportPortal require dedicated databases, Kubernetes clusters, and $30k+ annual DevOps upkeep.
Traditional automation was built for human-scripted tests and manual maintenance. It is not built for AI coding agents — TAMASH is.
TAMASH is the QA Layer of the Repository
"The repository is the only source of truth. Everything TAMASH produces is plain files and code in Git."
End-to-End Project Repositories
Application source code and the QA layer live in the same Git repo. QA starts at the development stage, and tests branch and merge with the application code.
- Tests reviewed in the exact same Pull Request as feature code
- Zero drift between application behavior and test definitions
QA-Only Project Repositories
Dedicated repository holding only the QA layer. The application is tested as deployed across staging, UAT, and production environments.
- Modular structure with features, steps, and test data in Git
- Status web UI renders living documentation for non-IDE stakeholders
The 5 TAMASH Products & Their Roles
| Product | Repository | Role in the QA Layer |
|---|---|---|
| tamash-agent | tamash-jev |
Engine and tools that coding agents use: drive and verify the application, generate automation code, check scenarios against the step catalog, and run developer PR checks. |
| tamash-qe | tamash-qe |
Repository index and web UI: requirements, scenarios, review status, manual runs, automation state, tracker sync, and living repository status for everyone. |
| tamash-playwright | tamash-playwright |
Runtime library in every test run: self-healing locators, apply-heals PR generator, and failure analysis for Playwright Test and Cucumber. |
| tamash-playwright-dashboard | tamash-playwright-dashboard |
Run reporters (Playwright Test and Cucumber) that record results, heals, and failure analysis per test case; report views move into the web UI. |
| tamash-admin-portal | tamash-admin-portal |
Licensing and organizations: cryptographic license keys (Ed25519), usage tracking, SSO, roles, and audit logging for hosted mode. |
Five focused, modular products designed to operate as a unified system across the software lifecycle.
Stage 1: Requirements & User Stories
STLC: Requirement Analysis • Products: tamash-qe & tamash-agent
tamash lint ensures steps match catalog standards across all teams.features/.Stage 2: Development & Autonomous Exploration
SDLC: Coding • STLC: Test Design • Products: tamash-agent & Project Templates
Autonomous Exploration
Developer or agent crawls the live feature branch; tamash-agent observes DOM changes, form inputs, and navigation transitions.
Exploration → Automation
Captured user actions automatically synthesize clean page step files and page objects that pass on their very first run.
Developer Loop Checks
tamash check verifies change impact on local builds, surfacing testability findings before pushing code.
Zero Data Corruption: Autonomous exploration operates under strict read-only safety rules — never clicking Save, Delete, or Logout.
Stage 3: Manual & Assisted Testing
STLC: Test Execution • Products: tamash-qe & tamash-agent
Manual Execution in the Web UI
Testers execute manual checklist runs directly inside the tamash-qe web UI:
- Record pass/fail statuses, notes, and screenshot evidence per step
- Writes compact run records directly into the Git repository
- Ensures manual test evidence is auditable and version-controlled
Assisted Agent Execution
tamash-agent drives repetitive preconditions, allowing humans to focus on exploratory testing:
- Signs in automatically using saved login states without passwords
- Navigates complex multi-step forms to target screens
- Transitions tags smoothly from
@manualto@automated
Stage 4: Pull Request & CI/CD Gate
SDLC: Build & Integration • Products: tamash-agent, tamash-playwright & tamash-playwright-dashboard
Change Impact Diff
tamash-agent analyzes git diffs to run exactly the affected scenarios rather than waiting for full suite execution.
Runtime Self-Healing
tamash-playwright intercepts broken locators on the fly, keeping the PR pipeline green while logging the heal.
Instant Run Summary
tamash-playwright-dashboard attaches a lightweight summary to CI artifacts, detailing clean vs healed passes.
Stage 5: Continuous Regression & Self-Healing
STLC: Regression & Maintenance • Products: tamash-playwright & tamash-playwright-dashboard
apply-heals: Permanent Code Fixes
Runtime self-healing repairs tests during CI, but doesn't leave them unpatched:
- Heals recorded in
tamash-heal.jsonwith test case IDs apply-healsAST engine patches locator factories in page step files- Automatically opens clean Git Pull Requests updating source code
- Reviewers merge verified semantic locators — zero XPath permitted
Failure & Stability Intelligence
tamash-playwright-dashboard tracks suite health across runs:
- 8 deterministic failure categories (assertion, timeout, locator, crash, etc.)
- Automated Flaky Test Watchlist with Instability Index (%)
- Token audit tracking exact AI usage and cost per test run
Stage 6: Release Readiness, Traceability & Governance
SDLC: Release • STLC: Sign-Off • Products: tamash-qe, tamash-playwright-dashboard & tamash-admin-portal
traceability.json
Living graph connecting Requirement ↔ Scenario ↔ Steps ↔ Code ↔ Runs ↔ Heals ↔ Bugs. Full audit compliance.
Repository Status Web UI
tamash-qe renders coverage matrices, scenario review states, and release readiness dashboards for business stakeholders.
Ed25519 Fleet Governance
tamash-admin-portal enforces organizational seat tiers, scoped CI concurrency tokens, and 100% offline air-gapped license validation.
tamash-agent: Core Capabilities
Plain-English Scenarios
Executes Markdown and YAML test cases directly in real browsers without requiring technical selector code.
In-Process Playwright Driver
Drives browsers via playwright-cli, capturing accessibility snapshots with sub-50ms latency and 0 false passes.
Step Catalog & tamash lint
Maintains reusable step definitions and catches reworded duplicate steps with instant suggestions.
Saved Login States
Saves authenticated session states per environment; regression runs start signed in with zero passwords in storage.
Developer Loop & PR Checks
tamash check runs impact analysis on local changes; flags testability findings before PR submission.
tamash-mcp Protocol Server
Enables AI coding assistants like Claude Code and Cursor to drive live browsers and write verified tests.
tamash-qe: The Git-Native Quality Platform
Standard QA Layer Layout
Initialized via tamash-qe init:
.tamash/— Framework config, schemas, and agent rulesfeatures/— Feature files with@TC-...and@story-...tagssteps/pages/— Page step files and modular locator factoriesdata/— Environment test data fixtures and credentialstraceability.json— Automated living requirement-to-code map
Git Branching Parity
Tests evolve directly alongside application features:
- No Out-of-Sync Databases: Branching feature code branches test cases
- Pull Request Reviews: Scenario changes reviewed with code
- Tracker Sync: Bi-directional sync with Jira, Azure DevOps, and GitHub
- $0 Recurring Cost: Replaces $15k-$40k/yr TestRail/Zephyr subscriptions
tamash-playwright: 4-Tier Healing & Non-Invasive Assertions
Accessibility
Matches ARIA tree, roles, and accessible names. Free, 0-token instant resolution.
Multimodal
Analyzes visual layout geometry and bounding box proximity relative to containers.
Fuzzy Lexical
Levenshtein distance matching button text variations, casing, and placeholder shifts.
System One AI
Narrow semantic judgement when confidence ≥ 0.80. Falls back safely if uncertain.
The Non-Invasive Assertion Guarantee:
Heals actions (clicks, fills) but NEVER touches assertions (expect). Zero false passes allowed.
From Runtime Healing to Permanent Git PRs
Clean Code Standards
- Patches locator factories in
steps/pages/*.page.steps.ts - Generates semantic Playwright locators (
getByRole,getByLabel) - Strictly No XPath: Preserves code quality and formatting
- Developers review and merge the PR normally
Test Case ID Traceability
- Every heal record carries its scenario
@TC-...identifier - Directly populates
tamash-playwright-dashboardheal history - Updates
traceability.jsonin thetamash-qerepository index
See It In Action: Self-Healing Log Detail
Inspect every heal: original selector, healed selector, confidence score, and model rationale.
Zero-Server Architecture & 8 Failure Classes
$0 Hosting • Zero Server • Zero DB
Single self-contained HTML bundle generated during test runs:
- Publishes for free to GitHub Pages, AWS S3, or CI artifacts
- Compact run summaries written to repository or results branch
- Report views integrate natively into the
tamash-qeweb UI
8 Deterministic Failure Classes
Classifies failures instantly in <2ms with zero token cost:
- 1. Assertion: Genuine application bug
- 2. Timeout • 3. Locator Not Found • 4. Interactivity
- 5. Network/API • 6. Navigation • 7. Crash • 8. Auth
1-Click JIRA Defect Export: Auto-formats bug tickets with stack traces, screenshots, reproduction steps, and test case IDs.
See It In Action: Cross-Run Dashboard Overview
Historical cross-run intelligence: pass rates, recent execution trends, and healed vs clean breakdown.
See It In Action: Test Health Analytics & Flaky Watchlist
Automated Flaky Watchlist: tracks flip-flop instability index, newly failed tests, and failure distributions.
See It In Action: Self-Healing Analytics & Cost Audit
Complete financial visibility: tracks heal events, resolution accuracy, and token spend per test run.
tamash-admin-portal: Cryptographic Security & Control
Ed25519 Offline Licensing
Asymmetric signed tokens (TAMASH1.<payload>.<sig>) validated locally in runners with zero network pings required.
Multi-Tenant RBAC & SSO
Granular roles (Super Admin, Owner, Developer, CI Runner) and SSO shared with the hosted web UI.
Zero External Dependencies
Built entirely on Node.js core libraries (http, crypto, fs). Sub-15ms cold start, immune to npm supply chain attacks.
Business Value & Quantified ROI for Leaders
Engineers build new coverage rather than fixing broken selectors.
Direct capacity reclaimed across a standard 10-engineer QA organization.
Eliminates external TestRail, ReportPortal, and vendor recorder fees.
100% Code & Data Sovereignty: All tests, reports, and traceability live in your Git repository.
Rapid 15-Minute Pilot & Adoption Roadmap
Zero Risk: 100% native Playwright compatibility. No vendor lock-in, no test rewrites.
Get Started with TAMASH Today
Transform Your Repository into an Autonomous Quality Engine