💡 Inspiration
AI coding agents can produce software at extraordinary speed, but speed alone is not enough for serious development.
Tools such as Codex, Gemini, Claude Code, Cursor, and GitHub Copilot can modify a repository within minutes. However, they may not remember a company’s architectural rules, previous failures, security requirements, or the reasons behind earlier decisions. More importantly, an agent should not be allowed to interpret a simple chat message as authorization to begin sensitive work.
This led us to one core belief:
Autonomous does not mean unsupervised.
We built Universal Agent OS: UiPath Edition to explore how UiPath can provide governance, persistent memory, human approval, and auditable planning for AI coding agents.
We also wanted the system to remain accessible to complete beginners. A user should be able to start with one sentence:
“I have an idea. Please help me turn it into a project.”
The agent should handle the technical preparation, explain each step in plain language, and ask for real human authorization before proceeding.
⚙️ What it does
Universal Agent OS adds a governed, plan-first workflow around repository-aware coding agents.
When a user proposes a new project, the agent must follow this sequence:
Read the repository contract
Agent-specific instruction files teach supported IDE agents how to follow the same governance workflow.Check UiPath readiness
The agent runs a read-only doctor that verifies access to the four governance-memory entities:CodeSoulMinefieldHistoryPersonaStateMemory
Create a real human-approval task
The agent registers aPhase-0 Alignment Reviewtask in UiPath Action Center and then stops.Wait for explicit approval
The user reviews the proposed plan, checks the required approval field, and submits the decision.Verify the decision through the UiPath API
A chat message saying “approved” is not accepted as evidence. The agent continues only when the UiPath API reports that the task is completed and explicitly approved.Run a beginner-friendly Phase-0 interview
The agent asks eight plain-English questions, exactly one at a time. These questions establish the goal, users, platform, privacy boundaries, business model, language, visual style, and success criteria.Create a formal master plan before code
After Phase-0 is complete, the decisions become a governed implementation-plan artifact. Product implementation cannot begin before this alignment is finished.
This creates a clear chain:
Beginner idea → UiPath readiness check → human approval → API verification → Phase-0 interview → master plan → implementation
🛠️ How we built it
UiPath Action Center
Action Center is the real human-in-the-loop authorization layer.
Our Python connector creates a high-priority review task containing the agent’s proposed plan and an explicit approval field. A separate verification command reads the completed task and its submitted data through the UiPath API.
This separation is important: creating a task does not grant permission, and a user’s chat response does not grant permission. Only the verified Action Center decision unlocks Phase-0.
UiPath Data Fabric / Data Service
We modeled four persistent governance-memory entities:
- CodeSoul stores architectural principles and forbidden patterns.
- MinefieldHistory stores previous failures and lessons learned.
- Persona stores developer preferences and review expectations.
- StateMemory stores session state, recent tasks, and verified outcomes.
Before creating the approval gate, the agent checks that all four entities are reachable. This allows future agents to begin with organizational context instead of an empty prompt window.
UiPath Maestro / Agentic Process
The governed lifecycle is represented as a portable BPMN 2.0 process in the repository. We also created and demonstrated the flow on UiPath’s Agentic Process design canvas.
The BPMN model documents the intended relationship between memory retrieval, human review, approval and rejection paths, Phase-0 alignment, and planning.
Our current evidence demonstrates the process model and design canvas. We do not claim a completed Maestro runtime instance in the final demo.
UiPath Orchestrator
The connector can submit the deployed UiPath process and expose job records through Orchestrator. During our captured tenant run, submitted jobs were visible in the Pending state.
We include this limitation explicitly: the project demonstrates process submission and job visibility, but the final demo does not claim a completed unattended runtime execution.
Python governance backend
The backend contains:
- a UiPath API connector;
- a read-only readiness doctor;
- gate registration and verification commands;
- strict configuration validation;
- persistent Phase-0 interview state;
- markdown-to-governance synchronization;
- mock and Strict Real modes.
Strict Real Mode never silently falls back to mock data. If required UiPath configuration is missing or an API request fails, the operation stops with an explicit error.
Repository-native agent adapters
The repository includes discovery instructions for Codex-compatible agents, Gemini, Claude Code, Cursor, and GitHub Copilot.
These files allow the repository itself to teach the IDE agent that it must:
- run the UiPath checks itself;
- never ask a beginner to execute commands the agent can run;
- stop for Action Center approval;
- verify the approval through the API;
- ask only one Phase-0 question at a time;
- create a plan before implementation.
Built with coding agents
We dogfooded the idea by using coding agents while building a system that governs coding agents. Gemini, GitLab Duo, and repository-aware agent tooling assisted with planning, connector development, tests, documentation, and evidence preparation.
The repository preserves prompt excerpts, commit history, tests, and an evidence manifest rather than making unverifiable claims about agent contributions.
⚠️ Challenges we ran into
Making approval real
The hardest problem was preventing the agent from treating conversational confirmation as authorization.
Our first iterations could create an Action Center task, but task creation alone was not enough. We separated the workflow into two commands:
registercreates the gate and blocks execution.verifyretrieves the server-side task state and submitted approval value.
The agent remains blocked unless the API returns a completed and explicitly approved decision.
Handling Action Center task states
During testing, we encountered differences between unassigned, pending, and completed task views. A task sometimes needed to be assigned to the current user before its decision fields became interactive.
This taught us that enterprise human-task workflows require careful state handling and clear user guidance—not merely an API call that creates a form.
Designing for nontechnical users
Most development assistants immediately ask about frameworks, databases, programming languages, and cloud providers. That defeats the purpose for beginners.
We redesigned the bootstrap so the user only describes the idea. The agent performs technical checks in the background and then asks simple questions such as:
- What do you want to build?
- Who will use it?
- Where should people use it?
- What is the one task that must work in the first version?
Keeping evidence honest
The project touches several UiPath surfaces, but not every surface reached the same runtime maturity.
We therefore created an evidence manifest that distinguishes:
- implemented repository code;
- live Action Center and Data Fabric evidence;
- portable BPMN specifications;
- UiPath design-canvas evidence;
- pending Orchestrator job submissions;
- simulated or future capabilities.
This honest boundary made the final submission stronger and more reproducible.
🏆 Accomplishments that we are proud of
We successfully demonstrated a complete beginner-facing governance journey:
- A user starts with one nontechnical sentence.
- The IDE agent reads repository rules automatically.
- The agent checks real UiPath entities.
- A real Action Center approval task is created.
- The user grants explicit permission.
- The agent verifies that permission through the UiPath API.
- Phase-0 begins only after verification succeeds.
- Eight plain-language questions are completed one at a time.
- A formal master plan is created before implementation.
We are especially proud that the system does not merely display a governance dashboard. The coding agent itself follows the governed workflow inside its native IDE environment.
📚 What we learned
We learned that UiPath’s capabilities extend naturally beyond traditional business automation.
Action Center can provide meaningful human authorization for AI decisions. Data Fabric can become persistent organizational memory for agents. BPMN can make a nondeterministic AI workflow understandable and reviewable. Orchestrator can expose execution attempts as auditable platform records.
We also learned that the most valuable AI safety mechanism is not another warning inside a prompt. It is a verifiable workflow with explicit state transitions, external evidence, and a human decision that the agent cannot manufacture by itself.
Finally, we learned that governance and usability do not have to conflict. The safest workflow can also be the easiest workflow when the agent handles technical complexity and presents the user with one understandable action at a time.
🚀 What’s next
Our next steps are:
- completing and monitoring the full Maestro runtime lifecycle;
- adding automated risk scoring before human review;
- supporting separate Coder, Reviewer, Security, and QA agents;
- attaching approval policies to repository risk levels;
- expanding persistent organizational memory across projects;
- introducing signed execution gateways for stronger enforcement;
- packaging the integration as a reusable UiPath Marketplace component.
Our long-term vision is a UiPath-governed software organization where AI agents can work quickly, but every important action remains explainable, reviewable, and accountable.
Log in or sign up for Devpost to join the conversation.