<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	 xmlns:media="http://search.yahoo.com/mrss/" xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" xmlns:media="http://search.yahoo.com/mrss/"
>

<channel>
	<title>RPABOTS.WORLD</title>
	<atom:link href="https://rpabotsworld.com/tag/uipath-coded-agents/feed/" rel="self" type="application/rss+xml" />
	<link>https://rpabotsworld.com</link>
	<description>RPA, Agentic AI &amp; Intelligent Automation — Tutorials, Tools &amp; Career Guides</description>
	<lastBuildDate>Fri, 30 Oct 2026 02:53:46 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.4</generator>
	<itunes:subtitle>RPABOTS.WORLD</itunes:subtitle>
	<itunes:summary>RPA, Agentic AI &amp; Intelligent Automation — Tutorials, Tools &amp; Career Guides</itunes:summary>
	<itunes:explicit>clean</itunes:explicit>
	<item>
		<title>How to Build and Deploy a LangGraph Agent on UiPath: The Complete Coded Agent Tutorial (2026)</title>
		<link>https://rpabotsworld.com/build-deploy-langgraph-agent-uipath/</link>
					<comments>https://rpabotsworld.com/build-deploy-langgraph-agent-uipath/#comments</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Tue, 14 Jul 2026 02:19:32 +0000</pubDate>
				<category><![CDATA[RPA & Bot Automation]]></category>
		<category><![CDATA[UiPath]]></category>
		<category><![CDATA[uipath tutorial]]></category>
		<category><![CDATA[LangGraph]]></category>
		<category><![CDATA[UiPath Coded Agents]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=32161</guid>

					<description><![CDATA[In the first four months of 2025, U.S. Customs and Border Protection completed 200 import compliance audits and recovered $134 million in underpaid duties — a 67% jump in audit activity over the same period in 2024. Misclassification is the single largest driver of those penalties, accounting for roughly 42% of all CBP assessments. Ford [&#8230;]]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">In the first four months of 2025, U.S. Customs and Border Protection completed 200 import compliance audits and recovered $134 million in underpaid duties — a 67% jump in audit activity over the same period in 2024. Misclassification is the single largest driver of those penalties, accounting for roughly 42% of all CBP assessments. Ford Motor Company found out how expensive a wrong code can get: a $365 million settlement over the misclassification of around 162,000 cargo vans. In July 2025, a federal court upheld a separate $26 million jury verdict against an importer over false customs statements. (<a href="https://steinshostak.com/harmonized-tariff-schedule-hts-codes-explained-how-misclassification-can-cost-you-thousands/" rel="nofollow noopener" target="_blank">Steinshostak</a>, <a href="https://customsandinternationaltradelaw.com/2026/07/10/htsus-classification-reasonable-care-importers/" rel="nofollow noopener" target="_blank">Customs &amp; International Trade Law Blog</a>)</p>



<p class="wp-block-paragraph">Underneath every one of those numbers is the same bottleneck: a human — or a spreadsheet full of &#8220;best guess&#8221; codes — trying to match a product description against a 99-chapter tariff schedule that changes constantly, without perfect memory of a decade of prior rulings and without a paper trail that would survive an audit.</p>



<p class="wp-block-paragraph">That&#8217;s a textbook agentic AI problem: unstructured input, a huge reference corpus, a judgment call, and a real cost to getting it wrong. It&#8217;s also a textbook argument for <em>not</em> running that agent as a bare Python script. A classification agent making real customs decisions needs an audit trail, a way for a compliance officer to intervene before a bad classification goes out the door, and a deployment target your IT and compliance teams can actually govern.</p>



<p class="wp-block-paragraph">This guide walks through exactly that: building a tariff (HTS) classification agent with <strong>LangGraph</strong> for the reasoning logic, and the <strong>UiPath Python SDK</strong> (<code>uipath-langchain</code>) to give it retrieval over your own classification corpus, a human-in-the-loop escalation path, and a governed home in UiPath Orchestrator. The same pattern — classify, score confidence, escalate below a threshold, log everything — applies directly to invoice coding, ticket triage, KYC review, or any other classification workflow you&#8217;re running today.</p>



<p class="wp-block-paragraph">If you&#8217;re newer to LangGraph itself, our <a href="https://rpabotsworld.com/langgraph-interview-questions/">250 LangGraph interview questions guide</a> is a good primer on the concepts referenced here (StateGraph, checkpointing, conditional edges) before you dive into the build.</p>



<figure class="wp-block-image size-full"><img fetchpriority="high" decoding="async" width="1920" height="1072" src="https://rpabotsworld.com/wp-content/uploads/2026/07/Gemini_Generated_Image_5fanjz5fanjz5fan.jpg" alt="How to Build and Deploy a LangGraph Agent on UiPath: The Complete Coded Agent Tutorial (2026) 1" class="wp-image-32162" title="How to Build and Deploy a LangGraph Agent on UiPath: The Complete Coded Agent Tutorial (2026) 1"></figure>



<h2 class="wp-block-heading">Why LangGraph + UiPath, Not LangGraph Alone</h2>



<p class="wp-block-paragraph">LangGraph is the reasoning engine: it models your agent as a state machine — nodes that do work, edges that decide what happens next, and a shared state object that flows between them. That&#8217;s the right abstraction for a classification workflow with a confidence gate and a human review branch. But LangGraph doesn&#8217;t ship an opinion on how you authenticate to your company&#8217;s identity provider, where you store the corpus the agent retrieves from, who&#8217;s allowed to approve an escalated classification, or how you prove to an auditor what the agent did and why.</p>



<p class="wp-block-paragraph">That&#8217;s the gap <code>uipath-langchain</code> closes. It&#8217;s an open-source Python package, maintained by UiPath, that wraps a LangGraph project with:</p>



<ul class="wp-block-list">
<li><strong><code>ContextGroundingRetriever</code></strong> — a LangChain-compatible retriever backed by UiPath&#8217;s Context Grounding (RAG) service, so your agent can search an indexed corpus (in our case, HTS chapter notes and prior rulings) without you standing up a vector database.</li>



<li><strong>Human-in-the-loop primitives</strong> (<code>CreateTask</code>, <code>WaitTask</code>, <code>CreateEscalation</code>, <code>interrupt</code>) that pause a running graph, open a task in UiPath Action Center, and resume the graph with the reviewer&#8217;s decision once it&#8217;s actioned.</li>



<li><strong>A CLI</strong> (<code>uipath</code>) that packages the graph, publishes it to UiPath Automation Cloud as a versioned process, and lets you invoke, monitor, and trace runs from Orchestrator.</li>



<li><strong>Governance for free</strong>: every run is traced, every package is versioned, every human decision is logged against the job, and access is controlled through the same identity and folder permissions your RPA processes already use.</li>
</ul>



<p class="wp-block-paragraph">This is the same &#8220;harness vs. raw prompt-and-hope&#8221; argument we made in <a href="https://rpabotsworld.com/agent-harness-vs-context-engineering-the-next-evolution-of-ai-agent-architecture-with-langgraph/">Agent Harness vs. Context Engineering</a> — LangGraph gives you the graph, UiPath gives you the harness it runs inside. And the harness matters more than it sounds: LangChain&#8217;s own 2025 State of Agent Engineering survey found that 57.3% of organizations already have agents in production, with quality named as the top blocker (cited by roughly a third of respondents) and security close behind for large enterprises (24.9%). Only 62% of teams have detailed step-by-step tracing of what their agents actually did. (<a href="https://www.langchain.com/state-of-agent-engineering" rel="nofollow noopener" target="_blank">LangChain, State of Agent Engineering 2025</a>) A deployment target that gives you tracing, versioning, and human review by default directly addresses the two biggest reasons agent projects stall — a pattern we cover in more depth in <a href="https://rpabotsworld.com/why-agentic-automation-fails/">16 Reasons Why Agentic Automation Programs Fail</a>.</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th></th><th>Raw LangGraph (self-hosted)</th><th>LangGraph + UiPath (<code>uipath-langchain</code>)</th></tr></thead><tbody><tr><td>Reasoning / graph logic</td><td>Yes</td><td>Yes — unchanged, it&#8217;s still your LangGraph code</td></tr><tr><td>RAG over internal documents</td><td>Bring your own vector store</td><td><code>ContextGroundingRetriever</code> over Context Grounding indexes</td></tr><tr><td>Human-in-the-loop review</td><td>Build your own approval UI</td><td>Action Center tasks via <code>interrupt()</code></td></tr><tr><td>Auth to internal systems</td><td>Custom per integration</td><td>UiPath connections + Integration Service</td></tr><tr><td>Versioned deployment</td><td>Your own CI/CD + hosting</td><td><code>uipath pack</code> / <code>uipath publish</code> → Orchestrator</td></tr><tr><td>Execution trail for audit</td><td>You build it</td><td>Built-in tracing per job, per node</td></tr><tr><td>Trigger patterns</td><td>You build queue/schedule logic</td><td>Orchestrator queues, triggers, or embed in a Maestro flow</td></tr></tbody></table></figure>



<h2 class="wp-block-heading">Architecture: The HTS Classification Agent</h2>



<p class="wp-block-paragraph">The agent takes a product description (and optionally a declared value or country of origin), searches an indexed corpus of HTS chapter notes and prior classification rulings, proposes a 10-digit HTS code with a confidence score, and routes based on that score:</p>



<ul class="wp-block-list">
<li><strong>High confidence</strong> → the code is attached to the shipment record automatically.</li>



<li><strong>Below the threshold</strong> → the agent opens an Action Center task for a licensed customs broker or trade compliance officer, waits for their decision, and only then finalizes the record — with the human&#8217;s decision captured against the job for audit purposes.</li>
</ul>



<pre class="wp-block-code"><code>graph TD
    A&#91;START] --&gt; B&#91;prepare_input]
    B --&gt; C&#91;classify: LLM + HTS retriever tool]
    C --&gt; D{confidence &gt;= 0.85?}
    D -- yes --&gt; E&#91;finalize: auto-approved]
    D -- no --&gt; F&#91;escalate: interrupt + CreateTask]
    F --&gt; G&#91;Action Center: compliance officer review]
    G --&gt; H&#91;resume: apply human decision]
    H --&gt; E
    E --&gt; I&#91;END]
</code></pre>



<p class="wp-block-paragraph">This is structurally the same pattern as UiPath&#8217;s own official <a href="https://github.com/UiPath/uipath-langchain-python/tree/main/samples/ticket-classification" rel="nofollow noopener" target="_blank">ticket-classification sample</a>: classify with a structured output, branch on a confidence field, and use <code>interrupt(CreateTask(...))</code> to hand off to a human when the model isn&#8217;t sure. We&#8217;re adapting that exact pattern to tariff classification, but it generalizes to any &#8220;classify, then escalate low-confidence cases&#8221; workflow.</p>



<h2 class="wp-block-heading">Prerequisites</h2>



<ul class="wp-block-list">
<li>Python 3.11 or later, plus <code>pip</code> or <code>uv</code> (UiPath&#8217;s docs recommend <code>uv</code>)</li>



<li>A UiPath Automation Cloud account with Orchestrator access and permission to publish processes</li>



<li>An LLM provider — by default the agent uses UiPath&#8217;s LLM Gateway (no separate API key needed); you can point it at Anthropic or OpenAI instead if you prefer</li>



<li>An HTS reference corpus (chapter notes, prior ruling letters, your internal classification guide) uploaded to a UiPath Storage Bucket and indexed as a <strong>Context Grounding</strong> index in Orchestrator — this is what the agent retrieves against</li>



<li>A UiPath <strong>Action Center</strong> app for the human review step (a simple form with the proposed code, confidence, and an approve/override field is enough to start)</li>
</ul>



<h2 class="wp-block-heading">Step 1: Scaffold the Project</h2>



<pre class="wp-block-code"><code>mkdir hts-classifier &amp;&amp; cd hts-classifier
uv init . --python 3.11
uv venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate
uv add uipath-langchain
uipath -lv   # confirms uipath-langchain is installed
</code></pre>



<p class="wp-block-paragraph">Generate the starting project:</p>



<pre class="wp-block-code"><code>uipath new hts-classifier
</code></pre>



<p class="wp-block-paragraph">This creates <code>main.py</code> (your LangGraph agent code), <code>langgraph.json</code> (LangGraph&#8217;s own config, pointing at your graph), and <code>pyproject.toml</code> (project metadata and dependencies). (<a href="https://uipath.github.io/uipath-python/langchain/quick_start/" rel="nofollow noopener" target="_blank">UiPath SDK, Quickstart</a>)</p>



<h2 class="wp-block-heading">Step 2: Write the Graph</h2>



<p class="wp-block-paragraph">Replace the generated <code>main.py</code> with the classification graph. This follows the same shape as UiPath&#8217;s official ticket-classification sample — <code>StateGraph</code>, a Pydantic input/output contract, a classify node, a confidence-gated conditional edge, and an <code>interrupt</code>-based escalation node — retargeted to HTS codes and wired to a <code>ContextGroundingRetriever</code> for the tariff corpus:</p>



<pre class="wp-block-code"><code>import logging
from typing import Literal, Optional

from langchain_core.messages import HumanMessage, SystemMessage
from langchain_core.output_parsers import PydanticOutputParser
from langchain_core.tools.retriever import create_retriever_tool
from langgraph.graph import START, END, StateGraph, MessagesState
from langgraph.types import Command, interrupt
from pydantic import BaseModel, Field

from uipath.platform import UiPath
from uipath.platform.common import CreateTask
from uipath_langchain.retrievers import ContextGroundingRetriever
from uipath_langchain.chat.models import UiPathAzureChatOpenAI

logger = logging.getLogger(__name__)
uipath = UiPath()

# --- Contracts -------------------------------------------------------------

class GraphInput(BaseModel):
    product_description: str
    declared_value_usd: Optional&#91;float] = None
    country_of_origin: Optional&#91;str] = None
    assignee: Optional&#91;str] = None  # compliance officer to notify if escalated

class GraphOutput(BaseModel):
    hts_code: str
    confidence: float
    auto_approved: bool

class GraphState(MessagesState):
    product_description: str
    declared_value_usd: Optional&#91;float]
    country_of_origin: Optional&#91;str]
    assignee: Optional&#91;str]
    hts_code: Optional&#91;str] = None
    confidence: Optional&#91;float] = None
    human_approval: Optional&#91;bool] = None

class HTSClassification(BaseModel):
    hts_code: str = Field(description="Proposed 10-digit HTS code, e.g. 8517.13.0000")
    rationale: str = Field(description="Short justification citing the retrieved chapter notes")
    confidence: float = Field(ge=0.0, le=1.0)

CONFIDENCE_THRESHOLD = 0.85

output_parser = PydanticOutputParser(pydantic_object=HTSClassification)

# --- RAG tool over the indexed HTS corpus -----------------------------------

retriever = ContextGroundingRetriever(index_name="HTS Reference Corpus")
hts_lookup_tool = create_retriever_tool(
    retriever,
    "search_hts_reference",
    "Search HTS chapter notes and prior classification rulings for the "
    "product category being classified. Use a specific query — e.g. the "
    "product type and key material or function — and cite what you find.",
)

# --- Nodes -------------------------------------------------------------------

def prepare_input(graph_input: GraphInput) -&gt; GraphState:
    system_message = (
        "You are a licensed customs classification assistant. Given a product "
        "description, search the HTS reference corpus, then propose a 10-digit "
        "HTS code with a rationale and a confidence score.\n\n"
        f"{output_parser.get_format_instructions()}"
    )
    return GraphState(
        product_description=graph_input.product_description,
        declared_value_usd=graph_input.declared_value_usd,
        country_of_origin=graph_input.country_of_origin,
        assignee=graph_input.assignee,
        messages=&#91;
            SystemMessage(content=system_message),
            HumanMessage(content=graph_input.product_description),
        ],
    )

async def classify(state: GraphState) -&gt; Command:
    llm = UiPathAzureChatOpenAI(model="gpt-4.1-mini-2025-04-14", temperature=0)
    llm_with_tools = llm.bind_tools(&#91;hts_lookup_tool])
    chain = llm_with_tools | output_parser
    try:
        result = await chain.ainvoke(state&#91;"messages"])
        logger.info(f"Proposed HTS {result.hts_code} at confidence {result.confidence}")
        return Command(update={"hts_code": result.hts_code, "confidence": result.confidence})
    except Exception as e:
        logger.error(f"Classification failed: {e}")
        return Command(update={"hts_code": None, "confidence": 0.0})

def route_on_confidence(state: GraphState) -&gt; Literal&#91;"finalize", "escalate"]:
    if state&#91;"confidence"] is not None and state&#91;"confidence"] &gt;= CONFIDENCE_THRESHOLD:
        return "finalize"
    return "escalate"

async def escalate(state: GraphState) -&gt; Command:
    task_output = interrupt(
        CreateTask(
            app_name="hts_classification_review_app",
            title=f"Review HTS classification: {state&#91;'product_description']&#91;:60]}",
            data={
                "ProductDescription": state&#91;"product_description"],
                "ProposedCode": state&#91;"hts_code"],
                "Confidence": state&#91;"confidence"],
            },
            assignee=state.get("assignee"),
            app_folder_path="Trade Compliance",
        )
    )
    return Command(
        update={
            "human_approval": True,
            "hts_code": task_output.get("CorrectedCode", state&#91;"hts_code"]),
        }
    )

async def finalize(state: GraphState) -&gt; GraphOutput:
    return GraphOutput(
        hts_code=state&#91;"hts_code"],
        confidence=state&#91;"confidence"],
        auto_approved=state.get("human_approval") is None,
    )

# --- Graph -------------------------------------------------------------------

builder = StateGraph(GraphState, input=GraphInput, output=GraphOutput)
builder.add_node("prepare_input", prepare_input)
builder.add_node("classify", classify)
builder.add_node("escalate", escalate)
builder.add_node("finalize", finalize)

builder.add_edge(START, "prepare_input")
builder.add_edge("prepare_input", "classify")
builder.add_conditional_edges("classify", route_on_confidence)
builder.add_edge("escalate", "finalize")
builder.add_edge("finalize", END)

from langgraph.checkpoint.memory import MemorySaver

graph = builder.compile(checkpointer=MemorySaver())
</code></pre>



<p class="wp-block-paragraph">A few things worth calling out:</p>



<ul class="wp-block-list">
<li><strong><code>ContextGroundingRetriever</code></strong> is doing the same job a self-hosted Pinecone or Chroma store would, except the index lives in Orchestrator, gets its documents from a Storage Bucket, and inherits your folder permissions — no separate vector DB to secure or pay for. UiPath&#8217;s own docs use almost this exact scenario as their example query: <em>&#8220;What is the ECCN for a laptop?&#8221;</em> — an export-control classification lookup structurally identical to HTS classification. (<a href="https://uipath.github.io/uipath-python/langchain/context_grounding/" rel="nofollow noopener" target="_blank">UiPath SDK, Context Grounding</a>)</li>



<li><strong><code>interrupt(CreateTask(...))</code></strong> is the human-in-the-loop primitive. It suspends the graph, opens a task against a UiPath Action Center app, and — critically — the graph doesn&#8217;t resume until a human actions it. The state persists via the checkpointer in the meantime, so this can be minutes or days.</li>



<li>The <strong>confidence threshold</strong> (<code>0.85</code> here) is a business decision, not a technical one. Set it with your compliance team, and expect to tune it after your first evaluation run (Step 5).</li>
</ul>



<h2 class="wp-block-heading">Step 3: Authenticate and Initialize</h2>



<pre class="wp-block-code"><code>uipath auth
</code></pre>



<p class="wp-block-paragraph">This opens a browser for OAuth login and lets you select the target tenant. For CI/CD pipelines, use unattended auth instead with a Confidential External Application&#8217;s client ID and secret:</p>



<pre class="wp-block-code"><code>uipath auth --client-id &lt;id&gt; --client-secret '&lt;secret&gt;' \
  --base-url https://cloud.uipath.com/&lt;org&gt;/&lt;tenant&gt;
</code></pre>



<p class="wp-block-paragraph">Then initialize the project:</p>



<pre class="wp-block-code"><code>uipath init
</code></pre>



<p class="wp-block-paragraph"><code>uipath init</code> generates the metadata UiPath needs to deploy the graph: <code>uipath.json</code> (entry points and the project&#8217;s stable GUID — never hand-edit this ID once it exists, or you&#8217;ll orphan your deployment history), <code>bindings.json</code> (overridable references to the resources your code calls — the Context Grounding index and Action Center app in this case), <code>entry-points.json</code> (the input/output schema, derived from your Pydantic models), and a <code>.mermaid</code> diagram of the graph for the Orchestrator UI. Re-run <code>uipath init</code> any time you change the graph&#8217;s input/output schema or add a new SDK resource call. (<a href="https://uipath.github.io/uipath-python/cli/" rel="nofollow noopener" target="_blank">UiPath SDK, CLI Reference</a>)</p>



<h2 class="wp-block-heading">Step 4: Run and Debug Locally</h2>



<pre class="wp-block-code"><code>uipath run agent '{"product_description": "Wireless noise-cancelling over-ear headphones with active Bluetooth 5.3, retail packaged"}'
</code></pre>



<p class="wp-block-paragraph">For step-through debugging with breakpoints per node:</p>



<pre class="wp-block-code"><code>uipath debug agent '{"product_description": "..."}'
# commands: c (continue), s (step), b &lt;node&gt; (breakpoint), l (list), q (quit)
</code></pre>



<p class="wp-block-paragraph"><code>debug</code> is genuinely useful here — you can set a breakpoint on <code>classify</code>, inspect exactly what the retriever returned before the LLM call, and confirm the model is actually grounding on your chapter notes rather than guessing.</p>



<h2 class="wp-block-heading">Step 5: Evaluate Before You Ship</h2>



<p class="wp-block-paragraph">Don&#8217;t skip this step for a compliance-facing agent. Build a small evaluation set of product descriptions with known-correct HTS codes (your compliance team almost certainly already has a list of tricky historical cases) and run:</p>



<pre class="wp-block-code"><code>uipath eval
</code></pre>



<p class="wp-block-paragraph"><code>uipath eval</code> auto-discovers your entry point and eval set, runs each case, and scores it against evaluators like <code>LLM Judge Output</code>, <code>Tool Call Order</code>, and <code>Tool Call Count</code> — useful for confirming the agent is actually calling <code>search_hts_reference</code> before proposing a code, not skipping straight to a guess. Results report back to UiPath if <code>UIPATH_PROJECT_ID</code> is set, so your eval history is versioned alongside the agent. (<a href="https://uipath.github.io/uipath-python/cli/" rel="nofollow noopener" target="_blank">UiPath SDK, CLI Reference</a>) This is also where you calibrate the confidence threshold from Step 2 — if your eval set shows the model is overconfident on a certain product category, tighten the gate for that case before it reaches production.</p>



<h2 class="wp-block-heading">Step 6: Package and Deploy</h2>



<pre class="wp-block-code"><code>uipath pack
uipath publish --my-workspace
</code></pre>



<p class="wp-block-paragraph"><code>uipath pack</code> builds a <code>.nupkg</code> containing your <code>.py</code>, <code>.json</code>, <code>.yaml</code>, and <code>.md</code> files (plus <code>uv.lock</code> by default, so the executor installs the exact dependency versions you tested with — use <code>--nolock</code> only if you deliberately want floating versions). <code>uipath publish</code> pushes the most recent package to a feed; <code>--my-workspace</code> auto-creates a runnable process for testing, <code>--tenant</code> (or <code>--folder</code>) publishes to a shared Orchestrator feed for team or production use. <code>uipath deploy</code> does both steps in one command. (<a href="https://uipath.github.io/uipath-python/cli/" rel="nofollow noopener" target="_blank">UiPath SDK, CLI Reference</a>)</p>



<p class="wp-block-paragraph">After publishing, Orchestrator gives you a process configuration link — use it to set environment variables and confirm the <code>bindings.json</code> resources (your Context Grounding index, your Action Center app) resolve to the right folder in this environment. This is the point where a dev-environment agent becomes a production one without touching code: swap the binding, not the source.</p>



<p class="wp-block-paragraph">Invoke it in the cloud the same way you ran it locally:</p>



<pre class="wp-block-code"><code>uipath invoke agent '{"product_description": "..."}'
</code></pre>



<p class="wp-block-paragraph">This starts a real Orchestrator job and gives you a monitoring link with full node-by-node tracing — the exact retrieval results, the exact prompt, the exact confidence score, and (if it escalated) the Action Center task and the reviewer&#8217;s decision, all attached to that job.</p>



<figure class="wp-block-image size-large"><img decoding="async" width="1024" height="1024" src="https://rpabotsworld.com/wp-content/uploads/2026/07/Gemini_Generated_Image_up3trqup3trqup3t-1024x1024.jpg" alt="How to Build and Deploy a LangGraph Agent on UiPath: The Complete Coded Agent Tutorial (2026) 2" class="wp-image-32163" title="How to Build and Deploy a LangGraph Agent on UiPath: The Complete Coded Agent Tutorial (2026) 2"></figure>



<h2 class="wp-block-heading">Wiring It Into Production</h2>



<p class="wp-block-paragraph">A one-off <code>invoke</code> call is fine for testing; production traffic needs a trigger. Three patterns cover most cases:</p>



<ul class="wp-block-list">
<li><strong>Orchestrator queue trigger</strong> — each new SKU or shipment line lands in a queue item, which invokes the agent per item. This is the natural fit for classification workloads and gives you built-in retry and SLA tracking.</li>



<li><strong>Scheduled batch</strong> — run against a day&#8217;s or hour&#8217;s backlog of unclassified items on a schedule, useful when you don&#8217;t need per-item latency.</li>



<li><strong>Embedded in a flow or as a tool for another agent</strong> — the coded agent can be called from a Maestro flow (see our <a href="https://rpabotsworld.com/uipath-maestro-case-the-complete-step-by-step-tutorial/">UiPath Maestro Case tutorial</a> for the orchestration layer around agents) or invoked as a sub-process from another agent via <code>InvokeProcess</code>, which is exactly how you&#8217;d chain this into a broader import-compliance pipeline that also validates country-of-origin documentation or screens against restricted-party lists.</li>
</ul>



<h2 class="wp-block-heading">Production Considerations</h2>



<p class="wp-block-paragraph"><strong>Guardrails.</strong> Add PII and harmful-content middleware on the classify node before this touches real shipment data — see UiPath&#8217;s <a href="https://uipath.github.io/uipath-python/langchain/guardrails/" rel="nofollow noopener" target="_blank">guardrails documentation</a> for the decorator and middleware patterns.</p>



<p class="wp-block-paragraph"><strong>Security.</strong> Use unattended client-credentials auth with scoped OAuth permissions (<code>OR.Execution</code>, plus whatever queue or asset scopes you actually need) for any CI/CD pipeline — never embed interactive-login credentials in automation. Security is already the second-largest blocker large enterprises report for agent projects, behind quality. (<a href="https://www.langchain.com/state-of-agent-engineering" rel="nofollow noopener" target="_blank">LangChain, State of Agent Engineering 2025</a>)</p>



<p class="wp-block-paragraph"><strong>Observability.</strong> Every job is traced by default, but pull <code>--trace-file</code> output into your existing observability stack if you have one — only 62% of teams surveyed have detailed step-level tracing today, and that gap is a top reason agents get pulled back out of production after launch. Our <a href="https://rpabotsworld.com/agent-quality-evaluation-llm-as-judge-langsmith/">Agent Quality &amp; Evaluation guide</a> covers building this out further with LLM-as-judge scoring.</p>



<p class="wp-block-paragraph"><strong>Cost and latency.</strong> Structured-output classification with a retrieval step typically runs a few seconds per item on a small-to-mid model; batch low-priority volume on a schedule rather than real-time if your SLA allows it, and reserve real-time invocation for the shipments actually blocking a release.</p>



<p class="wp-block-paragraph"><strong>Memory across runs.</strong> <code>MemorySaver</code> in this example is fine for local testing, but for a long-running production agent that needs to recall prior classifications for similar products, see our <a href="https://rpabotsworld.com/agent-memory-and-rag/">Agent Memory and RAG guide</a> on persistent, queryable agent memory.</p>



<h2 class="wp-block-heading">Common Mistakes</h2>



<ul class="wp-block-list">
<li><strong>Skipping <code>uipath init</code> after changing the schema.</strong> If you add a field to <code>GraphInput</code> and forget to re-run <code>init</code>, <code>entry-points.json</code> goes stale and the next deploy ships the old contract.</li>



<li><strong>Hand-editing the <code>id</code> in <code>uipath.json</code>.</strong> It&#8217;s a stable GUID minted on first <code>init</code>. Changing it disconnects the project from its publish history — UiPath will treat it as brand new.</li>



<li><strong>No confidence threshold tuning.</strong> A model that&#8217;s &#8220;usually right&#8221; without a calibrated escalation gate is exactly how a $365 million misclassification settlement happens. Set the threshold from real eval data, not a guess.</li>



<li><strong>Treating <code>interrupt</code> as fire-and-forget.</strong> The graph genuinely pauses — build your Action Center app and test the resume path before you trust it in production; an untested escalation path is worse than no escalation path, because it creates false confidence.</li>
</ul>



<h2 class="wp-block-heading">Key Takeaways</h2>



<ul class="wp-block-list">
<li>LangGraph supplies the reasoning graph; <code>uipath-langchain</code> supplies the enterprise harness — RAG via Context Grounding, human-in-the-loop via Action Center, and governed deployment via Orchestrator.</li>



<li>The core lifecycle is five commands: <code>uipath new</code> → <code>uipath init</code> → <code>uipath run</code>/<code>uipath debug</code> → <code>uipath eval</code> → <code>uipath pack</code> + <code>uipath publish</code> (or <code>uipath deploy</code> for both).</li>



<li>Confidence-gated escalation (<code>interrupt(CreateTask(...))</code>) is the pattern to reach for any time a wrong automated decision has real cost — tariff codes, invoice coding, KYC, ticket routing.</li>



<li>Evaluate before you deploy: <code>uipath eval</code> scores your agent against a real test set and reports results back to UiPath, so quality is tracked, not assumed.</li>



<li>Bindings, not code changes, move an agent from dev to production — swap the Context Grounding index or Action Center app reference per environment.</li>
</ul>



<h2 class="wp-block-heading">FAQs</h2>



<p class="wp-block-paragraph"><strong>Do I need to know UiPath&#8217;s low-code tools to build a coded agent?</strong> No. Coded agents are pure Python/LangGraph; UiPath&#8217;s low-code Agent Builder is a separate, prompt-configured path for teams that don&#8217;t want to write code. They can call each other, but you don&#8217;t need Studio Web skills to follow this guide.</p>



<p class="wp-block-paragraph"><strong>Can I use Anthropic or OpenAI directly instead of UiPath&#8217;s LLM Gateway?</strong> Yes — set the appropriate API key as an environment variable and configure the chat model accordingly; UiPath&#8217;s LLM Gateway is the default because it avoids managing separate provider keys, not a requirement.</p>



<p class="wp-block-paragraph"><strong>What happens if nobody actions the escalated task?</strong> The graph stays suspended (state is held by the checkpointer) until the task is actioned — build SLA reminders into your Action Center app or wrap the wait in a timeout pattern if indefinite suspension isn&#8217;t acceptable for your workflow.</p>



<p class="wp-block-paragraph"><strong>Is this the same thing as a UiPath &#8220;low-code agent&#8221;?</strong> No. Low-code agents are configured through <code>agent.json</code> and Agent Builder without Python. This guide covers coded agents, which give you full programmatic control over the graph — the right choice when your logic (like a confidence-gated classification pipeline) doesn&#8217;t fit a prompt-and-tools template.</p>



<p class="wp-block-paragraph"><strong>How is this different from just using LangGraph&#8217;s own deployment platform?</strong> LangGraph Platform is a fine choice if you don&#8217;t need to plug into existing enterprise identity, RPA processes, or human-review workflows. <code>uipath-langchain</code> is the right choice when the agent needs to sit alongside RPA jobs, Action Center approvals, and Orchestrator&#8217;s existing governance — which is the common case in regulated, compliance-heavy workflows like trade classification.</p>



<h2 class="wp-block-heading">References</h2>



<ul class="wp-block-list">
<li>U.S. Customs enforcement data and Ford settlement — <a href="https://steinshostak.com/harmonized-tariff-schedule-hts-codes-explained-how-misclassification-can-cost-you-thousands/" rel="nofollow noopener" target="_blank">Steinshostak: HTS Codes Explained</a></li>



<li>July 2025 $26M misclassification verdict — <a href="https://customsandinternationaltradelaw.com/2026/07/10/htsus-classification-reasonable-care-importers/" rel="nofollow noopener" target="_blank">Customs &amp; International Trade Law Blog, July 2026</a></li>



<li>LangChain State of Agent Engineering 2025 (production adoption, top blockers, tracing coverage) — <a href="https://www.langchain.com/state-of-agent-engineering" rel="nofollow noopener" target="_blank">langchain.com/state-of-agent-engineering</a></li>



<li>UiPath LangChain SDK Quickstart — <a href="https://uipath.github.io/uipath-python/langchain/quick_start/" rel="nofollow noopener" target="_blank">uipath.github.io/uipath-python/langchain/quick_start</a></li>



<li>UiPath SDK CLI Reference — <a href="https://uipath.github.io/uipath-python/cli/" rel="nofollow noopener" target="_blank">uipath.github.io/uipath-python/cli</a></li>



<li>UiPath Context Grounding (RAG) for LangChain — <a href="https://uipath.github.io/uipath-python/langchain/context_grounding/" rel="nofollow noopener" target="_blank">uipath.github.io/uipath-python/langchain/context_grounding</a></li>



<li>UiPath Human-in-the-Loop reference (<code>interrupt</code>, <code>CreateTask</code>) — <a href="https://uipath.github.io/uipath-python/langchain/human_in_the_loop/" rel="nofollow noopener" target="_blank">uipath.github.io/uipath-python/langchain/human_in_the_loop</a></li>



<li>Official ticket-classification sample this pattern is adapted from — <a href="https://github.com/UiPath/uipath-langchain-python/tree/main/samples/ticket-classification" rel="nofollow noopener" target="_blank">GitHub: uipath-langchain-python/samples/ticket-classification</a></li>
</ul>



<p class="wp-block-paragraph"></p>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/build-deploy-langgraph-agent-uipath/feed/</wfw:commentRss>
			<slash:comments>2</slash:comments>
		
		
		<media:thumbnail url="https://rpabotsworld.com/wp-content/uploads/2026/07/Gemini_Generated_Image_l1ueqyl1ueqyl1ue.jpg" />	</item>
		<item>
		<title>Comprehensive Guide to UiPath® Coded Agents</title>
		<link>https://rpabotsworld.com/comprehensive-guide-to-uipath-coded-agents/</link>
					<comments>https://rpabotsworld.com/comprehensive-guide-to-uipath-coded-agents/#respond</comments>
		
		<dc:creator><![CDATA[Satish Prasad]]></dc:creator>
		<pubDate>Mon, 16 Feb 2026 00:05:42 +0000</pubDate>
				<category><![CDATA[Agentic AI & AI Automation]]></category>
		<category><![CDATA[UiPath]]></category>
		<category><![CDATA[UiPath Coded Agents]]></category>
		<guid isPermaLink="false">https://rpabotsworld.com/?p=31943</guid>

					<description><![CDATA[UiPath Coded Agents represent a shift toward &#8220;pro-code&#8221; 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. These agents are designed to interpret, reason, and plan actions—leveraging Large Language Models (LLMs) while remaining fully [&#8230;]]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph"><strong>UiPath Coded Agents</strong> represent a shift toward &#8220;pro-code&#8221; 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 <strong>Integrated Development Environment (IDE)</strong> using Python.</p>



<p class="wp-block-paragraph">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.</p>



<h2 class="wp-block-heading">1. <strong>What Are Coded Agents?</strong></h2>



<p class="wp-block-paragraph"><strong>Coded Agents</strong> are software agents written directly in code (e.g., Python or JavaScript) using supported frameworks, integrated into the <strong>UiPath automation ecosystem</strong>. 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.</p>



<p class="wp-block-paragraph">In simpler terms, think of coded agents as <strong>programmable autonomous workers</strong> that:</p>



<ul class="wp-block-list">
<li>Take goals and context as input,</li>



<li>Reason using AI and external tools,</li>



<li>Act on behalf of users in complex workflows,</li>



<li>Integrate deeply with business systems and automation services.</li>
</ul>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h2 class="wp-block-heading">2. Core Architecture and Capabilities</h2>



<p class="wp-block-paragraph">Coded agents bridge the gap between flexible AI frameworks and rigid enterprise requirements. They are packaged as standard <code>.nupkg</code> files and deployed as processes within Orchestrator folders.</p>



<ul class="wp-block-list">
<li><strong>Logic Control:</strong> Developers have complete control over state management, complex loops, and custom error handling that might be cumbersome in a visual flow.</li>



<li><strong>Seamless Integration:</strong> Using the UiPath SDK, agents can programmatically interact with:
<ul class="wp-block-list">
<li><strong>Assets:</strong> For secure credential and secret management.</li>



<li><strong>Storage Buckets:</strong> For handling unstructured data files.</li>



<li><strong>Data Service:</strong> For structured business data.</li>



<li><strong>Orchestrator Jobs:</strong> To trigger or monitor other RPA processes.</li>
</ul>
</li>



<li><strong>Tracing &amp; Observability:</strong> Native integration with <strong>LangSmith</strong> allows for deep inspection of LLM reasoning paths, ensuring transparency in AI decision-making.</li>
</ul>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading">Supported Frameworks &amp; SDKs</h3>



<p class="wp-block-paragraph">UiPath provides specialized SDKs to accelerate the development of sophisticated multi-agent systems.</p>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><td><strong>Language/Framework</strong></td><td><strong>SDK Package</strong></td><td><strong>Primary Functionality</strong></td></tr></thead><tbody><tr><td><strong>Python</strong></td><td><code>uipath-python</code></td><td>Core CLI for creation, packaging, and platform interaction.</td></tr><tr><td><strong>LangGraph</strong></td><td><code>uipath-langchain-python</code></td><td>Builds stateful, multi-agent workflows with complex decision cycles.</td></tr><tr><td><strong>LlamaIndex</strong></td><td><code>uipath-llamaindex-python</code></td><td>Optimized for RAG (Retrieval-Augmented Generation) and data-heavy workflows.</td></tr></tbody></table></figure>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><strong>Why Coded Agents Are Important</strong></h3>



<h4 class="wp-block-heading"><strong>1. Advanced Customization</strong></h4>



<p class="wp-block-paragraph">With coded agents, developers can embed:</p>



<ul class="wp-block-list">
<li>Complex reasoning,</li>



<li>Domain-specific logic,</li>



<li>Custom memory and planning loops,</li>



<li>Integration with APIs and services beyond UiPath’s built-in activities.</li>
</ul>



<h4 class="wp-block-heading"><strong>2. Enterprise-Ready Deployment</strong></h4>



<p class="wp-block-paragraph">Once built, coded agents are packaged, published, and deployed through <strong>UiPath Orchestrator</strong> just like traditional automations — ensuring scalability, security compliance, monitoring, and scheduling.</p>



<h4 class="wp-block-heading"><strong>3. Unified Governance</strong></h4>



<p class="wp-block-paragraph">Businesses get standardized governance, audit trails, human-in-the-loop approvals, and logging — all essential for regulated industries.</p>



<h3 class="wp-block-heading"><strong>How Coded Agents Work</strong></h3>



<h4 class="wp-block-heading"><strong>1. Developer Creation</strong></h4>



<p class="wp-block-paragraph">Developers write agent logic in their preferred environment (IDE) using supported frameworks like <strong>LangChain</strong>, <strong>LangGraph</strong>, or <strong>LlamaIndex</strong>. This code defines:</p>



<ul class="wp-block-list">
<li>Perception (input handling),</li>



<li>Reasoning (AI decision making),</li>



<li>Action (APIs, workflows, data operations).</li>
</ul>



<h4 class="wp-block-heading"><strong>2. Integration with UiPath SDK</strong></h4>



<p class="wp-block-paragraph">Using the <strong>UiPath SDK</strong>, coded agents connect to platform services, such as:</p>



<ul class="wp-block-list">
<li>Orchestrator APIs,</li>



<li>Context storage (assets, buckets),</li>



<li>LLM gateways and model endpoints.</li>
</ul>



<h4 class="wp-block-heading"><strong>3. Packaging and Deployment</strong></h4>



<p class="wp-block-paragraph">A simple CLI command packages the agent for UiPath’s cloud. Once deployed:</p>



<ul class="wp-block-list">
<li>Agents can be scheduled,</li>



<li>Observed via dashboards,</li>



<li>Governed and approved within enterprise rules.</li>
</ul>



<h3 class="wp-block-heading">Development Lifecycle: From IDE to Orchestrator</h3>



<p class="wp-block-paragraph">The development process for a coded agent mirrors the modern software development lifecycle (SDLC) while retaining the benefits of the UiPath ecosystem.</p>



<ol start="1" class="wp-block-list">
<li><strong>Initialization:</strong> Use the CLI command <code>uipath new &lt;agent_name></code> to generate a project structure. This creates essential files like <code>uipath.json</code> (to expose functions) and <code>requirements.txt</code>.</li>



<li><strong>Logic Development:</strong> Write your Python logic in an IDE (like VS Code). You can utilize the <code>uipath-python</code> SDK to fetch assets or start other jobs.</li>



<li><strong>Authentication:</strong> Authenticate your local environment using <code>uipath auth</code> to link your IDE to your UiPath tenant.</li>



<li><strong>Packaging:</strong> Run <code>uipath pack</code> to compile your code into a <code>.nupkg</code> package.</li>



<li><strong>Deployment:</strong> Run <code>uipath publish</code> to send the package to the Orchestrator feed.</li>



<li><strong>Execution:</strong> In Orchestrator, create a process from the package. It can now be triggered by events, APIs, or schedules.</li>
</ol>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading">Human-in-the-Loop (HITL)</h3>



<p class="wp-block-paragraph">Coded agents are not purely &#8220;black box&#8221; autonomous systems. You can programmatically define <strong>interrupt points</strong> to ensure human oversight:</p>



<ul class="wp-block-list">
<li><strong>Action Center Integration:</strong> When an agent reaches a high-risk decision, it can create a task in the <strong>UiPath Action Center</strong>.</li>



<li><strong>Execution Pause:</strong> The agent process enters a &#8220;suspended&#8221; state, freeing up robot resources while waiting for human input.</li>



<li><strong>Resumption:</strong> Once the user completes the action (e.g., approving a budget or correcting an extraction), the agent resumes exactly where it left off.</li>
</ul>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading">Licensing and Consumption (2026 Model)</h3>



<p class="wp-block-paragraph">Usage is governed by a consumption-based model involving <strong>Agent Units</strong> or <strong>Platform Units</strong>.</p>



<ul class="wp-block-list">
<li><strong>LLM Calls:</strong> 1 LLM call typically consumes <strong>0.2 Platform/Agent Units</strong>.</li>



<li><strong>Execution Time:</strong> Agent runs are measured in 5-minute increments. A run under 5 minutes equals 1 execution unit.</li>



<li><strong>Trial/Community:</strong> Community users often receive a daily allotment (e.g., 250–350 LLM calls) to facilitate development and testing.</li>
</ul>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph"><strong>Note:</strong> Context Grounding queries and specific high-tier LLM models may be charged at different rates. Always refer to the <em>Consumables</em> tab in your Automation Cloud Admin portal for real-time tracking.</p>
</blockquote>



<hr class="wp-block-separator has-alpha-channel-opacity"/>



<h3 class="wp-block-heading"><strong>Coded Agents vs. Traditional RPA and Low-Code Agents</strong></h3>



<figure class="wp-block-table"><table class="has-fixed-layout"><thead><tr><th>Capability</th><th>Traditional RPA</th><th>Low-Code Agents</th><th>Coded Agents</th></tr></thead><tbody><tr><td>Skill Level</td><td>Beginner-friendly</td><td>Intermediate</td><td>Advanced (coding)</td></tr><tr><td>AI Reasoning</td><td>Limited</td><td>Basic</td><td>Advanced</td></tr><tr><td>Integration Flexibility</td><td>Low</td><td>Medium</td><td>High</td></tr><tr><td>Custom Logic</td><td>Low</td><td>Medium</td><td>Full</td></tr><tr><td>Governance</td><td>Yes</td><td>Yes</td><td>Yes</td></tr></tbody></table></figure>



<h4 class="wp-block-heading"><strong>Typical Use Cases</strong></h4>



<h5 class="wp-block-heading"><strong>1. Conversational Bot Controllers</strong></h5>



<p class="wp-block-paragraph">A coded agent interprets natural language and triggers RPA jobs accordingly — e.g., “Start invoice processing bot.”</p>



<h5 class="wp-block-heading"><strong>2. Intelligent Document Retrieval</strong></h5>



<p class="wp-block-paragraph">Agents using LlamaIndex can turn unstructured document collections into intelligent search assistants within workflows.</p>



<h5 class="wp-block-heading"><strong>3. End-to-End Workflow Planners</strong></h5>



<p class="wp-block-paragraph">Agents can orchestrate multi-step processes across systems — from CRM updates and data validation to email responses.</p>



<h5 class="wp-block-heading"><strong>4. AI-Driven Case Management and Ticket Routing</strong></h5>



<p class="wp-block-paragraph">Define custom logic to classify, respond, escalate, or route service tickets based on AI reasoning.<br></p>



<h3 class="wp-block-heading">## Troubleshooting and Support</h3>



<ul class="wp-block-list">
<li><strong>SDK-Level Issues:</strong> Errors regarding the Python library itself (e.g., <code>uipath-python</code>) should be reported via the respective <strong>GitHub Repository</strong>.</li>



<li><strong>Platform/Runtime Issues:</strong> Issues with Orchestrator deployment, Serverless Robot execution, or licensing should be handled through <strong>UiPath Official Support</strong>.</li>
</ul>



<figure class="wp-block-embed is-type-video is-provider-youtube wp-block-embed-youtube wp-embed-aspect-16-9 wp-has-aspect-ratio"><div class="wp-block-embed__wrapper">
<iframe title="DevDives: Building &amp; shipping UiPath coded agents" width="1240" height="698" src="https://www.youtube.com/embed/saBAZwR5Oa0?feature=oembed&#038;enablejsapi=1" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
</div></figure>



<p class="wp-block-paragraph"><a target="_blank" rel="noreferrer noopener nofollow" href="https://www.youtube.com/watch?v=taZEUwLTqh0">Build LangGraph-Powered AI Agents in UiPath</a></p>



<p class="wp-block-paragraph">This video provides a deep dive into how developers can use the Python SDK to build and deploy intelligent agents within the UiPath ecosystem.</p>



<p class="wp-block-paragraph"></p>
]]></content:encoded>
					
					<wfw:commentRss>https://rpabotsworld.com/comprehensive-guide-to-uipath-coded-agents/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
		<media:content url="https://www.youtube.com/embed/saBAZwR5Oa0" medium="video">
			<media:player url="https://www.youtube.com/embed/saBAZwR5Oa0" />
			<media:title type="plain">UiPath Coded Agents - RPABOTS.WORLD</media:title>
			<media:description type="html"><![CDATA[Enjoy the videos and music that you love, upload original content and share it all with friends, family and the world on YouTube.]]></media:description>
			<media:rating scheme="urn:simple">nonadult</media:rating>
		</media:content>
	</item>
	</channel>
</rss>

<!--
Performance optimized by W3 Total Cache. Learn more: https://www.boldgrid.com/w3-total-cache/?utm_source=w3tc&utm_medium=footer_comment&utm_campaign=free_plugin

Page Caching using Disk: Enhanced 

Served from: rpabotsworld.com @ 2026-11-16 00:18:24 by W3 Total Cache
-->