Develop: AI web interface tester: the agent controls Chrome and writes bug reports.

Budget: 120 USD Deadline: 7 days

😀 Hello!
I have experience in developing AI agents and automation scripts in Python using Playwright and integrating OpenAI/Claude API.

🛠 How I will do it:
1. I will set up autonomous control of Chrome through Playwright (authorization, running scenarios, logging errors in the console, and failed network requests).
2. I will connect LLM (OpenAI/Claude API) to check results at each step and analyze visual/logical deviations.
3. I will implement auto-assembly of structured bug reports with screenshots, severity, and reproduction steps in a convenient format (Markdown/Notion/Google Docs).

🎥 Portfolio: Freelancehunt

Let's discuss the details in the chat, ready to start working! Expand

Budget: 125 USD Deadline: 5 days

Hello. I will create an AI agent in Python + Playwright / Selenium with context loading via LLM API (OpenAI / Claude) for DOM analysis and screenshots.

Passing scenarios with authorization, interception of 4xx/5xx responses, and console logs (page.on('console'), page.on('response')).

Automatic comparison of the DOM tree and visual layout with expected behavior.

Generation of a structural report: step-by-step reproduction, screenshot of the failed step, severity, and logs. Export to Notion / Markdown / Jira via API.

Running via cron, through the web (FastAPI), or via Webhook during deployment (CI/CD pipeline).

Please provide a text description of 1-2 typical scenarios — I will specify the architecture and timelines. Expand

Budget: 120 USD Deadline: 7 days

Ready to start immediately. On the first day, I will show the framework of the Playwright runner and a demo run in Chrome. In 7 days, I will create a working AI agent: normalization of text scripts, UI and data checks, collection of console/network errors, screenshots, trace, and structured bug report. I will set up the launch manually, on a schedule, or after deployment. Please let me know which reporting channel you choose and how many initial scripts there will be and in what format?

Budget: 120 USD Deadline: 7 days

Good day, I have over 5 years of experience in development, having worked extensively with AI automations and OpenAI API integrations.

I am implementing an agent for Chrome: executing scenarios, logging into a test account, checking elements, and creating bug reports with screenshots and severity (saving in the required format - Google Docs, Notion, Jira, or Markdown).

I will have a working version ready within a week. I will provide the exact cost after a few clarifications or in private messages.

What format is needed for the bug reports - Google Docs, Jira, or another?

I look forward to your message in private!

Budget: 650 USD Deadline: 7 days

Look, there's a nuance - a full-fledged AI tester with Chrome, login, console checks, network checks, screenshots, traces, and reports in Jira or Notion usually doesn't fit within 125 USD. But we can keep it simple - I would suggest starting with a short phase of 7 days to build a working prototype.

In the first phase, we will create an agent that launches Chrome, goes through 2-3 scenarios, collects console and network errors, takes screenshots, saves reproduction steps, and generates a bug report in Markdown or Jira. After this, it will be clear where AI is needed and where traditional deterministic checks via Playwright are more reliable.

Questions for a more accurate assessment:
> How many scenarios are planned at the start?
> Where is it more convenient to write the report - Jira, Notion, Google Docs, or Markdown in the repository?
> Is there already a test stand, and can a separate account be provided without production data?

Similar cases from Ingello:
> https://business.ingello.com/vorfahr - AI and automation of complex workflows
> https://business.ingello.com/fractal - agent architecture and managed scenarios
> https://systems-fl.ingello.com - main profile of Ingello Systems for projects with architecture, automation, and corporate development

If the goal is not a toy script, but a tool that the team can run every day on stage, it's better to start with a prototype and then expand the scenarios. Measure seven times - automate once =) Expand

Budget: 125 USD Deadline: 7 days

Hello, I created a similar agent for automatic script execution in the browser: controlling Chrome via Playwright, logging into a test account, checking for element appearances, console errors, and failed network requests. Generating bug reports with screenshots, severity, and reproduction steps was also part of that project.

If the scripts are written in natural language, it’s worth immediately adding an LLM parser that converts them into clear steps, which eliminates manual rewriting of specifications and saves about 30% of the time on maintenance.

How many scripts are there at the start and where do we store the reports: Jira, Notion, or Markdown in the repository? And how do you plan to run it, manually with a button or on every stage deployment?

I suggest we get in touch; I’ll also draft a solution scheme for your scripts and the bug report format with a video run.

Budget: 125 USD Deadline: 4 days

Hello,

I can build an AI-powered browser testing agent that automatically executes user scenarios, detects issues, and generates detailed bug reports.

I have experience with Python, AI agents, Playwright, browser automation, API integrations, and CI/CD workflows. I can develop the system to launch Chrome, run provided test scenarios, validate UI elements, data, console errors, network requests, and generate reports with screenshots, reproduction steps, severity, and execution traces.

I can also review existing GitHub solutions and integrate suitable components to speed up development. The agent can support manual runs, scheduled execution, or deployment-based triggers.

I am ready to discuss the architecture and start.

Best, Youssef. Expand

Budget: 120 USD Deadline: 3 days

Hello! Ready to start today.

I’m responding to your question about GitHub: writing an agent from scratch in 2026 is a waste of your budget.

For such a task, it’s best to base it on modern open-source frameworks like browser-use or Stagehand in conjunction with Playwright. They already know how to control Chrome via LLM, understand scenarios in plain human language (without hardcoded selectors), and won’t break if the website's design changes slightly.
Here’s how I will implement your 4 points in 4 days (within $125):
Launch and integration: I will create a CLI command for manual launch + a ready GitHub Action / Webhook that will automatically run the tests after deploying the stage or on a cron schedule.

Scenario execution: The agent will authenticate (we’ll set up bypassing CAPTCHA/2FA for the test environment if needed) and read the scenarios as text. The LLM will interpret where to click and what to fill in.

Quality control (most important):
Playwright intercepts console errors (page.on('console')) and 4xx/5xx network requests.

Claude 3.5 Sonnet / GPT-4o (Vision) checks the screenshot at each step: whether the element appeared and whether the layout shifted (classic selectors do not see this, but the Vision model notices it instantly).

Playwright intercepts console errors (page.on('console')) and 4xx/5xx network requests.

Claude 3.5 Sonnet / GPT-4o (Vision) checks the screenshot at each step: whether the element appeared and whether the layout shifted (classic selectors do not see this, but the Vision model notices it instantly).

Bug reports: After the run, a structured report is generated (to start, it’s easiest to create Markdown directly in the repository or integrate with the Notion API): reproduction steps, Expected / Actual, Severity, error screenshot, and link to Playwright Trace (can be replayed by seconds). Expand

Budget: 125 USD Deadline: 5 days

Katerina, I suggest starting not with a universal system for an indefinite number of scenarios, but with a verifiable MVP that can then be safely expanded.

In the first stage, I will create a runner on Playwright for Chrome: authorization with a test account, execution of three agreed scenarios, checks of elements and data, collection of console errors and unsuccessful network requests. In case of a defect, a screenshot and trace will be saved, and a structured Markdown report will be generated in the repository. Human-readable scenarios will be transformed into understandable steps, but critical checks will remain deterministic so that the result does not depend on random agent decisions.

Stage readiness: launching with a single command or from CI, three working scenarios with pass/fail results, a bug report with steps, expected/actual, severity, and evidence, a README for setting up the test account and adding new scenarios. Integration with Jira/Notion and the expansion of the number of scenarios will be evaluated separately after the MVP demonstration.

The cost of the first stage is 125 USD via Safe, and the timeframe is 5 days after receiving the test environment and scenarios.

What three scenarios are we taking in the MVP, and is there CAPTCHA, 2FA, or SSO in the test authorization?

Budget: 125 USD Deadline: 12 days

Good day!
I see the task: an AI agent that autonomously runs scenarios in Chrome, catches discrepancies (failed requests, console errors, broken layouts), and generates bug reports with screenshots, severity, and run traces.

This is exactly my profile - Python + browser automation + LLM integration. Regarding ready-made repositories: there isn't anything fully "out of the box," but a solid foundation can be built using Playwright (controlling Chrome, traces, video, intercepting network requests and console) + an LLM layer that parses human-readable scenarios and decides what to click and what to check. This is faster and more reliable than building from scratch.

I would like to clarify 2 points:
1) Where do we submit bug reports in the first version - should we start with one channel (Markdown in the repo or Notion), and add the rest later, or do we need Jira with API right away?
2) How many scenarios at the start (N) and is there anything non-standard for login on the test stand - 2FA, captcha, SSO?

Here’s what I will do:
1) Core on Playwright: launching Chrome, logging in, running scenarios from a text list, collecting console/network/screenshots/video and trace.
2) LLM layer: interpreting scenarios in human language + analyzing discrepancies (expected vs actual, determining severity).
3) Report generator in the chosen channel + launch configuration (button / cron once a day / hook on stage deployment).

I have a relevant project in my portfolio: SaaS AI analytics - FastAPI + PostgreSQL with data processing through AI, plus separate experience with automation and bots.

I suggest breaking it down into stages: first MVP (1 report channel + basic scenarios), then expansion. The estimate for MVP: from 18,000 UAH / 12–18 days — more precise after answers to the questions.

—
Denis Ivanchенко · Python Developer, AI Integrations Expand

Budget: 120 USD Deadline: 7 days

Hello, Kateryna! I have reviewed your technical task regarding the development of an AI agent for testing web interfaces. I am ready to implement this system in Python with quality, stability, and turnkey solutions. I am a developer specializing in asynchronous browser automation, parsing, and integrating AI models (stack: Python, asyncio, Playwright / Selenium, OpenAI / Gemini API). I will implement your AI tester according to the following clear technical plan:

Launch and Infrastructure: I will create a flexible script that can be run manually with a single command, as well as integrated on a schedule (cron on Linux VPS) or triggered after deploying the stage.

Browser Management (Playwright): I will use Playwright for stable management of Chrome in asynchronous mode. The script will securely log into test accounts, handle dynamic content, and navigate through pages.

AI Agent Logic (Vision API): To recognize scenarios "in human language," I will connect a multimodal API. At each step, the script will take a screenshot, send it to the model along with the current task from the list, and receive clear instructions for the next action or to document deviations.

Bug Report Generation: If the AI detects a bug (missing element, 500 error, layout shift), the script will automatically collect the error log, attach a screenshot, and generate a structured report in Markdown/Notion format or send a notification via Google Docs API.

In the end, the price will be lower than stated, as I am currently working for feedback and rating. Expand

Budget: 125 USD Deadline: 3 days

There are many agents, for example, jimmytoan/qa-agent.

You can take one and refine it according to your specifications.

Budget: 125 USD Deadline: 7 days

Good day, Kateryna!

Developing an AI agent for testing web interfaces is a complex task that requires a deep understanding of both technologies and user scenarios. I have experience in creating automated solutions that effectively perform such tasks.

I understand that you need an agent that can run scenarios, verify their correctness, and generate bug reports. This will significantly reduce testing time and improve product quality.

To start, we need to clarify the details:
1. What functionality do you want to implement in the agent?
2. What scenarios do you plan to test and in what format will they be provided?
3. What are your preferences for reporting tools (Google Docs, Notion, Jira)?

After receiving this information, I will be able to propose a specific action plan and timeline estimate.

The preliminary cost of development may range from $1000 depending on the complexity of the project and the time required for implementation.

My profile contains examples of work that can demonstrate my experience in developing automated solutions: Oleg Kostylev - Freelancehunt.

Let's discuss the details of your project in private messages so that I can better understand your requirements and offer an effective solution. Expand

Budget: 125 USD Deadline: 3 days

Regarding the ready-made repos: the idea is to use the combination of Playwright with an LLM agent as a basis, rather than writing a runner from scratch.

I will create the agent: login, step-by-step execution of scenarios with checks for elements, console errors, failed requests, and layout. As a result, a report with reproduction steps, expected and actual behavior, a screenshot, and severity.

Please clarify where the report is needed: Markdown in the repo, Jira, or Notion, and how many scenarios at the start. The timeframe is about 3 days.