From fragmentation to flow: unified development in the UiPath 2025.10 release

As enterprises scale agentic AI, developers face a growing challenge: fragmentation. Teams juggle disconnected tools, data sources, and environments, losing more than 40% of productivity to context switching. Even as 75% of enterprise developers adopt AI by 2028, most will still operate in fragmented ecosystems. True productivity, scalability, and AI readiness demand a unified development experience.

UiPath Studio delivers that experience as a single AI-native workspace where every developer, from low-code builders to Python pros, can build, test, and deploy AI agents, robots, and API automations seamlessly.

One environment for every builder

Studio unifies low-code and pro-code development in one collaborative workspace. It brings every automation type—robotic, agentic, and API—into a single governed build environment, with a shared context and automation resources. Low-code builders and pro developers can now collaborate without hand-offs, reuse the same connections, queues, assets, and storage buckets as well as deploy to any environment, whether cloud, hybrid, or on-premises.

And with built-in governance and version control applied consistently through Automation Ops, Studio ensures enterprise-grade standards are applied automatically so developers can move fast without losing control.

Agent Builder in Studio: design and test intelligent agents visually

Agent Builder introduces a low-code, visual canvas in UiPath Studio for creating AI agents that combine deterministic logic with AI reasoning, while providing real-time evaluation and scoring to ensure their reliability. Here’s what’s new:

• Prebuilt templates: more than 50 agent templates for use cases like document summarization, data enrichment, and task routing

• Visual canvas: drag-and-drop activities for calling tools, orchestrating steps, and handling multi-agent collaboration

• Simulation and reliability scoring: run controlled tests against mock inputs, view behavior traces, and quantify accuracy before production

• Instance visualization: heatmaps and runtime dashboards show agent performance and error rates across deployments

• Built-in governance: projects automatically inherit version control, access policies, and telemetry through OpenTelemetry (OTEL) export

• Conversational agents: a type of agent you can create in Agent Builder that enables natural, context-aware interactions powered by enterprise knowledge, connected tools, and human escalation

Agent Builder in UiPath Studio closes the entry gap for agent development. You can prototype fast, validate performance early, and keep agents observable and governed by default.

Coded agents: full control and open-source extensibility

UiPath offers developers flexibility depending on the job to be done. If the goal is to build and iterate quickly, the low-code Agent Builder in Studio provides an efficient path. But when a project calls for deeper customization or integration, coded agents extend the Studio experience into a full Python workflow—with the same testing, evaluation, and scoring capabilities.

You can write, debug, and deploy agents using the UiPath SDK with support for open-source frameworks like LangChain and LlamaIndex, and securely connect them to external tools or models using the Model Context Protocol (MCP). What’s in this release:

• Build in Python with UiPath SDKs: call enterprise robots and use UiPath artifacts

• Run with enterprise-grade orchestration: observability, governance, and human-in-the-loop (HITL) via Action Center or any embedded tool

• Leverage open frameworks: use LangChain and LlamaIndex while benefiting from UiPath trust, governance, and scalability

• Model Context Protocol (MCP) support: connect to external or local models (e.g., Azure AI Foundry, Vertex AI, OpenAI GPT-5) through standardized context exchange

• Tool hosting: agents can call internal APIs or third-party services securely, using governed credentials

• Studio integration: coded agents can be imported into Studio to run the same simulations, scoring, and observability as low-code agents

• Cross-platform execution: deploy coded agents through UiPath Automation Suite or UiPath Automation Cloud™ with identical security and monitoring policies

Coded agents bring the openness developers expect, without losing enterprise governance. It’s the same build lifecycle whether you write Python or design visually.

ScreenPlay: intent-driven agentic UI automation

Bridging context and action, UiPath ScreenPlay brings a new class of intelligent, self-driving UI automation to the Studio environment. It lets anyone automate user interfaces by simply describing a task in natural language.

ScreenPlay understands intent, translates it into a multi-step execution plan, and runs autonomously across desktop and web interfaces. It dynamically adjusts execution based on task context, ensuring automations remain reliable even as applications evolve. Designed for enterprise-grade unattended scenarios, ScreenPlay supercharges UI automation with true agentic capabilities that merge perception, reasoning, and action.

Technical highlights include:

• Prompt-to-action translation: converts natural-language instructions into autonomous actions across various interfaces—without a need to manually configure selectors for each step.

• Cross-platform parity: supports UI automation scenarios across Windows, Linux, and macOS.

• Context-aware adaptation: reads live screen elements and adapts to changes on the go, even if applications get redesigned, UI elements shift, or styling differ across machines.

• Flexibility: provides access to third-party large action models (LAMs) and custom UiPath agents, enabling you to balance speed, cost, and power for each use case.

• Deep UI grounding: leverages industry-leading UiPath screen understanding technology, powered by decades of innovation in UI automation. By blending DOM extraction with AI Computer Vision, it grounds AI execution in real application context—eliminating hallucination and improving accuracy.

• Enterprise-grade unattended automation: combines the autonomy of agentic AI with the reliability of UI automation, unlocking computer-use capabilities for unattended enterprise scenarios at scale. Security and governance: integrates with the UiPath AI Trust Layer to safeguard data, models, and execution across all your processes. Credentials and tokens are securely managed through Orchestrator for enterprise-grade access control.

ScreenPlay provides access out-of-the-box to market-leading LAMs, particularly OpenAI Operator and Anthropic Computer Use. It also offers UiPath-built custom agents—our secret recipe for agentic UI automation—that blend UiPath technology with large language models (LLMs) from Google and OpenAI.

This approach is already showing results. In fact, UiPath Screen Agent, a custom ScreenPlay agent built with OpenAI GPT-5, was recently ranked #3 on the OSWorld-Verified benchmark.

We’re proud to work with OpenAI on incorporating its models into our newest capabilities. Here’s how OpenAI describes this effort:

UiPath is helping developers close the gap between AI insight and real enterprise action, and we’re proud to support that vision with our models. Together, we’re enabling a new generation of agents and automations that are simpler to build and powerful at scale.

James Dyett, Head of Strategic Accounts, OpenAI

ScreenPlay marks a new era of enterprise automation—where AI not only understands intent but takes reliable, autonomous action across your interfaces. Our early adopters are already seeing how ScreenPlay unlocks new automation opportunities.

Having had an early look at UiPath ScreenPlay, we’re excited about its potential to meaningfully improve how we scale automation. Its adaptive intelligence could support our growing partner ecosystem while helping reduce ongoing maintenance so our teams can stay focused on growth.

Noble Keyser, Manager, Enterprise AI and Automation, SimpleTire

API Workflows: system-to-system automation built in

Automation doesn’t stop at the UI. Many enterprise workloads rely on API-based orchestration between systems. For high-volume, system-to-system automation, API Workflows in UiPath Studio close the execution gap between AI decisions and enterprise action. Developers can now build, debug, and run API-based automations directly inside Studio alongside robotic process automation (RPA) and agentic workflows.

API Workflows handle logic, data transformation, and event triggers in one governed flow. They keep systems synchronized and data consistent while ensuring speed, precision, and observability at scale. Capabilities include:

• Connector catalog: native access to hundreds of UiPath-certified connectors plus a custom connector builder for REST, SOAP, and GraphQL endpoints

• Inline logic and validation: conditional branching, data transformation via JavaScript expressions, and schema validation for robust API chains

• Performance and observability: execution metrics, response previews, and end-to-end traceability via OTEL

• Event-driven execution: workflows can be triggered by API calls, webhooks, or agentic events, supporting async orchestration at enterprise scale

• Reusability: any automation can be exposed as a callable API endpoint, making integration bi-directional across the UiPath Platform™

With RPA, agentic, and API workflows in one place, you can design full end-to-end processes—UI, logic, and system calls—without context switching or governance drift.

Autopilot for Developers: accelerate authoring

Building in one environment means you can also get help in one. UiPath Autopilot™ for Developers adds an AI assistant within your integrated development environment (IDE) to help write expressions, scaffold workflows, and debug faster.

Describe what you want: “connect to ServiceNow and extract open incidents,” and Autopilot creates the activities and logic. It can explain code, catch syntax errors, and apply UiPath best practices automatically. And teams in regulated environments can connect their own LLMs through MCP for full control of data residency. It doesn’t replace developers, it removes friction. Setup, syntax checks, and boilerplate code happen instantly, so you can focus on logic and architecture.

From tool fragmentation to a single stack

Unified development replaces tool fragmentation with a single, composable stack:

• One integrated development environment for RPA, API, and agentic workflows

• Same runtime, observability, and security controls across deployment models

• Git, OTEL, and MCP support for modern DevOps pipelines

• AI-assisted authoring that keeps full precision and versioning

Whether you prefer drag-and-drop, Python, or prompt-based automation, you can now build in one flow, under one standard of reliability and governance.

Want to see what’s coming next? Head to UiPath Labs to get hands-on with early previews, experimental capabilities, and help define the next generation of agentic automation.