QAgent

AI agents that test your website like real users.

Comment

Inspiration

Modern QA is still surprisingly manual. Even with automated testing tools, developers often need to write and maintain brittle test scripts that break whenever the UI changes. I wanted to explore a more autonomous approach to testing using AI agents.

The idea behind QAgent was simple:

What if an AI agent could test a website the same way a human QA engineer would?

Instead of relying on predefined scripts, I wanted the agent to dynamically explore websites, interact with forms and buttons, test edge cases, detect bugs, and generate useful QA reports automatically.

I was also inspired by the recent growth of AI agents and developer tooling. I wanted to build something practical that developers could realistically use in their workflow.

What it does

QAgent is an autonomous AI QA agent for websites.

Given a website URL, QAgent:

  • launches a browser session using Playwright
  • analyzes the page structure and screenshots
  • decides what actions to take next using AI
  • explores flows like login, signup, and forms
  • detects bugs and UX issues
  • generates detailed QA reports automatically

The app uses CLŌD for advanced reasoning and multi-model orchestration

The application also includes:

  • live browser testing visualization
  • step-by-step action logs
  • replayable testing sessions
  • screenshot-based bug reports

How I built it

I built the frontend using:

  • React
  • Tauri
  • shadcn/ui

For the backend and infrastructure, I used:

  • Rust through Tauri
  • MongoDB
  • Playwright
  • TypeScript

The core of the system is an autonomous agent loop:

  1. Observe the website state
  2. Analyze the page structure
  3. Decide the next action
  4. Execute the action using Playwright
  5. Evaluate the result
  6. Repeat

To reduce token usage and improve performance, I built a DOM simplification pipeline that extracts only meaningful interactive elements before sending them to the AI models.

For AI orchestration:

  • Ollama handles fast local testing ( and free prompt engineering )
  • CLŌD routes tasks across different models depending on reasoning requirements

I also set up:

  • CI/CD pipelines
  • Husky pre-commit hooks
  • Prettier formatting
  • authentication and MongoDB integration

before building the core product so development would stay organized during the hackathon.

Challenges I ran into

One of the biggest challenges was managing context efficiently. Raw browser DOMs are extremely large, and sending entire pages to AI models quickly becomes expensive and slow.

To solve this, I built a DOM-cleaning pipeline that extracts only the most relevant elements such as:

  • buttons
  • forms
  • inputs
  • clickable UI components

Another challenge was making AI-generated browser actions reliable. Instead of allowing the model to generate arbitrary code, I created a strict action schema for interactions like:

  • click
  • type
  • navigate
  • wait

This made the Playwright execution loop much more stable and predictable.

I also had to balance:

  • execution speed
  • token costs
  • reasoning quality

especially when orchestrating multiple AI models through CLŌD.

Accomplishments that I'm proud of

I’m proud that QAgent feels like a real autonomous developer tool rather than just another AI wrapper.

Some accomplishments I’m especially proud of:

  • building a functional autonomous browser-testing loop
  • integrating AI-driven reasoning with Playwright
  • implementing model orchestration using CLŌD
  • creating a live testing and replay system
  • designing the architecture in a way that could realistically scale into a larger platform

I’m also proud that the project focuses on solving a real developer pain point instead of being purely experimental.

What I learned

This project taught me a lot about:

  • autonomous AI agents
  • browser automation
  • prompt engineering
  • structured AI outputs
  • AI orchestration
  • cost-efficient inference pipelines

I also learned that building reliable AI systems is much more about creating good feedback loops and constraints than simply calling an LLM API.

One of the biggest takeaways was understanding how important system design becomes when combining:

  • browser automation
  • real-time AI reasoning
  • UI interaction
  • multi-model workflows

What's next for QAgent

I plan to continue developing QAgent beyond the hackathon.

Some future features I want to add include:

  • repository-aware debugging using Greptile
  • automatic root-cause analysis
  • AI-generated regression tests
  • CI/CD integrations
  • parallel multi-agent testing
  • self-healing test flows
  • team collaboration features

Long-term, I want QAgent to evolve into a fully autonomous QA platform that helps engineering teams ship faster with less manual testing overhead.

Built With

Share this project:

Updates