Covenant

Inspiration

We focused on a real healthcare operations gap: treatment orders do not fail because one API call is slow, they fail because the clearance process breaks across systems, roles, and exception paths.

When a doctor orders an MRI, infusion, surgery, or specialist procedure, the patient expects care to move forward. In practice, the order enters a fragmented administrative workflow involving coverage checks, prior authorization, missing clinical evidence, denials, status chasing, staff review, and scheduling handoffs. Orders get stuck in open loops, clinic staff spend time re-checking status and chasing documents, and treatment access is delayed by process fragmentation rather than clinical intent.

We built Covenant to model that workflow as one governed BPMN process on UiPath Maestro instead of leaving it split across inboxes, spreadsheets, and disconnected systems.

What it does

Covenant is a Track 2 UiPath Maestro BPMN solution for treatment clearance and denial rescue.

It orchestrates the full path from order intake to scheduled care:

1. Receives a treatment order
2. Checks payer coverage and whether prior authorization is required
3. Extracts clinical and administrative evidence
4. Evaluates completeness against payer requirements
5. Routes missing evidence to remediation
6. Routes complete packets to governed review
7. Submits prior authorization
8. Checks payer status through a long-running process step
9. If denied, builds denial rescue and appeal preparation
10. If approved, schedules treatment
11. Notifies the patient
12. Generates an audit packet

The solution is designed to show not only the straight-through path but also the operational exception paths that matter in real healthcare workflows: missing documentation, waiting states, denials, and appeal recovery.

How we built it

We built Covenant as a BPMN-first orchestration system with UiPath as the control plane.

On the UiPath side:

• UiPath Maestro BPMN models the end-to-end treatment clearance process
• UiPath Studio Web is used for process and workflow authoring
• UiPath API Workflows handle service-to-service orchestration
• UiPath Agent Builder roles represent low-code agent participation in evidence and denial-routing steps
• UiPath Automation Cloud / Orchestrator handles deployment and execution management

On the service layer side:

• A Cloudflare Worker provides the public backend surface used by the workflows
• A Render-hosted Mastra agent acts as an external coded policy-variance participant
• OpenRouter is used for optional LLM rationale generation in the external coded agent
• Public healthcare reference APIs validate diagnosis and provider context

The key architecture decision was to keep UiPath as the orchestrator even when external coded agents are involved. The external agent participates in the workflow, but it does not own process state or routing. Maestro BPMN remains authoritative for process logic, approvals, and exception handling.

Challenges we ran into

• Getting the BPMN flow to remain dynamic and governed instead of collapsing into hardcoded demo shortcuts
• Wiring gateway conditions correctly inside Maestro so routing followed actual workflow outputs
• Keeping human-review stages represented in the process while working within hackathon tenant limitations for full app/task deployment
• Making the public reference stack reproducible for judges without requiring private healthcare systems or private tenant-only dependencies
• Fixing deployment friction across Cloudflare Worker, Render, and the external coded agent path
• Keeping the solution strong on platform usage without turning it into generic “AI agent” theater

Accomplishments that we're proud of

• Built a process that fits Track 2 directly instead of forcing a generic assistant into BPMN
• Kept UiPath as the actual orchestration and governance layer across APIs, agents, decisions, and approvals
• Modeled both missing-evidence remediation and denial-rescue handling as first-class branches
• Deployed a public backend surface that judges can hit directly
• Integrated an external coded agent without giving up governed orchestration
• Produced a submission package that is aligned to the actual shipped system, not aspirational slides

What we learned

• In healthcare operations, the hard problem is orchestration, not just extraction or summarization
• BPMN is much stronger when the workflow is built around operational ownership, waiting states, and exception branches from the start
• External agents add value only when their role is constrained and governed
• Judge credibility improves when every claim maps to something live, inspectable, and reproducible
• UiPath is most compelling here when it is used deliberately for long-running, stateful, approval-sensitive work rather than as a thin wrapper around APIs

What's next for Covenant

• Replace reference data with production-grade EHR and payer integrations
• Add richer human task and approval UX in a tenant with full app-task deployment support
• Persist case-level operational records for downstream reporting and SLA tracking
• Expand the denial-rescue agent into a broader exception-resolution capability
• Add payer-policy variance monitoring across multiple procedure types and plans
• Introduce stronger operational dashboards for queue health, bottlenecks, and escalation aging

Built With

• apis
• cloudflare
• javascript
• mastra
• openrouter
• python
• render
• rest
• typescript
• uipathagentbuilder
• uipathapiworkflows
• uipathautomationcloud
• uipathforcodingagents
• uipathmaestrobpmn
• uipathorchestrator
• uipathstudioweb
• workflows