AgentHack winning architectures

What happens when an agent meets an adversary

Most agent evaluations are cooperative by design: you write a test set, the agent passes it, and the score tells you nothing about what happens when a real attacker sends an input nobody anticipated.

This year's Grand Prize winner, Gauntlet, closes that gap by pitting a Red Coach agent, which mutates its attack strategy every round, against a Blue target agent, running the whole fight on UiPath Maestro Case and feeding every successful attack into UiPath Test Manager as a permanent regression test.

That problem only shows up once an agent is running inside a real process, which is exactly the space UiPath Maestro is built for, as the orchestration core of the UiPath Platform™ approach to Business Orchestration and Automation Technologies (BOAT), Gartner's term for the layer that coordinates AI agents, automation, and people under one governed operating model. Maestro Case and Maestro BPMN were the backbone behind nearly every winning submission this year, pausing for approval in Action Center, branching on confidence scores, and escalating to a human instead of guessing. That's the throughline across this year's winners, and of AgentHack itself.

Celebrating the builders

Over the past few months, the UiPath Community came together for AgentHack 2026, our annual global hackathon, built around three tracks: UiPath Maestro Case, UiPath Maestro BPMN, and UiPath Test Cloud. The response was significant: 1,400 builders registered, 333 teams submitted, and 203 went into evaluation. 31 finalist teams presented live at the finale on July 23, 2026, and the winners were announced shortly after on the UiPath Forum.

This year's brief was robust: a public GitHub repository, a five-minute demo video of the solution‌ running, and orchestration built on UiPath Automation Cloud. Building with coding agents — Claude Code, Codex, Cursor, Gemini CLI — through UiPath for Coding Agents earned bonus points, and every top winner below used one. Submissions were judged on business impact, platform usage, technical execution, completeness of delivery, creativity, and presentation. Here's a closer look at the winning solutions from each track.

Grand prize

Gauntlet - Go safe or go home

Built by Tim Dries, Gauntlet runs fights between a Red Coach agent, which mutates its attack strategy each round, and a Blue target, which can be any UiPath Agent, Maestro Flow, or external LangGraph agent. The orchestration runs on Maestro Case (FightArena) with each round handled by a Maestro Flow (RoundOrchestrator); winning attacks are automatically added to UiPath Test Manager as permanent regression tests, tagged against the OWASP LLM Top-10 and MITRE ATLAS frameworks. When a fight exposes a weakness, a Fix Recommender proposes ‌remediation and opens an UiPath Action Center task for a human to review, rather than patching the agent automatically.

Team member: Tim Dries. $8,000.

1st place – InsureIQ

InsureIQ is an AI-driven underwriting assistant that automates key steps of the insurance evaluation workflow. Insurance underwriting is often slow and manual, requiring underwriters to review large volumes of structured and unstructured data under tight timelines. InsureIQ ingests policy and customer data, uses AI to extract insights and assess risk, and generates structured recommendations, while a case management layer tracks each request and keeps a human in the loop for final validation.

The solution combines UiPath Orchestrator and Maestro for workflow management with Agent Builder and Coded Agents for the reasoning layer, and uses the AI Trust Layer to support explainability, an important requirement in a decision-heavy domain like insurance.

Team members: Srajan Gupta, Tanya Pakhee, Astitva Singh, Pragya Jha (Team ADROForge). $5,000. InsureIQ also won Best Demo/Presentation.

2nd place – Do Not Consume 👏 Team members: Neehara Ajithkumar & team. $3,000.

3rd place – PostAuto x BE-terna – Customer request processing 👏 Team members: Patrick Wirth & team. $2,000.

UiPath Maestro BPMN track

1st place – SpectreAI

Every RPA team knows the pattern: a bot fails in production, an end user reports it, and a developer has to dig through UiPath Orchestrator logs to find and patch the broken XAML before raising a PR, often taking two to four hours per incident. SpectreAI was built to remove that loop entirely. A Slack message triggers a Maestro BPMN process that classifies the request as a bug or enhancement.

An InvestigationAgent runs a three-layer log fetch (job logs, business exception logs, transaction item logs) against a knowledge base of past diagnoses and returns a root cause with a confidence score. On high-confidence cases, a CodingAgent fetches the XAML directly through the GitHub API, without cloning the repository, produces and validates a patch, and raises a labelled draft PR. Lower-confidence cases are escalated to a human through interactive Slack buttons rather than resolved automatically. The solution runs three fully working paths end to end: happy path, escalation, and enhancement.

👏 Team member: Nithin BR. $5,000.

2nd place – Adro Acord AI 👏 Team members: Lakshay Sabharwal & team ADROMinds. $3,000.

3rd place – FDE Agent: Pre-Flight Check for Enterprise AI Workflows 👏 Team member: Minji Kim. $2,000.

UiPath Test Cloud track

1st place – FlakeWarden

FlakeWarden triages failing tests and routes each one to the right action. Its architecture is deliberately split: a deterministic flake scorer uses exact statistics from the run history to resolve cases with high confidence.

A grounded UiPath Agent Builder classifier handles the more ambiguous cases by analyzing stack traces, selector diffs, and commit messages. It labels each case as a real defect, a flaky test, or an environment issue. UiPath Maestro orchestrates the handoff between the two, and a fix is only ever proposed for flaky tests, never applied automatically; every quarantine, heal, or baseline change is a human-gated proposal. On a 150-case labeled corpus, the solution measured 90.7% accuracy with a 0% safety-direction false-positive rate.

UiPath Maestro orchestrates the handoff between the two, and a fix is only ever proposed for flaky tests, never applied automatically; every quarantine, heal, or baseline change is a human-gated proposal. On a 150-case labeled corpus, the solution measured 90.7% accuracy with a 0% safety-direction false-positive rate.

👏 Team member: Jonathan SolvesProblems. $5,000.

2nd place – Cricible 👏 Team member: Kinnah Joshua. $3,000.

3rd place – Penetron 👏 Team member: Oleksandr Kryo. $2,000. Penetron also won Best First-Time Builder.

Bonus and special awards

• Most Creative Solution: Nexus Maestro: 1 Case, 5 AI Agents, Seamless Orchestration, Russel Alfeche & team. $3,000.

• Best Cross-Platform Integration: SelfHeal QA, Anthony Yanza. Built as Anthony's first UiPath project, SelfHeal QA is a UiPath Coded Agent that self-heals brittle UI test locators, but refuses to heal a real bug, filing a defect in UiPath Test Manager instead. The solution was validated with a 0% false-negative rate across 8 real regressions and 100% triage accuracy on a 16-case adversarial benchmark designed to try to fool it. $1,500.

• Best First-Time Builder: Penetron, Oleksandr Kryo. First UiPath hackathon, and a 3rd place finish in the Test Cloud track. $1,500.

• Best Product Feedback: Sabrina Ben Haddou. This award recognizes the individual or team providing the most insightful and high-impact feedback on the UiPath products used during the hackathon. $1,500.

• People's Choice – picked by the community. $500 each:

Meridian, Dhananjay Mendgudli & team

Vigilance 'Q': The Pharma Quality Watchtower, team Boundaryless Maestro Minds

Do Not Consume, Neehara Ajithkumar & team

That's $50,000 in prizes across 17 awards. All 31 finalist projects are worth exploring, not only the ones listed above – the full gallery is available on DevPost, and the finalist announcement thread on the UiPath Forum has the complete list by track.

Patterns worth carrying into your own builds

Looking across the winning solutions, a few architectural choices show up repeatedly, regardless of track:

• Deterministic logic and generative reasoning are kept separate on purpose.

FlakeWarden's flake-scorer resolves clear cases with exact statistics and only hands the ambiguous middle to an LLM classifier. Gauntlet turns its attack corpus into an OWASP- and MITRE-tagged coverage matrix rather than a vibes-based safety claim.

• Autonomous actions are paired with a refusal path.

SelfHeal QA refuses to heal a real bug and files a defect instead. SpectreAI escalates low-confidence cases to a human through Slack rather than guessing. Gauntlet's Fix Recommender proposes a remediation but always routes it through Action Center for human approval.

• Coding agents were used to build the orchestration itself, not just to generate code snippets.

Several of the winning teams used Claude Code together with the uip CLI to author Maestro BPMN processes, deploy Coded Agents, and wire up Test Manager and Action Center integrations, which is exactly the kind of usage the bonus points criteria were designed to reward.

In the builders' words

Winners weren't the only people who learned something during the competition. Many participants sent us feedback after building, and one line from Nick Sudh sums up what came back most often:

We built the crisis logic instead of the plumbing.

Nick's CascadeCare Network Command runs a multi-stakeholder healthcare-payment cyber crisis as one living Maestro case, nested three levels deep, driven by five mid-flight goal reversals across a simulated 90-day timeline.

The solution spans 13 UiPath product surfaces and includes 12 AI agents: six low-code Agent Builder reasoners powered by BYO Claude, and six coded Python agents. Two of the Python agents use the LangGraph StateGraph. The architecture also includes Context Grounding, Data Fabric, Integration Service API Workflows, Action Center approval gates, the LLM Gateway, and the Trust Layer. What he rates highest is the agent-as-task model: invoking agents as type:

Agent tasks inside case stages, mixing low-code and coded agents in the same case, is clean and composable. His team swapped a deterministic coded agent for a LangGraph implementation of the same task and invoked it as a normal case task with zero special-casing on the canvas. Without Maestro it would have been an unmanageable tangle of custom queues, state machines, and glue code.

Emmanuel Nwajari and Kodu Giobari built AgriGrant AI while learning UiPath and Maestro for the first time. It helps farmers discover and pursue agricultural grants, and one application can sit open for days while a farmer emails a missing tax document or an officer approves a profile.

I initially thought about building a custom Python backend to track the status of each grant. But Maestro eliminated the need for a custom database entirely. Built by hand, that would have meant cron jobs, database state flags, and webhook listeners just to wake the Studio Robot up once the documents arrived. Do not try to build the orchestrator yourself in Python or Node.js.

They didn't get the workflow to the level they first envisioned, as learning about a new platform and the hackathon clock were happening at the same time, and they submitted what they had built anyway. For Emmanuel that's also an impactful part of the story: "an imperfect outcome is still better than giving up completely." He draws the parallel to the work AgriGrant AI is built for.

A farmer can lose part of a harvest to a difficult season, preserve what remains, learn from it, and prepare to do better next time. Building technology works much the same way: you work with what you have, push through the constraints, and bring something into the light.

Leonardo Calancea's CostGuard checks what an agent costs to be right, cost per correct invoice, not per token, and blocks the promotion if cost regressed, with a human approving the block. He built it, deployed it, and ran it as a live serverless job on Automation Cloud without leaving his terminal: Claude Code authenticated the tenant, packaged the agent, pushed it to the feed, created the process, and started the job. It came back with a verdict in eleven seconds.

Agents building agents on a governed platform' stopped being a slide and became something I'd actually done.

Looking ahead

A warm congratulations to all participants and winners of AgentHack 2026. We look forward to seeing more from these innovative projects.

Thank you to everyone who registered, built, and submitted, and to the judges who spent hours reviewing submissions and running the finale. We look forward to seeing you at the next hackathon. In the meantime, check community.uipath.com for more hackathons, events, and programs.