Pathfinder

About

---                                                                                                                                                                                                                                                
  Pathfinder — AI QA Engineer in Your Browser
                                                                                                                                                                                                                                                     
  Pathfinder is an autonomous QA agent that lives in your browser. Point it at your web app, and it explores every page, learns your user flows, generates test cases, and executes them — all without writing a single line of test code.
                                                                                                                                                                                                                                                     
  ---
  WHY PATHFINDER?                                                                                                                                                                                                                                    
                              
  Modern web apps ship fast. Manual QA can't keep up. Playwright scripts break every sprint. Pathfinder fills the gap: it understands your app the way a QA engineer does, then works 24/7 so you don't have to.
                                                                                                                                                                                                                                                     
  ---
  HOW IT WORKS                                                                                                                                                                                                                                       
                              
  1. Crawl — Pathfinder crawls your help documentation and builds a knowledge base. It understands what your product is supposed to do before it ever opens your app.
  2. Explore — An autonomous agent navigates your web app using real browser interactions. It finds every form, button, wizard, and navigation path — including content hidden behind hover states, accordions, and dynamic menus. It detects        
  sub-apps (admin vs learner vs manager portals) and explores each independently.                                                                                                                                                                    
  3. Learn — The exploration graph is fed to an LLM. Pathfinder generates a rich library of user flows — at least 2 distinct flows per page, covering primary actions, edge cases, and multi-step wizards.                                           
  4. Generate — For each flow, Pathfinder produces a complete, grounded test case with step-by-step instructions, real selectors from your live DOM, and expected outcomes. No hallucinated fields. No invented UI elements.                         
  5. Execute — Tests run directly in your browser via Chrome DevTools Protocol. Pathfinder watches the DOM, fills forms, clicks buttons, waits for state changes, and reports pass/fail with screenshots.                                            
                                                                                                                                                                                                                                                     
  ---                                                                                                                                                                                                                                                
  KEY FEATURES                                                                                                                                                                                                                                       
                                      
  Autonomous Exploration              
  - BFS graph traversal across your entire app
  - Detects and explores sub-applications (admin, learner, manager portals) separately                                                                                                                                                               
  - Walks shadow DOM, same-origin iframes, and dynamically rendered content           
  - Reveals hidden content: hover menus, accordions, popovers, aria-expanded panels                                                                                                                                                                  
  - Detects auth-walls mid-exploration and stops gracefully                                                                                                                                                                                          
  - Single-page mode: explore just the current URL and its inline components                                                                                                                                                                         
                                                                                                                                                                                                                                                     
  Intelligent Flow Learning                                                                                                                                                                                                                          
  - Partitions the exploration graph by sub-app for focused, relevant flows                                                                                                                                                                          
  - Guarantees ≥2 flows per page — no page ever skipped                                                                                                                                                                                              
  - Intra-partition deduplication removes overlapping flows while preserving coverage                                                                                                                                                                
  - Wizard/stepper-aware: serializes multi-step form sequences into coherent flows                                                                                                                                                                   
  - Coverage safety net synthesizes filler flows for any page the LLM missed                                                                                                                                                                         
                                                                                                                                                                                                                                                     
  Grounded Test Generation                                                                                                                                                                                                                           
  - Multi-signal relevance scoring matches each flow to the right page's form fields (URL path overlap, selector matching, token scoring)                                                                                                            
  - Budget-aware context packing: fits the most relevant page data within token limits                                                                                                                                                               
  - Grounding rules prevent LLM from inventing selectors, field names, or navigation steps not present in the exploration data                                                                                                                       
  - Pulls help documentation context to enrich test expectations                                                                                                                                                                                     
                                                                                                                                                                                                                                                     
  Test Execution Engine                                                                                                                                                                                                                              
  - Runs tests in the active browser tab — no external tools needed                                                                                                                                                                                  
  - Fills forms, clicks buttons, navigates, waits for DOM changes                                                                                                                                                                                    
  - Captures screenshots at each step                            
  - Detailed pass/fail report with step-by-step breakdown                                                                                                                                                                                            
                                                                                                                                                                                                                                                     
  Analysis Tools                      
  - API Coverage: Tracks which backend endpoints are exercised by your test suite                                                                                                                                                                    
  - Accessibility: Scans pages for WCAG violations                                                                                                                                                                                                   
  - API Contracts: Validates request/response shapes against expected schemas                                                                                                                                                                        
                                                                                                                                                                                                                                                     
  Multi-Provider AI                                                                                                                                                                                                                                  
  - OpenAI: GPT-5 series (with reasoning model support — temperature handled automatically)
  - Anthropic: Claude Sonnet 4.6 / Opus 4.7                                                                                                                                                                                                          
  - Google: Gemini 3 Pro / Flash           
  - Bring your own API key — your data never touches Pathfinder servers                                                                                                                                                                              
                                                                       
  MCP Server (Power Users)                                                                                                                                                                                                                           
  - Includes a standalone Model Context Protocol server                                                                                                                                                                                              
  - Exposes 20+ tools so any MCP-compatible AI agent (Claude Desktop, Cursor, etc.) can drive Pathfinder programmatically                                                                                                                            
  - Tools cover: crawling, exploration, flow management, test generation, execution, and reporting                                                                                                                                                   
  - MySQL-backed persistence for long-running agent sessions                                                                                                                                                                                         
                                                                                                                                                                                                                                                     
  ---                                                                                                                                                                                                                                                
  WHO IS IT FOR?                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                     
  - QA Engineers who want to stop writing boilerplate test scripts
  - Developers who want to catch regressions before they ship                                                                                                                                                                                        
  - Product teams who need test coverage but don't have dedicated QA headcount                                                                                                                                                                       
  - AI engineers building agent-driven quality pipelines                                                                                                                                                                                             
                                                                                                                                                                                                                                                     
  ---                                                                                                                                                                                                                                                
  PRIVACY & DATA                                                                                                                                                                                                                                     
                                      
  Pathfinder runs entirely in your browser. No app data is sent to Pathfinder servers. AI requests go directly from your browse