Transcription
[music] Most software doesn't fail because the idea was bad. It fails because small issues slip through unnoticed broken flows. Edge cases nobody tested. Regressions that show up after release. And in practice, QA or quality assurance is often the first thing teams rush or skip, especially when time or budget is tight.
That is why I wanted to look at Deep Agent from a QA engineer's perspective, not as a demo tool and not as a replacement for people, but as a system that claims it can take a live application, understand how it actually works and test it the way a human would. In this video, I'm giving Deep Agent a real app pulled from GitHub and deployed live. I'm not telling it what to test or where to look. I'm simply giving it the link and asking it to do a full end-to-end QA pass from exploration to test design to execution and reporting. The question isn't whether it can generate test cases. The question is whether the output is something a real team could trust and act on. Enough talk. Let's see Deep Agent in action. Let's dive deep.
[music] I'll be testing Deep Agent's capabilities as a QA engineer on this app I pulled from GitHub. I will be providing Deep Agent the app's live link. First, I'll log in to Appacus AAI. I'll switch from chat mode to Deep Agent. I am now typing my prompt. This prompt is asking Deep Agent to perform a full end-to-end QA test on the app and generate a professional report with evidence. I'll click send. And before Deep Agent begins testing, it is asking a couple of questions. I'm answering the questions. I'm going to click send.
Deep Agent proceeds to work on the task. Deep Agent is familiarizing itself with the app through real usage. So the tasks it designs are grounded in actual user flows rather than assumptions. At this stage, it is behaving like a human QA engineer on their first pass, confirming that login works, identifying the main navigation areas, and clicking through the interface to see what functionality is available to understand the app's scope before creating a test plan.
Deep Agent has finished its first walkthrough and is now turning what it observed into a structured test plan. It identified the main functional areas of the app and translated them into concrete test cases covering authentication, data management, calculations, navigation, validation, and error handling. In other words, it is moving from exploration to formal QA coverage just like a human QA engineer would. Deep Agent created 11 test cases and is now asking for review and approval to proceed with execution. The test cases look solid, so I'll ask it to proceed.
At this point, Deep Agent has finished executing the full test plan. It ran all 11 test cases and end-to-end documented failures with screenshots and generated a structured QA report. The final output includes a PDF and HTML report, a clear pass/fail breakdown, and a prioritized list of bugs with severity levels. This is the same kind of deliverable you'd expect from a human QA engineer after a full test cycle. Let's take a look at the PDF report generated. This isn't just a summary. It includes the full test plan, execution results, screenshots as evidence, and a prioritized list of bugs with severity levels.
Deep Agent executed 11 test cases, as I already mentioned, across the application covering authentication, employee management, pay periods, time sheets, payroll calculations, reports, navigation, form validation, and error handling. Out of those tests, nine passed and two failed. I already mentioned that as well, with three bugs identified in total. That tells us the core system is largely stable, but there are still important issues that need attention. What matters here isn't just the bugs themselves, but the process. Deep Agent explored the application like a real QA engineer, designed a structured test plan based on actual usage, executed the tests end-to-end, captured evidence, and produced a professional QA report grounded in real user flows.
At this point, the QA cycle is complete. I have a full PDF and HTML report, clear pass and fail results, documented bugs with severity levels, and concrete recommendations for what to fix next. That's the entire QA workflow from exploration to execution to reporting handled automatically. Now I want Deep Agent to automate this QA test. I'm typing in the prompt. I will click send. Deep Agent is creating a scheduled task for itself to handle future runs automatically. The schedule is now created. To confirm this scheduled task, I'll click on tasks. Here I can find the scheduled task to perform quality assurance on my app.
After watching Deep Agent go through the entire QA cycle, it's clear this isn't just a tool that generates test cases. It behaves much more like a real QA engineer. It explores the application through actual usage, builds a structured test plan based on what it observes, executes those tests against a live system, captures evidence, and delivers a report that's clear, traceable, and actionable. What stood out to me isn't just that it found bugs, but how it found them. Every issue is tied to a specific test case, backed by screenshots, and presented with severity and impact. That's the kind of output teams rely on to make decisions, not just a list of suggestions. By automating this process and scheduling it to run continuously, Deep Agent moves QA from a one-time task into an ongoing system. Instead of testing being something you remember to do, it becomes something that runs in the background and surfaces issues as the product changes.
Deep Agent is part of Abacus AI and it's available through the chat LLM subscription, which is currently priced at around $10 per month. If you're already experimenting with AI agents or looking for ways to reduce manual QA work without hiring a full team, that makes it relatively easy to try this out for yourself. I left the link in the description if you want to explore it further. I hope you enjoyed this video. If so, leave your thoughts in the comment section. I'm done for now and I'll talk to you soon. Ivan KV out.
[music]