From AI speed to enterprise reliability: introducing UiPath for Coding Agents

Before I founded UiPath, I was an engineer at Microsoft, working on SQL Server Agent. My job was to build a scheduler that could run automated jobs reliably, millions of times, inside enterprise databases I would never see, under conditions I could not predict. The code itself wasn't the hard part. Making the code run, dependably, at scale, was hard. I've been working on some version of that problem ever since.

Twenty years later, the problem hasn't changed. What has changed is who writes the code.

AI coding agents have gone from autocomplete assistants to autonomous partners in less than two years. Eighty-four percent of developers use one or plan to. For a lot of teams, that coding agent has already become a dependable builder. The question is no longer whether AI can write code. It can. And has been proven several times over. The question is what happens after the code is written—how output from a coding agent turns into a real outcome for an enterprise and the customer on the other end of it.

Today, UiPath is the first enterprise business orchestration and automation platform to open its orchestration layer to any coding agent. We’re introducing UiPath for Coding Agents. Builders can now use their coding agent of choice—Claude Code, OpenAI Codex, Cursor, Google Gemini CLI, GitHub Copilot, and others—to create, test, deploy, operate, and govern UiPath-built automations across the entire lifecycle.

UiPath for Coding Agents

Think about what a customer experiences when they apply for a mortgage. From the outside, it's a single application. Inside the enterprise, it's dozens of moving parts: a credit pull, income verification, document review by AI agents, an underwriter checking on exceptions, and a confirmation back to the applicant. Every one of those steps is an automation. The whole thing only feels seamless to the customer if every handoff between them works. When one fails, the customer feels it, and the lender pays for it in abandonment, complaints, or worse. Coding agents can now build, operate, and optimize every step of that process on the UiPath Platform™, so the whole thing runs end to end without gaps.

That kind of reliability is where enterprise automation actually lives. In the retry logic after the third API failure. In the credential vault. In the role-based access control policy. In the case state that has to survive for thirty days while a claim moves through twelve systems and four approvals. In the audit trail that has to hold up when a regulator asks a question three years from now. None of that is visible in a demo yet. All of it is the difference between a proof of concept that worked on someone's laptop and an automated process running across twenty business units at scale.

Why enterprise automation needs more than AI-generated code

Coding agents compress the first 10% of the work. What's left is the hard part. Three things, in particular, separate a generated script from a production automation. Multiple actors in one process. Humans approve. Robots click into legacy UIs that will never have a modern API. API workflows move data between SAP and Salesforce in milliseconds. Agents reason over unstructured documents. All of that has to be coordinated, with handoffs, dependencies, and states that customers don't have to manage themselves.

Deterministic guardrails around non-deterministic AI. Evaluation, policy enforcement, controlled-agency boundaries. The layer that keeps an AI agent from doing something that, in isolation, sounds reasonable but is catastrophic in context. A United States (U.S.) semiconductor company spent over a year trying to get an agent-based workflow into production with another vendor. With UiPath, they did it in under two weeks. That’s the gap UiPath for Coding Agents closes.

What this means for builders

Open your terminal or IDE. Connect your coding agent to UiPath. Describe in plain English what you want to accomplish: reconcile our daily AP invoices against SAP, flag exceptions to the controller, and post the clean batch. A few moments later, you have a UiPath project scaffolded against platform conventions, validated against enterprise policies, packaged, and ready to iterate on locally and then deploy to production.

Two things matter about how we built this.

First, the platform is open to every coding agent. Enterprises are not going to standardize on one, and the best coding agent six months from now probably doesn't exist today. Run Claude Code on one team, Codex on another, swap in what comes next. The orchestration, observability, execution, and governance layer underneath stays the same. That is the real compounding advantage. Every model release from Anthropic, OpenAI, Google, and the rest makes this platform more valuable, because more automations reach production and more processes need somewhere reliable to run.

Second, governance is the default, not the afterthought. Policy enforcement, audit trails, credential vaults, role-based access control, and runtime controls are standard for every automation that enters the platform. Whether a human authored it or a coding agent did, it inherits the same guardrails the rest of your automations already operate under. Coding agents are free to iterate at AI speed locally. Promotion to production still follows an enterprise path, and that path is repeatable.

Who becomes a builder

For the developers already building on UiPath, the productivity ceiling moves. Testing, debugging, and deployment become as accessible as building. For millions of people who have never touched automation, the barrier just dropped to a conversation with a coding agent.

I've been arguing for a while that a new role is emerging in the agentic enterprise. Not just engineers. Builders. People who can describe what they want, direct a coding agent to produce it, and carry it through to something that actually runs. Product managers, analysts, operators with taste and judgment. Coding agents are how they cross the line from idea to execution. UiPath is how what they build stays running.

A better coding agent generates better code, faster, with fewer errors. All of that still has to execute against real enterprise systems, under real governance, at real scale, and it has to keep running when the models get replaced, developers move on, and the regulator calls. The execution layer compounds with every model release. The orchestration layer compounds with every new artifact built.

We are still in the early stages of a much larger transition. Coding agents will keep getting better. Twenty years ago, I worked on making code run at Microsoft. The answer to that problem hasn't changed. Writing code is the easy part. Running it, durably, safely, at enterprise scale, is where the value accrues, and where trust is earned or lost.

That's the layer we're opening up, starting today.

In two days, at DevCon, our developer conference, we’ll show the whole thing end-to-end. A working enterprise automation, built by a coding agent, deployed into production, governed from the first commit. Developers in the room will see exactly what this means for how they build. Everyone else can watch the keynote live on YouTube.