TR-Forge discovers every application and generates test cases from real workflows, APIs, and existing coverage—combining AI speed with QE expertise for relevant, traceable test coverage.
What is TR-Forge?
TR-Forge is an AI-powered test case generation engine that combines requirement context with the actual behavior and structure of your application. Instead of generating tests from ticket text alone, TR-Forge explores the application through a real browser, discovering pages, forms, authentication states, navigation paths, and user workflows to build application context for test generation.
TR-Forge integrates with JIRA, Linear, and ClickUp, or accepts manual input, and generates test cases based on discovered application workflows. It extends the same approach to APIs, generating test cases against real endpoints and modules while keeping UI and API coverage within the same system.
Each test case maintains a stable ID and version history. During regeneration, TR-Forge evaluates existing tests within the relevant module to expand coverage while minimizing duplication. Teams can configure Claude, Gemini, OpenAI, or Ollama as the LLM provider at the project level.
What TR-Forge Brings to Test Engineering
- Built to scale without missing pages – Crawls up to 100 pages per run, with login retried up to 5 times before failing
- Choose the crawl engine that fits the page– 3 interchangeable engines: raw Playwright, Playwright MCP (@playwright/mcp), and an AI-driven agent — plus 4 LLM providers (Claude, Gemini, OpenAI, Ollama) and 3 ticket connectors (Linear, JIRA, ClickUp)
- Coverage survives regeneration — nothing – Every run is snapshotted with full version
- Silently overwritten – history; every test case keeps a permanent TC-xxxxx ID across regenerations
Built-In Intelligence for Modern Test Engineering
Core Capabilities of TR-Forge
- Application-Aware Test Case Generation – Generated from Linear, JIRA, ClickUp tickets, or manual requirements — page-connection-aware through the crawled Site Map, with pages_covered cross-checked against real crawl data for every test case.
- Page Documentation– One Markdown file per crawled page, generated on demand.
- Graph-Based Memory – A Feature/Module/TestCase/Page relationship graph with a zoomable Project Graph view.
- Redesigned Web UI – A shared design-token system, reusable components, a consistent icon set, and a structured table-based results of view.
Why TR-Forge for Application-Aware AI Test Case Generation?
Generate from application context
TR-Forge crawls the application to discover pages, forms, authentication flows, and navigation, then uses the resulting Site Map to ground test generation.
Expose real application paths
Browser-based discovery identifies pages and navigation paths that may not be evident from requirement text alone.
Bring UI and API coverage together
Generate functional test cases from the crawled application and API test cases from real endpoints and modules, within the same system.
Regenerate without starting over
Each generation run is evaluated against existing tests within the relevant module, helping avoid unnecessary duplication across subsequent generations.
Maintain test-case continuity
Every test case carries a permanent TC-xxxxx ID and generation history, making changes across regenerations traceable.
Use the LLM that fits your project
Configure Claude, Gemini, OpenAI, or Ollama at the project level, with the flexibility to change providers through Settings.
Reduce repetitive QA work
Automate application discovery and test-case authoring allow QE teams to spend more time on exploratory testing, edge cases, and quality analysis.
Reuse discovered context across the team
Keep application discovery and generated test coverage within the project, reducing the need to repeat the same discovery and generation workflow.
Our Tools and Technology
Jira
Clickup
Liner
Gemini
OpenAI
Claude
MCP
Playwright
Discover How TR-Forge Discovers Real Workflows and Uses Them to Drive AI-Powered Test Case Generation.
FAQ’s
1. How does TR-Forge generate AI-powered test cases?
TR-Forge combines requirements from JIRA, Linear, ClickUp, or manual input with application context discovered through browser-based crawling. It discovers pages, forms, authentication flows, navigation paths, and user journeys, then uses the resulting Site Map to generate test cases grounded in the actual application rather than requirement text alone.
2. How is TR-Forge different from requirement-based AI test case generation?
Traditional AI test generation can rely primarily on the information contained in a requirement or ticket. TR-Forge adds real application context by exploring the application and building a Site Map before generating tests. This allows generated test cases to reflect discovered pages, navigation relationships, and workflows instead of only matching requirement wording.
3. Can TR-Forge generate both UI and API test cases?
Yes. TR-Forge generates functional test cases based on the discovered application and independently generates API test cases scoped to real endpoints and modules. Both are managed within the same system while keeping the UI and API generation contexts distinct.
4. How does TR-Forge prevent duplicate test cases during regeneration?
TR-Forge maintains per-module generation history, permanent TC-xxxxx test-case IDs, and version history across regenerations. Existing test cases within the relevant module are considered during subsequent generation runs, helping the system expand coverage without unnecessarily recreating previously generated scenarios.
Talk To Our Experts
Let Us Take The Wheel: Entrust Your Testing To Our QA Professionals
