OwlGate

Inspiration

A green CI run answers "did the tests pass?" — but the question every release manager actually has is "should we ship this?" Those aren't the same. Tests go red for reasons that don't matter (a renamed CSS class breaks a selector; a toast animates in 50ms too slowly) and stay green while a real behaviour change slips through an uncovered path. Teams cope by throwing humans at every release: someone eyeballs the diff, re-runs flaky suites, and makes a gut call. It's slow, inconsistent, and doesn't scale.

The data backs this up. Faros AI's 2025 study of 10,000+ developers found that high-AI-adoption teams merge 98% more PRs, but review time rises 91% and PR size grows 154% — and GitClear's analysis of 211M lines from Google, Microsoft and Meta repos found AI-era code clones up 4× and refactoring down from 25% to under 10%. As Google's Addy Osmani put it in 2026, "the bottleneck moved from writing code to proving it works."

OwlGate turns that gut call into a reasoned, auditable, agentic decision — and keeps a human in charge where it counts.

Sources: Faros AI — The AI Productivity Paradox (2025) & Acceleration Whiplash (2026); GitClear — AI Copilot Code Quality (2025); Kamalı et al. — Rethinking Code Review in the Age of AI (arXiv, 2026); A. Osmani — Code Review in the Age of AI (2026).

What it does

OwlGate is an agentic release-gate built on UiPath. On every change it runs a five-stage pipeline:

1. Risk agent reads the diff, maps changed files to impacted test suites via a catalogue, and scores release risk (0–1) from a transparent weighted blend of tag severity, churn, coverage gap, and breadth.
2. Test Cloud runs only the impacted suites against the system under test — real UI tests (Playwright) and API tests — and records pass/fail in UiPath Test Manager.
3. Self-Healing agent classifies each failure: a broken selector or flaky timing is diagnosed and a fix is proposed (authored by a coding agent); a genuine functional regression is never auto-healed.
4. Gate agent synthesizes risk + results + heals into a go / no-go verdict with a written rationale and a list of blocking issues.
5. Human gate — when the verdict needs sign-off, OwlGate records a durable approval request (Orchestrator queue item + Action Center task). A person approves or overrides before anything ships.

The verdict and its full reasoning publish to a dashboard.

How we built it

• Coded agents (Python + LangGraph), deployed to UiPath as a coded function (owlgate-gate). The agents are deterministic and auditable — risk scoring is a transparent formula, not an opaque model.
• UiPath Orchestrator is the control plane: a queue (owlgate-changes) as the change record, an API trigger (owlgate-on-change) that a CI/PR webhook posts to, and the owlgate-gate process that runs the agents.
• UiPath Test Cloud / Test Manager executes and governs the tests. We made the Test Manager cases emit real pass/fail without UiPath Studio: a harness runs the sample app's actual Playwright + API tests and reports each result into Test Manager via the uip CLI (testsets run → testcaselog start/finish). The same results drive the gate.
• Action Center is the human-in-the-loop surface (with a queue-item fallback so HITL works even on tenants without the Actions service).
• API Workflows glue the edges: fetch-diff, notify, publish-verdict.
• Automation Solutions package the whole thing as one versioned deployable.
• Coding agents (Claude Code via UiPath for Coding Agents) scaffolded the solution, author the self-healing patches, and built the Studio-free Test Cloud integration — coding agents combined with low-code UiPath components.

The system under test is a small SvelteKit app seeded with three deliberate defects (a fragile selector, flaky timing, and a tightened validation rule) so each agent capability has something real to react to.

Which UiPath components we used

UiPath Test Cloud / Test Manager · Orchestrator (queue, API trigger, process) · Coded Agents (Coded Function) · API Workflows · Action Center · Automation Solutions · UiPath for Coding Agents (Claude Code).

Challenges we ran into

• Automating Test Cloud cases without Studio. Authoring a test entry point normally needs UiPath Studio (Windows). On a Linux/CI box that path is closed, so we used Test Manager's external-result-reporting API via the uip tm CLI — the agents run the real tests and report verdicts. Verified live (a clean tree reports Passed 4 / Failed 0; a broken selector reports Passed 3 / Failed 1).
• Coded agents can't be queue-trigger targets (Orchestrator rejects it) — so we invoke the gate via an API trigger, which also fits the "CI posts the diff" model.
• Action Center isn't enabled on every tenant — so the human gate falls back to a durable Orchestrator queue item, and upgrades to an Action Center task when available.

Accomplishments we're proud of

• A real, end-to-end gate: diff → risk → Test Cloud → self-heal → verdict → human approval → published — verified running on UiPath Automation Cloud.
• Test Manager cases that emit genuine pass/fail from real test runs, no Studio.
• Safety by construction: functional regressions escalate to a human and are never auto-passed.

What we learned

The valuable unit of automation in testing isn't "run the tests" — it's deciding what to test, telling a test defect from a real bug, and knowing when to involve a human. UiPath is a natural control plane for that because it already coordinates agents, robots, people, and APIs. Academic work is converging on the same idea: Kamalı et al. (2026) describe AI "turning code review into a growing bottleneck" and propose agentic code review that turns reviewers into supervisors of agents — which is exactly what OwlGate ships on UiPath.

Built With

• claude
• llm
• node.js
• python
• typescript
• uipath