Talos kery test Agent

Inspiration

Modern software teams are moving faster than their testing systems can comfortably handle. Product teams ship new screens, AI features, onboarding flows, admin dashboards, and internal tools at a pace that makes traditional manual QA feel permanently behind. At the same time, enterprise testing cannot simply become “let the AI click around and hope for the best.” Real organizations need evidence, repeatability, governance, traceability, and a clear human decision point before quality signals affect a release.

That tension inspired Talos Kery Test Agent.

We wanted to build something that sits between two worlds: the messy, unpredictable world of browser-based software and the governed enterprise world where tests need to be managed, reviewed, and connected to a real platform. UiPath Test Cloud was the natural center of gravity for that idea because it is not just a place to run tests; it is an enterprise testing layer where test cases, execution results, evidence, and release confidence can be coordinated.

The original question behind Talos was simple:

What if an AI testing agent could explore an application like a QA analyst, capture useful evidence like a test engineer, and report its work through UiPath Test Cloud like an enterprise testing system?

That question shaped the entire project.

We did not want to build another chatbot that says “this page looks good.” We wanted an agentic testing workflow that can open a real browser, authenticate into an application, navigate through user flows, observe what happens, produce structured testing evidence, and connect the result back to UiPath’s testing ecosystem.

Talos was built for the reality of enterprise QA: flaky screens, login flows, dynamic dashboards, missing data, visual regressions, unclear user journeys, and the need for a human reviewer to understand what happened without replaying the entire session from scratch.

What it does

Talos Kery Test Agent is an agentic QA orchestration layer for browser applications, designed around UiPath Test Cloud.

At a high level, Talos lets a user define a target application and a testing intent in plain language. For example, a user can ask it to log in, open key navigation areas, inspect a workflow, or validate a feature path. Talos then launches a real browser session, performs the requested actions, captures structured steps, records observations, identifies potential issues, and prepares the run as a governed testing artifact.

The important part is that Talos is not only “running an AI agent.” It is organizing the agent’s behavior as a test execution flow that can be connected to UiPath Test Cloud / Test Manager.

Talos focuses on five core capabilities:

1. Agentic browser execution

Talos runs against a real web application in a real browser environment. The agent can navigate pages, click controls, fill fields when allowed, observe DOM state, capture screenshots, and reason about what changed after each action. This makes it useful for modern web apps where behavior depends on authentication, routing, client state, and dynamic UI updates.

2. Natural-language test intent

Instead of requiring a test author to write every browser command manually, Talos accepts a human-readable test goal. A tester can describe the behavior they want to validate, and the agent translates that into browser actions. This is especially helpful for early-stage QA, exploratory testing, flow discovery, and regression test drafting.

3. Evidence-rich run detail

Every run is organized into a timeline. Talos captures the action taken, the target element, the page state, reasoning, and available evidence. This gives a human reviewer a clear trail of what the agent attempted and what it observed.

This matters because AI testing without evidence is not enterprise-ready. A pass/fail label alone is not enough. Teams need to know:

What page was tested?
What did the agent click?
What did the page show at that moment?
Did the agent actually reach the expected state?
Was the result blocked by the application, credentials, browser setup, or test logic?
Is there enough evidence for a human to trust the result?

Talos is built around those questions.

4. Human-in-the-loop review

Talos does not assume that every AI conclusion should automatically become a release decision. The UI is designed so a person can inspect runs, review steps, examine issues, and decide what should happen next. This aligns strongly with UiPath’s enterprise automation philosophy: agents can accelerate work, but people remain in control at critical decision points.

5. UiPath Test Cloud integration

Talos is designed to connect agentic testing activity with UiPath Test Cloud. The goal is for Talos runs to map into a UiPath-managed testing workflow where test cases, test sets, execution results, and evidence can be governed centrally.

For the hackathon, this makes Talos a Track 3 project: it reimagines software testing using agents while keeping UiPath as the orchestration and governance layer.

Why UiPath matters

UiPath is central to the project because Talos is not trying to replace enterprise test management. It is trying to make enterprise test management smarter.

A standalone AI browser agent can be impressive in a demo, but enterprises need more than impressive clicks. They need test assets, repeatable execution, auditability, ownership, and a platform where automation, agents, and humans can work together.

UiPath Test Cloud provides that enterprise anchor.

Talos uses UiPath as the control plane for the testing lifecycle. The agent performs intelligent exploratory work, but UiPath is where that work becomes part of a managed testing process. This distinction is important. Talos is not just “AI testing with a UiPath logo attached.” The project is designed around the idea that agentic QA becomes valuable when it can plug into a governed testing system.

UiPath helps answer questions like:

Which test case does this agentic run belong to?
Which test set should receive this execution result?
What evidence was produced?
Was this a failed test, a blocked test, or an exploratory discovery?
Who reviews the result?
Can this become part of a repeatable regression workflow?
How does this fit into a release process?

Talos brings the adaptive intelligence. UiPath brings the enterprise structure.

Together, they form a more realistic model for agentic testing in production environments.

How it works

Talos is built as a full-stack testing platform with a web interface, API layer, worker process, browser automation engine, database, queue, and UiPath integration path.

The architecture is intentionally modular because agentic testing has multiple responsibilities that should not be collapsed into one script.

The main pieces are:

Web application

The Talos web UI is where users create projects, configure environments, define test flows, run tests, inspect results, review issues, and manage settings. It provides visibility into what the agent is doing instead of hiding everything behind a terminal.

For a demo, this is the main control room. It shows the user that Talos is a real application, not just a background script.

API service

The API handles project data, saved tests, environments, run creation, settings, and run status. It acts as the bridge between the UI, database, worker queue, and live run updates.

Worker process

The worker is responsible for executing test runs. When a user starts a test, the run is queued, and the worker picks it up. This makes Talos more production-like because test execution is separated from the web request lifecycle.

That separation matters for enterprise testing because browser runs can take time, fail unexpectedly, require retries, and produce artifacts. A worker-based model is much closer to how real testing infrastructure behaves.

Browser automation engine

The agent uses browser automation to open the target app, inspect page state, interact with controls, and capture observations. The agent receives a high-level intent and decides the next step based on the current UI.

This is where agentic behavior happens. The browser agent is not simply replaying a fixed script. It can observe, decide, act, and adapt.

Database and Redis

Talos uses persistent storage for projects, environments, runs, steps, LLM calls, issues, and settings. Redis supports queueing and live run state. This lets the UI show live progress and keeps run history available after execution.

UiPath Test Cloud connection

Talos is designed to publish or align execution results with UiPath Test Cloud / Test Manager concepts such as projects, test sets, and test cases. The local configuration includes UiPath-related environment settings so that agentic runs can be connected to UiPath-managed testing assets.

This connection is the key enterprise layer. Talos does not treat agent output as disposable. It treats it as test evidence that belongs in a managed QA system.

The UiPath-centered workflow

A typical Talos workflow looks like this:

A QA engineer or product team member opens Talos.
They select a project and environment.
They describe a test goal in natural language.
Talos creates a run and sends it to the worker.
The worker launches a browser and executes the flow.
The agent logs in if credentials are configured.
The agent navigates through the application and records each step.
Talos captures observations, screenshots, step details, and potential issues.
The run is reviewed in the Talos UI.
The result is prepared for UiPath Test Cloud / Test Manager so it can be associated with a governed testing workflow.
A human reviewer can decide whether the result should become a regression test, be investigated as a bug, or be ignored as exploratory noise.

This workflow is intentionally human-centered. Talos helps the tester move faster, but UiPath provides the structure needed to make the result useful beyond a one-off demo.

What makes it unique

Talos is different from a normal browser test runner because it starts from intent, not code.

Traditional automated testing usually requires someone to decide every selector and every assertion before the test can run. That is powerful for stable regression suites, but it creates friction when teams want to quickly understand a new app, explore a changed workflow, or generate early test coverage.

Talos approaches testing more like a QA analyst:

It opens the app.
It observes what is on the page.
It decides what action makes sense.
It records what changed.
It keeps evidence.
It lets a human review the outcome.

But Talos is also different from a generic AI agent because it is connected to the testing lifecycle. It is not just an autonomous browser session. It is an agentic test run with structure, state, artifacts, and UiPath alignment.

The unique idea is this:

Talos turns AI exploration into enterprise test evidence.

That is the bridge we wanted to build.

How we built it

We built Talos as a TypeScript monorepo with separate applications and packages for the web UI, API, worker, database layer, and engine. This made the system easier to reason about because each part has a clear responsibility.

The frontend is a modern web application that provides the tester-facing experience. It includes run detail views, settings, model configuration, project management, and live progress surfaces.

The backend API exposes the operational layer for creating and reading projects, environments, tests, runs, issues, and settings.

The worker handles long-running test execution. This is where the agentic browser runs happen. The worker reads jobs from the queue, launches the browser, executes the agent, streams progress, persists steps, and prepares final run results.

The database stores durable information so runs can be reviewed later. We used structured run records instead of treating each execution as an ephemeral console log. That decision matters because testing evidence needs to survive after the browser closes.

Redis supports background job coordination and live run updates. This lets the UI show what is happening while the agent is still working.

For the UiPath side, the project includes configuration for connecting Talos execution to UiPath Test Cloud / Test Manager assets. The intent is to make Talos runs compatible with UiPath-managed testing workflows so that agent-generated test evidence can become part of a real enterprise QA process.

Challenges we ran into

The hardest part was not making an agent click a button. The hard part was making the entire flow feel reliable enough for an enterprise testing context.

Agentic browser testing has a lot of edge cases.

Sometimes a browser is not installed correctly. Sometimes the app loads, but the worker cannot launch the headless browser. Sometimes the agent makes progress, but the UI does not show it quickly enough. Sometimes a broad exploration prompt creates a long run that gets stuck after a few successful steps. Sometimes a page changes without a full navigation, which means the agent needs to reason from page state instead of URL changes.

Those challenges taught us that agentic testing needs strong operational design.

We improved the worker so that progress is flushed earlier. That way, if a run gets stuck, the tester can still see what happened before the issue. This is important for trust. A blank “running” screen is frustrating. A run that shows “logged in, opened Chat, opened Roles, then stalled” is much more useful.

We also learned that broad autonomous discovery is powerful but risky for demos. A full breadth-first exploration can get trapped in dynamic application behavior. A controlled flow is much better for demonstrating the core value: the agent can authenticate, navigate, observe, and capture evidence.

Another challenge was balancing flexibility with governance. AI agents are good at adapting, but enterprise test management needs consistency. UiPath Test Cloud is valuable here because it gives the agentic output a structured destination.

Accomplishments that we're proud of

We are proud that Talos became more than a prototype script.

It has a real application interface, a background worker, project configuration, run history, live progress, model settings, browser execution, and a UiPath-centered testing story.

We are especially proud of the direction of the architecture: Talos treats AI testing as a managed workflow, not a magic trick. The project is designed so a tester can inspect what happened and decide what should happen next.

We are also proud that the system can work against real deployed applications. Testing a real app is messier than testing a toy page. Authentication, navigation, dynamic dashboards, empty states, disabled controls, and unpredictable layouts all force the system to behave more like a real QA assistant.

Most importantly, we are proud of the UiPath alignment. Talos shows how coding agents and browser agents can be connected to UiPath Test Cloud instead of living outside the enterprise automation stack. That is the future we think matters: agents that are not isolated experiments, but governed participants in real workflows.

What we learned

We learned that agentic software testing is not just about intelligence. It is about coordination.

A smart agent is useful, but a smart agent connected to a testing platform is much more valuable. UiPath Test Cloud gives agentic testing a place to land. It gives teams a way to organize test cases, test sets, execution results, and evidence.

We also learned that humans need visibility. If an AI agent is testing a production-like workflow, the reviewer should not have to guess what happened. Every step should be inspectable. Every issue should include context. Every failure should explain whether the app failed, the browser failed, the model failed, or the test instruction was unclear.

We learned that shorter, focused agentic flows are often more useful than huge autonomous crawls. For enterprise QA, the best agent is not always the one that does the most. It is the one that produces trustworthy evidence for a meaningful workflow.

We also learned that UiPath’s value becomes clearer when the agent is treated as part of a larger automation ecosystem. Talos can use AI to reason through a web app, while UiPath provides the testing governance layer that enterprises need.

Why this matters for enterprise QA

Enterprise QA teams are under pressure from every side.

Applications are changing faster. Release cycles are shorter. AI features are harder to test deterministically. Manual QA teams are stretched thin. Automated regression suites are expensive to maintain. And business stakeholders still expect confidence before release.

Talos addresses that gap by giving teams an agentic testing assistant that can create useful evidence quickly.

But it does not remove the enterprise controls. Instead, it connects the agent’s work to UiPath Test Cloud so that the output can be reviewed, governed, and reused.

This is the model we believe will matter most:

Agents explore.
UiPath orchestrates.
Humans approve.
Test Cloud governs the evidence.
Teams ship with more confidence.

What's next for Talos Test Cloud Agent

The next step is to make the UiPath integration deeper and more automated.

We want Talos to create richer mappings between agentic runs and UiPath Test Manager assets. A future version should be able to automatically associate a Talos run with a UiPath test case, publish structured execution results, attach screenshots and logs as artifacts, and update test outcomes in a way that fits naturally into Test Cloud reporting.

We also want to improve flow generation. When Talos successfully completes an exploratory run, it should be able to recommend a stable regression test that can be reviewed by a human and then saved as a repeatable test asset.

Another important direction is risk-based testing. Instead of asking the agent to test everything, Talos could use recent code changes, known flaky areas, previous failures, and UiPath test history to decide which flows matter most for a release.

We also want to strengthen human-in-the-loop review. A reviewer should be able to approve an issue, dismiss it, convert a successful path into a regression test, or send a result into a UiPath-managed workflow.

Long term, Talos could become an agentic QA layer where UiPath Test Cloud is the command center and AI agents are specialized testing workers. One agent could explore new flows. Another could repair broken tests. Another could summarize failures. Another could generate release-risk recommendations. UiPath would coordinate the lifecycle and keep the work governed.

That is the vision behind Talos:

An enterprise-ready agentic testing system where AI does the exploratory work, UiPath governs the testing process, and humans stay in control of release quality.

Built With

anthropic-claude
bullmq
docker
fastify
google-gemini
node.js
openai
openrouter
playwright
postgresql
react
redis
typescript
uipath-automation-cloud
uipath-test-manager
use-this:-`uipath-test-cloud
vite