UiPath Coded Agents represent a shift toward “pro-code” agentic automation. Unlike traditional RPA, which is often visual and deterministic, coded agents allow developers to build autonomous, AI-driven logic directly in their preferred Integrated Development Environment (IDE) using Python.
- 1. What Are Coded Agents?
- 2. Core Architecture and Capabilities
These agents are designed to interpret, reason, and plan actions—leveraging Large Language Models (LLMs) while remaining fully integrated into the enterprise-grade governance of the UiPath Orchestrator.
1. What Are Coded Agents?
Coded Agents are software agents written directly in code (e.g., Python or JavaScript) using supported frameworks, integrated into the UiPath automation ecosystem. Unlike low-code agents created via drag-and-drop tools, these agents give developers full control over logic, reasoning, integrations, and behavior — while still benefiting from UiPath’s cloud orchestration, logs, compliance rules, and governance.
In simpler terms, think of coded agents as programmable autonomous workers that:
- Take goals and context as input,
- Reason using AI and external tools,
- Act on behalf of users in complex workflows,
- Integrate deeply with business systems and automation services.
2. Core Architecture and Capabilities
Coded agents bridge the gap between flexible AI frameworks and rigid enterprise requirements. They are packaged as standard .nupkg files and deployed as processes within Orchestrator folders.
- Logic Control: Developers have complete control over state management, complex loops, and custom error handling that might be cumbersome in a visual flow.
- Seamless Integration: Using the UiPath SDK, agents can programmatically interact with:
- Assets: For secure credential and secret management.
- Storage Buckets: For handling unstructured data files.
- Data Service: For structured business data.
- Orchestrator Jobs: To trigger or monitor other RPA processes.
- Tracing & Observability: Native integration with LangSmith allows for deep inspection of LLM reasoning paths, ensuring transparency in AI decision-making.
Supported Frameworks & SDKs
UiPath provides specialized SDKs to accelerate the development of sophisticated multi-agent systems.
| Language/Framework | SDK Package | Primary Functionality |
| Python | uipath-python | Core CLI for creation, packaging, and platform interaction. |
| LangGraph | uipath-langchain-python | Builds stateful, multi-agent workflows with complex decision cycles. |
| LlamaIndex | uipath-llamaindex-python | Optimized for RAG (Retrieval-Augmented Generation) and data-heavy workflows. |
Why Coded Agents Are Important
1. Advanced Customization
With coded agents, developers can embed:
- Complex reasoning,
- Domain-specific logic,
- Custom memory and planning loops,
- Integration with APIs and services beyond UiPath’s built-in activities.
2. Enterprise-Ready Deployment
Once built, coded agents are packaged, published, and deployed through UiPath Orchestrator just like traditional automations — ensuring scalability, security compliance, monitoring, and scheduling.
More Read
3. Unified Governance
Businesses get standardized governance, audit trails, human-in-the-loop approvals, and logging — all essential for regulated industries.
How Coded Agents Work
1. Developer Creation
Developers write agent logic in their preferred environment (IDE) using supported frameworks like LangChain, LangGraph, or LlamaIndex. This code defines:
- Perception (input handling),
- Reasoning (AI decision making),
- Action (APIs, workflows, data operations).
2. Integration with UiPath SDK
Using the UiPath SDK, coded agents connect to platform services, such as:
- Orchestrator APIs,
- Context storage (assets, buckets),
- LLM gateways and model endpoints.
3. Packaging and Deployment
A simple CLI command packages the agent for UiPath’s cloud. Once deployed:
- Agents can be scheduled,
- Observed via dashboards,
- Governed and approved within enterprise rules.
Development Lifecycle: From IDE to Orchestrator
The development process for a coded agent mirrors the modern software development lifecycle (SDLC) while retaining the benefits of the UiPath ecosystem.
- Initialization: Use the CLI command
uipath new <agent_name>to generate a project structure. This creates essential files likeuipath.json(to expose functions) andrequirements.txt. - Logic Development: Write your Python logic in an IDE (like VS Code). You can utilize the
uipath-pythonSDK to fetch assets or start other jobs. - Authentication: Authenticate your local environment using
uipath authto link your IDE to your UiPath tenant. - Packaging: Run
uipath packto compile your code into a.nupkgpackage. - Deployment: Run
uipath publishto send the package to the Orchestrator feed. - Execution: In Orchestrator, create a process from the package. It can now be triggered by events, APIs, or schedules.
Human-in-the-Loop (HITL)
Coded agents are not purely “black box” autonomous systems. You can programmatically define interrupt points to ensure human oversight:
- Action Center Integration: When an agent reaches a high-risk decision, it can create a task in the UiPath Action Center.
- Execution Pause: The agent process enters a “suspended” state, freeing up robot resources while waiting for human input.
- Resumption: Once the user completes the action (e.g., approving a budget or correcting an extraction), the agent resumes exactly where it left off.
Licensing and Consumption (2026 Model)
Usage is governed by a consumption-based model involving Agent Units or Platform Units.
- LLM Calls: 1 LLM call typically consumes 0.2 Platform/Agent Units.
- Execution Time: Agent runs are measured in 5-minute increments. A run under 5 minutes equals 1 execution unit.
- Trial/Community: Community users often receive a daily allotment (e.g., 250–350 LLM calls) to facilitate development and testing.
Note: Context Grounding queries and specific high-tier LLM models may be charged at different rates. Always refer to the Consumables tab in your Automation Cloud Admin portal for real-time tracking.
Coded Agents vs. Traditional RPA and Low-Code Agents
| Capability | Traditional RPA | Low-Code Agents | Coded Agents |
|---|---|---|---|
| Skill Level | Beginner-friendly | Intermediate | Advanced (coding) |
| AI Reasoning | Limited | Basic | Advanced |
| Integration Flexibility | Low | Medium | High |
| Custom Logic | Low | Medium | Full |
| Governance | Yes | Yes | Yes |
Typical Use Cases
1. Conversational Bot Controllers
A coded agent interprets natural language and triggers RPA jobs accordingly — e.g., “Start invoice processing bot.”
2. Intelligent Document Retrieval
Agents using LlamaIndex can turn unstructured document collections into intelligent search assistants within workflows.
3. End-to-End Workflow Planners
Agents can orchestrate multi-step processes across systems — from CRM updates and data validation to email responses.
4. AI-Driven Case Management and Ticket Routing
Define custom logic to classify, respond, escalate, or route service tickets based on AI reasoning.
## Troubleshooting and Support
- SDK-Level Issues: Errors regarding the Python library itself (e.g.,
uipath-python) should be reported via the respective GitHub Repository. - Platform/Runtime Issues: Issues with Orchestrator deployment, Serverless Robot execution, or licensing should be handled through UiPath Official Support.
Build LangGraph-Powered AI Agents in UiPath
This video provides a deep dive into how developers can use the Python SDK to build and deploy intelligent agents within the UiPath ecosystem.
