While designing an agent story for invoice processing, the team identifies multiple decision points where different systems are used.
How should the agent design reflect these decision points?
Minimize explicit decision modeling in the agent and instead trigger system automations sequentially, allowing system responses to implicitly determine the next step.
Decompose each decision point into independent micro-agents aligned to individual systems, without maintaining centralized orchestration logic.
Represent decisions as structured conditional branches within the agent, mapping them to the specific system tools required while preserving traceability and outcome alignment.
Abstract decision points into a generalized reasoning layer within the agent and rely on downstream systems to enforce detailed validation and routing logic.
Option C is the strongest answer because it emphasizes explicit decision modeling, appropriate tool selection, and traceability across an invoice-processing workflow.
An agent story should identify the decisions required to achieve its business objective and the enterprise capabilities needed to execute each outcome.
For example, an invoice-processing solution may evaluate whether a purchase order exists, whether the invoice amount matches an approved order, whether the supplier is authorized, and whether discrepancies require escalation.
Each decision should have a defined result and an associated processing route. The agent can use its reasoning capabilities to interpret unstructured invoice information and call authorized tools for validation, retrieval, or updates.
However, UiPath makes an important architectural distinction: deterministic conditional branches should generally be implemented in workflows or UiPath Maestro rather than embedded as extensive hardcoded branching logic inside an autonomous agent.
Maestro supports BPMN gateways and conditional sequence flows for explicit, auditable process routing.
Option A makes routing implicit and difficult to audit. Option B introduces unnecessary fragmentation without coordinated control. Option D delegates routing decisions to downstream applications, reducing transparency.
Therefore, C is correct in its design intent, provided deterministic process branches are assigned to an appropriate orchestration component.
Official UiPath references/topics: Agents — Best Practices for Building Agents; Maestro Orchestrate — Gateways and Sequence Flows.
Technical qualification: Architecture qualification: Explicit deterministic conditional routing typically belongs in a workflow or Maestro rather than inside an autonomous agent.
In the context of automation, what key capability distinguishes generative AI (GenAI) from agentic AI?
GenAI provides cognitive navigation and adapts to changes when handling complex tasks, whereas agentic AI only performs predefined, quality-gated content generation actions.
GenAI excels in creating new content (text, images, code) from prompts, whereas agentic AI moves beyond creation to planning and executing tasks.
GenAI autonomously triggers workflows and makes decisions through cognitive navigation and in-context reasoning, whereas agentic AI is limited to generating content from prompts.
GenAI can perceive environments and learn over time to act autonomously, while agentic AI cannot.
Option B accurately identifies the distinction between content generation and autonomous, goal-directed execution.
Generative AI primarily creates new content by processing prompts and generating responses such as text, images, software code, summaries, and other information artifacts.
Agentic AI extends these capabilities by incorporating contextual perception, reasoning, planning, tool invocation, and action execution to pursue defined objectives.
UiPath describes agentic AI as technology that enables autonomous agents to make decisions, coordinate activities, and adapt their actions according to changing circumstances.
For example, a generative AI application may draft an email recommending adjustments to a delivery schedule. An agentic automation solution can analyze delivery constraints, determine appropriate changes, invoke scheduling tools, update operational records, and initiate notifications.
This distinction is especially relevant within UiPath's automation architecture, where agents can combine language-model reasoning with robotic process automation, Integration Service activities, APIs, and orchestration components.
However, agentic autonomy does not eliminate governance requirements. Enterprise deployments still need defined permissions, traceability, exception handling, and human oversight when appropriate.
Options A, C, and D reverse or misrepresent the respective capabilities of generative and agentic AI.
Official UiPath references/topics: UiPath — What Is Agentic AI?; What Is Agentic Automation?; Agents and Workflows.
Which of the following accurately describes the recommended workflow mapping exercise to complete before building an agent?
Identify decision points and input/output formats, Include user training planning, Look for structured, predictable flows, Avoid designing agents as a replacement for workflows.
Identify decision points and input/output formats, Look for structured, predictable flows (e.g., ticket triage, compliance checks), Avoid designing agents as a replacement for workflows.
Look for structured, predictable flows, Identify decision points and input/output formats, Add agent UI design steps, Avoid designing agents as a replacement for workflows.
Avoid designing agents as a replacement for workflows, Identify decision points and input/output formats, Add tool selection and deployment steps, Look for structured, predictable flows.
Option B most closely represents UiPath's recommended workflow mapping exercise before agent development.
UiPath emphasizes that effective agents should be embedded within existing business processes rather than designed as unrestricted replacements for complete workflows.
The first responsibility during workflow mapping is identifying the process's decision points and input/output formats. These characteristics establish where business information enters the process, what decisions must be made, and which results downstream components require.
The next activity is identifying processes with clear business objectives but variable or ambiguous inputs. Ticket classification, compliance assessment, and document interpretation are suitable examples when decisions require contextual reasoning.
Predictable, rules-based execution steps should generally remain in conventional RPA workflows or deterministic orchestration components. Agents should be introduced where contextual interpretation, judgment, or adaptive planning adds value.
Finally, the design should preserve the surrounding workflow architecture. The agent operates as a specialized decision-making component, while conventional automation handles repeatable execution and process control.
Options A, C, and D introduce activities such as user training, interface design, and deployment planning. Although these can be necessary elsewhere in the project lifecycle, they are not the core workflow mapping activities specified by UiPath.
Official UiPath references/topics: Agents — Best Practices for Building Agents — Design Agents for Real Workflows.
Technical qualification: Wording qualification: UiPath emphasizes processes with variable or ambiguous inputs; the term “predictable flows†is imprecise.
An agent needs to extract high-confidence data from structured documents and optionally permit human review before continuing.
Which tool configuration meets this need?
Use DeepRAG with citations enabled to automatically correct low-confidence extracted values.
Add a Web Search tool and filter results to validate extracted document fields.
Add an IXP project as a tool and configure a Document Validation Task escalation for human validation of extracted data.
Add the Analyze Files tool and rely on token limits to determine when human validation is required.
Option C precisely describes the documented integration between UiPath Intelligent Xtraction and Processing (IXP) and agent escalations.
UiPath Agents can use published IXP models as tools to extract structured information from business documents.
An IXP project defines the extraction taxonomy, including the fields and field groups that the model identifies. When an agent invokes the IXP tool, the extracted information becomes available for subsequent reasoning or tool operations.
Execution traces can also expose the extraction schema, input attachments, and confidence scores associated with predicted fields.
For scenarios requiring human verification, UiPath provides the Document Validation Station interface through an escalation configured with the Document Validation Task type.
The developer links the escalation to the appropriate IXP tool instance and configures a storage bucket for validation results.
A human reviewer can examine extracted values, review confidence information, and correct inaccurate fields. The validated information is subsequently returned to the agent so processing can continue.
Option A incorrectly treats DeepRAG as a document-extraction correction tool. Option B uses web retrieval instead of document extraction. Option D incorrectly associates human validation decisions with token limits.
Human validation should be triggered according to defined confidence, business-risk, or exception criteria, rather than assuming that every high-confidence extraction is necessarily correct.
Official UiPath references/topics: Agents — IXP: Adding an IXP Project as a Tool and Validation Station Escalation.
What role does the FastMCP("Finance") declaration play in the MCP server setup?
It configures a metadata registry used for automatic tool introspection and remote capability advertisement to connected agents
It instantiates a named MCP application context that serves as a logical container for registering and exposing tools under the "Finance" namespace
It initializes a transport-bound MCP endpoint preconfigured for financial workflow routing and tenant-aware isolation
It establishes a scoped execution runtime that enforces financial-domain middleware policies across all registered tools
Option B most closely describes the purpose of the FastMCP declaration when implementing a coded MCP server.
UiPath supports coded MCP servers developed in Python using the FastMCP framework from the MCP Python package.
The expression FastMCP("Finance") creates an MCP server instance whose configured name is Finance.
That server instance provides the registration context for tools exposed through the FastMCP tool decorator.
For example, a developer can define financial operations such as invoice retrieval, payment-status validation, or account-balance queries and register them using the server object's tool decorator.
Once the coded server is packaged, published, and configured in UiPath Orchestrator, its registered tools can be discovered and made available to compatible MCP clients and agents.
Option A focuses on introspection rather than initialization. Option C incorrectly assumes the constructor configures transport routing and tenant isolation. Option D incorrectly assigns automatic finance-specific policy enforcement to the declaration.
The server name is descriptive metadata. It does not independently establish financial authorization policies, access boundaries, or specialized middleware behavior.
Although B uses the term namespace, the declaration does not automatically prefix every registered tool name with Finance.
Official UiPath references/topics: Orchestrator — MCP Server Types; Troubleshooting MCP Servers; UiPath Python SDK — Coded MCP Servers Quickstart.
Technical qualification: B is intended, but Finance is a named server context rather than automatically prefixed tool names.
In a UiPath Maestro process with multiple active instances running concurrently, what happens to global variables when one instance updates a global variable's value?
Global variables become read-only after the first instance sets a value, preventing further modifications
The updated value becomes immediately visible and usable by all other running instances of the same process
The value change is queued and only applied to new instances started after the update occurs
The update is isolated to the instance that performed it and does not affect other concurrent instances
Option B is the intended answer because UiPath Maestro distinguishes global variables from variables belonging to individual process instances.
Global variables are shared across instances of the same Maestro process. They are persistent and maintain their values beyond the execution of one instance. This provides a mechanism for maintaining process-wide information that must remain accessible across multiple executions.
Instance-level variables behave differently. They represent the state and data context of an individual process instance and are not automatically shared with other concurrently executing instances.
For example, a process may use a global variable to maintain information relevant to multiple executions, while each individual instance maintains separate transaction identifiers, customer records, and activity results.
Options A, C, and D incorrectly impose read-only restrictions, deferred-only visibility, or instance isolation on global variables.
However, option B contains an important qualification. The official UiPath documentation establishes that global variables are shared and persistent, but it does not guarantee instantaneous visibility under every concurrent execution condition.
Therefore, the word immediately should not be interpreted as a documented atomic-consistency or synchronization guarantee.
Architects should assess concurrent updates carefully and avoid assuming that shared variables automatically provide transaction locking or conflict-free coordination.
Official UiPath references/topics: Maestro — Working with Instance Management.
Technical qualification: B is the closest intended option, but immediate propagation is not explicitly guaranteed.
According to UiPath best practices, which elements primarily form the basis of the Agent Score?
User ratings, deployment frequency, agent version history, and governance policy compliance
Prompt structure, tool and context usage, input/output arguments, evaluation sets, and evaluation score
LLM model selection, temperature settings, maximum iterations, and integration activity types
Runtime logs, error rates, token consumption, and number of successful deployments
Option B is the intended answer under UiPath's earlier Agent Score framework.
Agent Score was designed to assess aspects of an agent's definition and evaluation readiness rather than relying exclusively on production execution statistics.
The characteristics identified in option B correspond to important agent development elements: prompt quality, tool configuration, contextual information, input/output schemas, evaluation coverage, and evaluation results.
Prompt structure determines whether the agent receives clear instructions describing its role, objectives, constraints, and execution behavior.
Tools and contexts establish the capabilities and enterprise information available to support its tasks.
Input/output arguments define structured interfaces for communicating with other automation components.
Evaluation sets and evaluation results provide evidence of performance across representative scenarios.
Options A and D emphasize administrative metadata and operational metrics rather than the intended development-quality assessment. Option C focuses on model configuration settings without adequately covering the broader agent definition.
However, this question is outdated for current UiPath Automation Cloud environments.
On October 8, 2026, UiPath announced that Agent Review replaced Agent Score.
Agent Review uses Autopilot to examine an agent against development best practices, identify critical issues and warnings, recommend improvements, and assign an A–F grade.
The numerical evaluation-set score remains a separate measure of performance.
Official UiPath references/topics: Agents — October 2026 Release Notes, Agent Review; Evaluations.
Technical qualification: Historical Agent Score replaced by Agent Review on October 8, 2026; retain B as legacy answer.
A team is designing an AI assistant and wants to make sure the model always follows company compliance rules, regardless of what individual users request.
What type of prompt should be used to enforce these rules consistently?
A user prompt that describes a single task requested during a specific interaction.
A dynamic message that changes tone based on the user’s most recent input.
A user prompt that overrides prior instructions with each new conversation.
A system prompt that defines global behavior and rules applied before any user interaction.
Option D identifies the appropriate instruction layer for establishing persistent behavioral rules in an AI assistant.
The system prompt defines the agent's operating role, authorized responsibilities, behavioral constraints, permitted activities, and requirements for handling user requests.
These instructions provide an operating framework that should remain applicable as users introduce different tasks or conversational topics.
For example, a financial-services assistant may require restrictions on exposing customer records, approving transactions without authorization, or processing requests outside its assigned responsibilities.
Embedding these requirements in the system prompt provides the agent with higher-priority behavioral instructions than ordinary task-specific user input.
Options A and C incorrectly assign persistent compliance controls to user prompts. Option B concerns conversational tone rather than governance requirements.
However, system prompts alone cannot guarantee compliance. Language-model behavior remains probabilistic, and user-controlled inputs may contain attempts to redirect the agent.
UiPath provides additional safeguards, including AI Trust Layer governance policies, centralized guardrails, tool permissions, evaluations, and human-in-the-loop escalation.
A production-grade solution should therefore combine system-level instructions with enforceable technical controls, monitoring, and approval mechanisms for consequential operations.
Official UiPath references/topics: Agents — Best Practices for Building Agents; Automation Ops — AI Trust Layer Policies.
Technical qualification: System prompts alone cannot guarantee compliance.
How can an agent with Escalations be evaluated?
Escalations will not execute in Evaluations.
It can only be evaluated manually.
Escalations must be simulated.
Escalations will be automatically mocked.
Option C is the intended selection because escalation simulation is a recommended method of evaluating agent behavior without requiring live human intervention.
UiPath Agents use escalations to request approval, validation, or assistance from human reviewers through Action Apps and Action Center.
During evaluation, an agent may encounter a scenario requiring an escalation. Allowing the actual escalation to execute can create a human task and introduce external dependencies into the test.
UiPath supports simulation of escalation behavior so developers can supply predefined or generated responses without waiting for a reviewer.
A simulated response might represent approval, rejection, or a request for additional information. The developer can then examine whether the agent continues correctly after receiving that result.
Simulation improves repeatability, reduces operational side effects, and supports automated regression testing.
However, current UiPath documentation permits both real and simulated executions within evaluation sets. Runtime evaluations can invoke live escalations when those components are not simulated.
Consequently, option C is not universally correct as written. Option A incorrectly states that escalations cannot execute, option B excludes automated evaluation, and option D incorrectly assumes that mocking occurs automatically.
The accurate recommendation is to simulate escalations when controlled, side-effect-free evaluation is required.
Official UiPath references/topics: Agents — Evaluations — Configuring Simulations; Managing Runtime Evaluations.
Technical qualification: Inaccurate wording: C is the intended answer, but escalation simulation is optional, not universally mandatory.
A team wants an agent to be selectable in the Run Job activity within Studio Web workflows.
Which lifecycle step best makes it available?
Observe the agent after it is tested, evaluated, and refined for intended behavior
Simulate the agent after it is tested, evaluated, and refined for intended behavior
Publish the agent after it is tested, evaluated, and refined for intended behavior
Debug the agent after it is tested, evaluated, and refined for intended behavior
Option C correctly identifies publishing as the lifecycle operation required to make a completed UiPath Agent available for orchestration and invocation from other automation workflows.
UiPath recommends testing, evaluating, and refining an agent before releasing it into a production environment.
During development, the agent exists within its design environment, where developers can debug prompts, evaluate responses, simulate tools, and inspect execution traces.
Publishing packages the agent and registers the published artifact within UiPath Orchestrator.
However, publishing alone does not complete the entire deployment lifecycle. The published solution must also be deployed before the agent becomes available as an executable resource.
Following deployment, supported Studio Web workflows can invoke the agent through the Run Job activity.
This enables developers to combine agent reasoning with conventional workflows and larger orchestration processes.
Option A refers to observing execution behavior rather than releasing the agent. Option B concerns simulated testing. Option D supports troubleshooting during development.
None of these operations substitutes for publishing and deployment.
The release process should also validate input/output arguments, runtime permissions, required connections, and dependencies to ensure successful invocation by downstream workflows.
Official UiPath references/topics: Agents — Publishing and Deploying the Agent — Publishing to Orchestrator.
What changes would improve clarity and specificity when an agent does not escalate high-value refund requests because the prompt merely says large refunds should be "handled carefully" without defining a clear threshold?
Encourage the agent to use its judgment when determining whether a refund amount is significant.
Emphasize that large refunds require attention and rely on the agent to interpret what qualifies as large.
Add more contextual background about refund policies without specifying measurable escalation criteria.
Define a precise refund amount threshold and clearly state when escalation to a human must occur.
Option D corrects the underlying ambiguity by establishing a measurable escalation condition and explicitly specifying the required action.
UiPath Agents support human-in-the-loop escalations for business exceptions, approvals, and decisions that should not be completed autonomously.
An instruction such as "handle large refunds carefully" does not define what constitutes a large refund or what the agent must do when encountering one.
The agent may consequently interpret the requirement inconsistently, allowing financially significant transactions to proceed without human review.
A more reliable instruction defines a numerical threshold, relevant currency, comparison operator, and escalation procedure.
For example, a policy might require human approval when the refund amount exceeds a configured financial limit. The agent should then invoke the designated escalation and include the relevant transaction information.
UiPath escalation configuration supports prompts that tell the agent when an escalation is appropriate, along with Action App inputs, assignment criteria, and outcome handling.
Options A, B, and C preserve ambiguity because they do not establish an objective triggering condition.
For financial operations requiring guaranteed approval, deterministic workflow controls should enforce the threshold outside the agent rather than relying solely on model-based interpretation.
Official UiPath references/topics: Agents — Escalations; Action Center — Creating Agent Escalations with Action Apps; Agents — Prompts.
You need an agent to dynamically incorporate customer email content into its response.
What is the best way to pass the email content as an input argument at runtime?
Manually input the email content into the system prompt each time the agent is used.
Reference the email content using the {{Customer_Email}} argument and pass it in the user prompt.
Define the email content as an array argument and ensure the agent references the array index.
Format the email content as a Boolean argument and use conditional logic to process it in the agent prompt.
Option B correctly uses UiPath Agent input arguments to introduce dynamic information during execution.
UiPath separates persistent system instructions from runtime input data. The system prompt defines the agent's role, responsibilities, behavioral constraints, and tool usage expectations.
The user prompt determines how task-specific inputs and arguments are supplied to the agent.
Developers can define input arguments through the agent's data schema and reference them in prompts using placeholders such as {{Customer_Email}}.
At runtime, the argument is populated with the actual customer email content. The agent then uses the supplied information when interpreting the request or generating its response.
This mechanism eliminates the need to modify persistent system instructions for every new email.
UiPath's current Prompt Editor also supports inserting arguments through its reference picker. The editor stores input argument references using the same placeholder representation.
Option A introduces unnecessary manual configuration and increases operational risk.
Option C incorrectly assumes that simple email text requires array indexing. Option D uses a Boolean data representation unsuitable for preserving email content.
A reliable implementation should use a descriptive text argument, establish its expected data type, and distinguish customer-provided content from trusted system instructions.
Official UiPath references/topics: Agents — Prompts — User Prompt; Agents — Prompt Editor — Input Argument References.
An agent produces inconsistent outputs because the system prompt clearly defines the task but does not specify the format of the final answer.
How can clarity and conciseness best practices be used to resolve this issue?
Encourage the agent to structure the response in a way that seems most appropriate for each case.
Expand the explanation of the agent’s overall goal without introducing formatting constraints.
Specify the required output format, structure, and tags that the agent must follow in the final response.
Provide additional background information about the business scenario to give the agent more context.
Option C directly resolves the identified problem by introducing explicit requirements for the structure and representation of the agent's final output.
UiPath recommends that system prompts define not only the agent's responsibilities but also the expected response format and behavioral constraints.
When output formatting is unspecified, a language model may generate responses using different headings, field names, narrative structures, or data representations across executions.
Although these responses may be semantically correct, inconsistent formatting can create problems for downstream automations that expect predictable output structures.
For example, an invoice-processing agent may be required to return an invoice identifier, payment status, validation result, and discrepancy description.
Defining these fields explicitly in a JSON schema or structured tagged format helps the agent produce consistent responses.
The prompt should identify required properties, permitted values, and behavior when information is missing.
Option A preserves formatting ambiguity. Option B expands the objective without addressing the defect. Option D supplies background information that may improve contextual understanding but does not establish output consistency.
UiPath also supports structured agent output arguments, which provide an additional mechanism for enforcing predictable data contracts.
A reliable implementation should combine concise formatting instructions, defined output schemas, and deterministic evaluation of mandatory fields.
Official UiPath references/topics: Agents — Prompts; Prompt Editor; Evaluations.
What is the main design goal when chaining multiple agents in one process for complex automations?
Replace all agents with a human reviewer at the final step to guarantee correctness without policies.
Centralize all decisions in a single agent and keep others idle to minimize orchestration complexity overall.
Let each agent decide freely without thresholds so execution adapts organically to changing inputs at runtime.
Establish clear handoff rules and confidence thresholds so downstream agents or robots act predictably.
Option D correctly identifies the importance of explicit coordination boundaries when multiple agents participate in a complex business process.
UiPath supports agent composition by allowing published agents to be invoked as tools and by providing orchestration capabilities for coordinating agents, robotic workflows, enterprise integrations, and human activities.
Each agent should perform a clearly defined responsibility and produce structured outputs that downstream components can interpret reliably.
Handoff rules specify the circumstances in which responsibility transfers from one component to another.
For example, an invoice classification agent may pass a validated classification to a financial verification agent. The downstream agent should receive the required data through a defined input schema and return a structured result.
Where classification uncertainty is relevant, the solution can use an appropriately validated confidence threshold or business-rule condition to determine whether processing continues or requires additional review.
Option A incorrectly assumes final human review guarantees correctness. Option B undermines the benefits of specialized agents. Option C permits uncontrolled delegation without safeguards.
For predictable orchestration, architects should also define error handling, timeout behavior, retries, escalation routes, and transaction boundaries.
UiPath recommends explicit tool descriptions and clear invocation conditions so agents understand when delegation is appropriate.
Official UiPath references/topics: Agents — Agents as Tools; Building Effective Agent Tools; Prompts, including tool invocation and escalation instructions.
Which evaluator is best suited to verifying a boolean output that must be strictly true?
JSON similarity, because it tolerates structure equivalence rather than single-value strict equality.
Exact match, because it enforces a strict equality check on the boolean value without ambiguity.
LLM-as-a-Judge, because it scores semantic similarity rather than strict boolean equality requirements.
Trajectory evaluator, because it reviews behavior history instead of enforcing exact output equality.
Option B correctly identifies the Deterministic Exact Match evaluator as the most appropriate mechanism for validating a strictly defined Boolean output.
UiPath provides several evaluator categories, each intended for a different validation requirement.
Exact Match compares the agent's actual output against a predefined expected value without allowing semantic substitutions or alternative representations.
For an output field that must be the Boolean value true, the evaluator should pass only when the actual result matches the expected value under the configured comparison rules.
This is important when the field controls a consequential business decision, such as whether a validation has succeeded or whether mandatory checks have been completed.
JSON Similarity examines structural similarity and is more appropriate when evaluating complex JSON representations.
LLM-as-a-Judge evaluates meaning or contextual correctness and can tolerate language variation. That flexibility is unnecessary for a strict Boolean requirement.
Trajectory evaluators inspect the agent's broader execution behavior, including intermediate actions and tool usage.
Option B therefore provides the most predictable, efficient, and reproducible verification mechanism.
The developer should also define the output schema as Boolean to distinguish the actual Boolean value true from a text string containing the word "true."
Official UiPath references/topics: Agents — Evaluations — Deterministic Evaluators and Choosing the Evaluator Type.
You are designing a Validate Invoice Status tool for an agent that checks invoice payment information. During testing, the agent sometimes misinterprets the results, even though the workflow runs successfully.
Which action best aligns with UiPath's best practices for improving tool reliability?
Use tool guardrails only to block unsafe inputs rather than clarifying result interpretation.
Add a detailed description listing side effects and risk factors so the agent can infer the correct interpretation.
Rely on the agent's language model to infer tool usage automatically, since example prompts are optional for well-named tools.
Include an example of the tool's input, expected output, and interpretation logic directly in the system prompt so the agent learns how to call the tool correctly.
Option D directly addresses the tool output interpretation problem and follows UiPath's documented recommendations for building reliable agent tools.
An agent's interaction with a tool involves three stages: selecting the appropriate tool, providing valid input arguments, and interpreting the returned output.
A successfully executed workflow does not guarantee that the agent understands the semantic meaning of its results. For example, a Validate Invoice Status tool might return structured properties identifying whether an invoice exists, its payment status, and its due date.
Without explicit interpretation guidance, an agent could mistakenly treat a valid but unpaid invoice as a completed payment or incorrectly classify an invalid invoice reference.
UiPath recommends including representative tool usage examples in the system prompt. These examples should show the expected input schema, sample output, and interpretation rules for important result combinations.
Such examples reduce ambiguity and provide the language model with a clear mapping between structured tool responses and business outcomes.
Option B addresses valuable tool metadata, particularly side effects and operational risk, but does not directly resolve result interpretation. Option A limits guardrail functionality, while option C relies excessively on implicit language-model inference.
Clear examples should supplement concise tool descriptions, validated schemas, and appropriate guardrails.
Official UiPath references/topics: Agents — Building Effective Agent Tools — Providing Example Usage in a System Prompt.
Why is it important to balance the threshold and number of results when optimizing agent context retrieval?
Because lowering both settings ensures the agent uses only the most recent context regardless of relevance.
Because it ensures relevant high-signal context is provided without returning too many unrelated results.
Because setting both to their maximum always produces the best performance by including all possible context.
Because balance is required to determine which schema fields are mandatory versus optional during context retrieval.
Option B correctly identifies the relationship between retrieval precision, context quantity, and the quality of information provided to an agent.
UiPath Context Grounding uses configurable retrieval parameters to determine which knowledge-base content becomes available during agent execution.
The Relevance score threshold controls the minimum acceptable similarity score for retrieved chunks.
The Max results generated parameter controls how many chunks are returned from the retrieval operation.
These parameters influence different aspects of retrieval performance and must be calibrated together.
A very low relevance threshold can allow unrelated or weakly relevant passages into the grounding payload. Increasing the result count may amplify this problem while consuming additional language-model context tokens.
Conversely, an excessively high relevance threshold combined with a small result count may exclude information necessary for answering the user's question.
UiPath recommends balancing these settings to provide relevant, high-signal context without exceeding token limits or overwhelming the agent with unnecessary material.
Option A incorrectly associates these settings with document freshness. Option C assumes that maximizing retrieval parameters improves accuracy. Option D concerns schema configuration rather than search-result optimization.
Developers should inspect retrieved chunks in execution traces, evaluate response quality, and adjust the parameters using representative test cases.
Official UiPath references/topics: Agents — Best Practices for Context Engineering — Number of Results and Threshold Score.
Regarding guardrails in UiPath Agents, what should you do when evaluating an agent?
Test thresholds during evaluation to fine-tune detection sensitivity and balance accuracy with false positives.
Apply uniform detection thresholds across all guardrails regardless of their data sensitivity and create human escalations to automatically fine tune the thresholds.
Configure thresholds based on production feedback without running evaluation sessions, because the production feedback is validated by humans.
Focus only on blocking all detections during evaluation to simplify configuration.
Option A precisely aligns with UiPath's recommended guardrail evaluation practices.
Guardrails provide safety, compliance, and operational controls over the information an agent processes and the actions it executes. UiPath supports guardrails at the agent, language-model, and tool levels, allowing different categories of behavior to be monitored and restricted.
Detection thresholds determine how sensitive a guardrail is when identifying potentially problematic information or behavior.
A lower detection threshold may identify more violations but can increase false-positive rates. Conversely, a higher threshold may reduce false positives while potentially allowing some genuine violations to remain undetected.
UiPath explicitly recommends testing thresholds during evaluation sessions to determine an appropriate balance between detection effectiveness and operational accuracy.
Developers should evaluate representative compliant and noncompliant scenarios, examine triggered guardrails, and adjust thresholds according to observed results.
Option B incorrectly assumes all guardrails require identical thresholds. Option C postpones essential validation until production. Option D prioritizes universal blocking without considering whether detections are accurate.
UiPath also recommends reviewing logs and execution traces to verify that configured actions operate correctly.
For business-critical applications, guardrail evaluation should establish acceptable false-positive and false-negative rates before production deployment.
Official UiPath references/topics: Agents — Guardrails, Best Practices for Guardrails; Monitoring Guardrails.
According to the UiPath Agents documentation, where can you view the evaluation score (0–100) and detailed results after running an evaluation set to assess accuracy and reliability?
Agent Score panel on the agent’s Evaluations workspace
Execution Trail tab in the bottom panel
Orchestrator Jobs page under Job traces
Results tab within the agent’s Evaluations workspace
Option D identifies the documented location for reviewing the outcome of an evaluation set in UiPath Agents.
The evaluation framework allows developers to compare an agent's actual outputs and execution behavior against predefined expectations.
After configuring representative evaluation cases, the developer executes the evaluation set using the Evaluate set action.
UiPath then presents the resulting scores and detailed evaluation outcomes in the Results tab.
These results help determine whether the agent satisfies the configured assertions and provide evidence for comparing changes made during development.
The score referenced in the question uses a 0–100 scale to represent evaluation performance according to the applicable assessment criteria.
Option A confuses evaluation-set results with the separate Agent Score feature used in earlier versions of the agent development experience.
Option B identifies the Execution Trail, which displays operational details such as tool invocations, inputs, outputs, and execution errors. Although these details support troubleshooting, they are not the primary evaluation-results location.
Option C concerns Orchestrator execution monitoring rather than the evaluation workspace.
A reliable development process should inspect both numerical evaluation results and detailed traces. High aggregate scores alone do not establish that every critical business scenario has been handled correctly.
Official UiPath references/topics: Agents — Evaluations, Working with Evaluation Sets.
What must be configured to create an Automation Ops policy for a specific tenant?
Policy name, Priority, Roles
Policy name, Description, Roles
Policy name, Priority, Description
Policy name, Description, Period
Option C most closely matches the general policy-details configuration described in the official UiPath Automation Ops documentation.
Automation Ops provides centralized governance controls for supported UiPath products, including Studio, Integration Service, and AI Trust Layer capabilities.
When an administrator creates or edits a governance policy, the Policy Details section includes a policy name, priority, description, and an availability setting.
The policy name identifies the governance configuration and should be unique enough to distinguish it from other policies.
Priority determines precedence when multiple group-level policies apply to the same user. UiPath applies the policy with the lowest numerical priority value first.
Description provides supplementary information about the policy's purpose and intended application.
Option A incorrectly substitutes Roles for Description. Option B omits Priority. Option D incorrectly introduces Period in place of the documented Priority setting.
However, the original question is incomplete if interpreted as an exhaustive list of mandatory fields.
Current UiPath documentation also includes Availability (days), which determines how long a cached policy remains applicable when the governed product cannot connect to Automation Ops.
Furthermore, the description is optional, and creating a policy does not automatically apply it to a tenant. The policy must subsequently be deployed to the intended tenant.
Official UiPath references/topics: Automation Ops — Configure a Governance Policy; Deploy Governance Policies.
Technical qualification: C best matches principal policy details, but description is optional and Availability (days) is another configuration property.
During the automation potential identification phase, which combination of factors should be analyzed to properly understand process variations?
Process steps for each pattern and the number of human touch points, without considering error rates or completion duration factors
Process steps for each pattern, including systems used, human touch steps, completion duration factors, and error rates per step
Annual labor effort and process volume trends, while assuming all variations follow similar patterns
Consumer satisfaction metrics and output format preferences, without mapping the specific steps in each process variation
Option B represents the most comprehensive approach to evaluating process variations during automation discovery.
Before introducing agentic automation, an organization should understand how the existing business process operates across different scenarios and exception paths.
Each variation should be mapped according to the activities performed, applications involved, human intervention requirements, execution duration, and frequency of errors.
The systems used determine integration complexity and available automation mechanisms. Human touch points reveal where employees perform manual actions, interpret unstructured information, resolve exceptions, or make decisions.
Completion duration identifies delays and potential bottlenecks. Error rates help quantify process instability, rework, and opportunities for quality improvement.
This information allows automation architects to distinguish deterministic activities suitable for conventional RPA from judgment-intensive activities where AI agents can add value.
For example, a standard invoice approval may follow a predictable sequence, while invoices with missing purchase-order references may require contextual analysis and human escalation.
Option A omits performance and quality measurements. Option C assumes process variants are equivalent. Option D concentrates on business outcomes without examining the operational causes.
A properly documented process baseline supports solution design, automation prioritization, and measurable comparisons between current-state and future-state performance.
Official UiPath references/topics: Agents — Best Practices for Building Agents; Process Mining — Process Analysis; Automation Hub — Opportunity Assessment.
An internal audit team creates a prompt requiring an agent to determine whether control descriptions are Adequate or Inadequate. The prompt contains the agent’s role, evaluation criteria, two labeled control examples, and a new description.
What is the primary advantage of this few-shot structured prompt?
It removes the need to define success criteria because the examples implicitly establish them.
It sets clear criteria and examples before evaluating the new control description.
It allows the agent to modify the evaluation criteria based on similarities to the examples.
It focuses primarily on formatting output instead of demonstrating how to apply the criteria.
Option B correctly identifies the benefit of combining explicit evaluation criteria with representative labeled examples in a few-shot prompt.
Few-shot prompting provides a language model with a small number of examples demonstrating how a task should be performed.
For an internal audit classification task, the agent must distinguish control descriptions that satisfy defined requirements from those that do not.
The prompt should first establish the agent's role and the criteria used to classify a control as Adequate or Inadequate.
Labeled examples then demonstrate how those criteria apply to representative control descriptions.
For example, an adequate control may specify a responsible owner, execution frequency, evidence requirements, and a clearly defined verification procedure.
An inadequate control might omit accountability, provide vague operating instructions, or fail to establish measurable compliance requirements.
The examples help the agent recognize the expected classification behavior when evaluating a new description.
Option A incorrectly suggests that examples eliminate the need for explicit success criteria. Option C would permit inconsistent modification of audit requirements. Option D overlooks the instructional value of the labeled examples.
UiPath recommends including representative input-output examples while avoiding excessive examples that unnecessarily increase prompt size.
A reliable implementation should also evaluate borderline descriptions and ensure that classification criteria remain consistent across executions.
Official UiPath references/topics: Agents — Prompts, Writing Effective Prompts; Best Practices for Building Agents.
Once a coded MCP server is registered in UiPath's MCP Servers panel, what triggers the discovery of its tools?
A manual capability refresh initiated from the MCP Servers panel that forces immediate re-indexing of exposed tools
Execution of the job associated with the MCP server registration, which establishes a live session and performs tool introspection
A scheduled synchronization cycle that periodically polls the server endpoint for updated tool metadata
An automatic heartbeat exchange that validates connectivity and refreshes the server's advertised capabilities
Option B most accurately describes the tool discovery mechanism used for coded MCP servers in UiPath Orchestrator.
Model Context Protocol (MCP) provides a standardized mechanism for exposing external tools and capabilities to AI agents. UiPath Orchestrator supports managing MCP servers and discovering the tools they make available.
For coded MCP servers, discovery is initiated through the Discover action within the MCP server's Jobs tab.
When the administrator selects Discover, Orchestrator starts a job associated with that MCP server. The job executes the required discovery procedure and obtains the tools exposed by the server.
Administrators can monitor execution progress through the Jobs tab. After the discovery job finishes, the Tools tab refreshes to display the discovered capabilities.
This distinction is important because selecting Discover does not immediately guarantee that the tools are available. Successful completion of the associated job is required.
Option A is incomplete because it suggests an immediate manual refresh rather than the documented job-based discovery procedure. Options C and D describe automatic polling or heartbeat mechanisms that are not the specified discovery trigger.
The discovered tools can subsequently be exposed to supported AI agents according to the applicable platform permissions and configuration.
Official UiPath references/topics: Orchestrator — Managing MCP Servers — Discovering Tools and Jobs.
Technical qualification: Tool discovery qualification: Discover initiates a job; tools appear after the job completes.
How are activity input methods configured in UiPath agent tools, and what are the main considerations for cascading fields?
Activity input methods include Prompt (default), Argument, and Static Value. Cascading fields cannot use the Prompt input method as agents cannot infer changes in field structures at runtime.
Activity input methods are mostly limited to Prompt, though in some cases Argument or Static Value can be selected depending on the connector. Cascading fields generally work with the Prompt method because agents can usually handle dynamic field updates during execution without major issues.
Activity input methods are fully automated with no optional configurations available. Cascading fields do not impact agent tool functionality in any way.
Activity input methods primarily default to Static Value for most fields to ensure predictable behavior and minimize runtime errors. Cascading fields are automatically detected and adjusted by the agent at runtime for smooth handling of dependent or conditional inputs.
Option A accurately describes the activity input configuration mechanisms documented for UiPath Agents.
When an Integration Service activity is exposed as an agent tool, its input fields can be configured using three methods: Prompt, Argument, and Static Value.
Prompt is the default method. It allows the agent's language model to infer an appropriate field value during execution based on the system prompt, tool description, and available context.
Argument populates the activity field from an explicitly defined agent input argument. This is appropriate when an upstream automation or orchestration process supplies a known value that should be passed directly to the tool.
Static Value assigns a predefined value that remains unchanged between executions.
Cascading fields introduce an important limitation. Their structure depends on another field's selected value. For example, choosing an issue type in an external ticketing application may change the available dependent fields.
UiPath does not permit the Prompt method for cascading fields because an agent's tool schema cannot dynamically adapt to those structural changes during execution.
Therefore, dependent field configurations must be resolved through supported explicit input methods rather than relying on runtime inference.
Official UiPath references/topics: Agents — Activities — Defining Activity Input Methods.
When integrating UiPath Data Fabric with event-driven automation, which action causes the connector to generate an event?
Exporting entity data from Data Fabric to an external system.
Opening the Data Fabric entity configuration in the Admin section.
Assigning user permissions to the Data Fabric entity.
Creating or updating a record in the Data Fabric entity.
Option D correctly identifies the record-level changes that generate events through the UiPath Data Fabric connector.
UiPath Data Fabric supports event-driven automation through Integration Service.
An event represents a state change affecting an entity record. When a subscribed entity experiences a supported record-level modification, Data Fabric can publish an event notification to Integration Service through a webhook.
The connector supports two principal event types: Record created and Record updated.
Record created fires when a new record is inserted into the selected entity and satisfies the configured trigger filter.
Record updated fires when an existing record changes and its updated state matches the relevant filter conditions.
For example, an organization may configure a workflow to execute whenever a new customer record is created or an invoice status changes.
The resulting event includes metadata identifying the event type, affected entity, and record identifier.
Integration Service can then route the event to the subscribed automation, enabling processing without continuous polling.
Option A describes data export rather than a supported record-change trigger. Option B concerns administrative configuration. Option C concerns permission management rather than entity data changes.
Importantly, event delivery requires a properly configured subscription and applicable permissions. Creating or updating a record does not automatically launch an automation without the corresponding trigger configuration.
Official UiPath references/topics: Integration Service — UiPath Data Fabric Events.
Which practice best helps you iteratively improve an agent’s prompt quality through UiPath evaluations?
Increase the model temperature to its maximum to force more creative outputs.
Tune only the agent's evaluator thresholds without updating the prompt structure.
Refine the prompt based on failed debug runs and add corrected outputs to the evaluation set.
Remove evaluations with lower scores to artificially raise the agent's average.
Option C describes a disciplined iterative development process based on observed execution failures and repeatable validation.
UiPath evaluations allow developers to measure whether an agent produces expected results under representative input conditions.
When a debug run fails, the developer should inspect the execution trace, identify the reason for the incorrect behavior, and determine whether the system prompt requires modification.
Prompt refinements may clarify the agent's responsibilities, constraints, tool-selection criteria, exception handling, or expected output format.
After correcting the behavior, the developer should add the original failing scenario to an evaluation set with the appropriate expected result.
This establishes a regression test that can be executed during subsequent changes.
UiPath supports creating evaluations directly from debug runs and manually correcting expected outputs before adding them to an evaluation set.
Option A introduces unnecessary output variability. Option B changes evaluation criteria without correcting the underlying agent behavior. Option D manipulates aggregate scores by excluding difficult cases, producing an unreliable assessment of production readiness.
A robust improvement cycle includes representative test scenarios, stable evaluation criteria, trace analysis, prompt refinement, and repeated execution.
UiPath's Optimize functionality can also analyze evaluation results and propose prompt changes, but proposed changes should be reviewed and validated against the full evaluation set.
Official UiPath references/topics: Agents — Evaluations — Creating Evaluations from Test Runs; Optimizing Your Agent Through Evaluations.
Before publishing an agent to Orchestrator, which combination of checks ensures the agent meets enterprise readiness standards?
Conduct at least 50 interactive tests and confirm no regressions.
Conduct at least 30 interactive tests, validate evaluation sets with ≥70% performance.
Run smoke tests only after publishing, and make sure the provided guardrail logging is enabled.
Skip interactive testing if curated evaluations exceed 80% accuracy.
Option B most closely matches UiPath's documented validation benchmarks for publishing and deploying agents to Orchestrator.
UiPath recommends completing at least 30 interactive tests covering normal scenarios, boundary conditions, malformed inputs, and other representative variations.
These tests allow developers to inspect agent behavior directly and identify problems involving prompts, tool selection, contextual information, and execution outcomes.
In addition, UiPath recommends creating at least 30 curated evaluation cases and achieving an evaluation score of 70% or higher without regressions.
Evaluation results should remain consistent when prompts, tools, or model configurations change.
Option A introduces an unsupported minimum of 50 interactive tests. Option C incorrectly postpones smoke testing and treats optional guardrail logging as the primary readiness control. Option D incorrectly suggests that high evaluation accuracy eliminates the need for interactive testing.
However, the checks in B are not sufficient by themselves to guarantee enterprise readiness.
UiPath also recommends finalizing prompts, validating tool schemas, configuring necessary guardrails, confirming context sources, verifying credentials and access permissions, and testing downstream integrations.
For high-risk operations, the organization should establish stricter acceptance criteria appropriate to the business consequences of failure.
Official UiPath references/topics: Agents — Best Practices for Publishing and Deploying Agents.
Technical qualification: B omits the separate recommendation for 30 curated evaluations and absence of regressions.
When configuring evaluation sets to compare model/temperature combinations, which evaluator categories let you select the model used for evaluation?
Trajectory evaluators only, because only trajectory grading needs a model selection while LLM-as-a-judge evaluators remain model-agnostic.
LLM-as-a-judge and Trajectory evaluators, because both are LLM-based and include a Model selection field for testing different model and temperature configurations.
Deterministic evaluators only, because their stable rule-based matching supports explicit model selection to compare model behaviors.
All evaluator categories, because model selection is available uniformly for deterministic, LLM-as-a-judge, and trajectory evaluators.
Option B correctly identifies the evaluator categories that expose a Model selection field in UiPath Agent evaluations.
UiPath separates evaluators into three principal categories: Deterministic, LLM-as-a-Judge, and Trajectory.
Deterministic evaluators use predefined comparison rules to evaluate outputs. Exact Match and JSON Similarity are examples. Because these evaluators do not require language-model inference to calculate their results, they do not include a Model selection field.
LLM-as-a-Judge evaluators use a language model to assess response characteristics such as semantic similarity, faithfulness, and contextual relevance. Their configuration allows developers to select the evaluation model.
Trajectory evaluators also use an LLM, but their purpose is to examine the agent's overall execution behavior, including intermediate actions, decisions, and tool usage.
Consequently, both LLM-as-a-Judge and Trajectory evaluators support model selection.
Option A incorrectly excludes LLM-as-a-Judge evaluators. Option C incorrectly assigns model selection to deterministic evaluators. Option D ignores the distinction between model-based and rule-based scoring.
Importantly, choosing an evaluator's model is different from choosing the model and temperature used to execute the agent. These are separate configuration concerns.
Official UiPath references/topics: Agents — Evaluations: Evaluator Categories and Defining Evaluators.
TESTED 22 Nov 2026