An agent needs to synthesize information from multiple documents and include source citations in its answer.
Which configuration best meets this requirement?
Select Structured (Preview) and map CSV columns for multi-document synthesis
Select DeepRAG and enable citations in the context properties
Keep Semantic and only lower Max results generated to encourage citations
Select Semantic and set a high relevance score threshold for citation output
Option B correctly identifies the Context Grounding configuration designed for complex document synthesis with source traceability.
UiPath provides multiple Context Grounding search strategies for different retrieval requirements.
Semantic search retrieves relevant document chunks and is generally appropriate for targeted information retrieval.
DeepRAG supports more extensive research by planning retrieval operations, examining relevant information across multiple documents, and synthesizing the findings into a comprehensive response.
This makes DeepRAG particularly appropriate when an agent must compare policies, consolidate evidence, or produce detailed findings supported by several source documents.
Within the Context properties, developers can select the DeepRAG search strategy and enable citations for the resulting queries.
Citations allow the generated response to reference the documents supporting its conclusions, improving traceability and reviewability.
Option A uses Structured search, which targets tabular information such as CSV files rather than complex document synthesis.
Option C reduces retrieval quantity without establishing comprehensive research capabilities. Option D modifies semantic retrieval precision but does not provide the same multi-document synthesis behavior.
An important distinction is that UiPath also offers a separate just-in-time DeepRAG tool. That tool has its own citation configuration, while the question specifically concerns the Context Grounding search strategy.
For index-based DeepRAG, the context-level configuration described in B is appropriate.
Official UiPath references/topics: Agents — Contexts, DeepRAG Search Strategy; Automation Cloud — Using DeepRAG.
When writing effective prompts for agents, what should always be included to help ensure reliable performance?
Multiple example responses for each possible user input scenario.
Detailed explanations of the business context for every argument.
A clear role definition, task breakdown, reasoning instructions, and output formatting.
Separate prompts for each reasoning step to simplify task execution.
Option C identifies the foundational elements of effective agentic prompt construction recommended by UiPath.
Unlike a simple language-model interaction, an agentic prompt must provide enough operational guidance for an agent to interpret information, formulate an execution plan, invoke appropriate tools, and return a result aligned with its objective.
A clear role definition establishes the agent's responsibilities and operating boundaries.
Task breakdown identifies the activities the agent must perform and helps organize complex operations into manageable stages.
Reasoning methodology instructions specify the expected decision-making approach, including validation criteria, tool usage conditions, and exception-handling requirements.
Output formatting establishes the structure of the generated result so downstream applications can interpret it consistently.
UiPath additionally recommends specifying measurable goals, relevant context, error-handling procedures, and representative examples where they improve reliability.
Option A unnecessarily requires examples for every possible scenario, creating excessive prompt complexity. Option B overemphasizes contextual detail without establishing behavioral instructions. Option D assumes every reasoning stage requires a separate prompt, which is not a universal design requirement.
Reliable agent development depends on combining structured instructions with suitable tools, evaluation coverage, and explicit operational constraints.
Official UiPath references/topics: Agents — Prompts — Writing Effective Prompts, Structure and Iterations.
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.
Given the following BPMN for the "SME to review the discrepancies" task, which option should be selected in the "Action" dropdown?

Original exhibit — Question 56
Create action app task
Create validation app task
Create and wait for action app task
Create and wait for validation app task
Option A identifies the documented implementation action for creating a human review task within a UiPath Maestro BPMN process.
The exhibit shows a User task named "SME to review the discrepancies" with an Action App selected in its properties panel.
In Maestro, a User task represents an activity requiring human participation rather than autonomous execution by an AI agent or robotic automation.
The Create action app task implementation integrates UiPath Action Apps and Action Center to provide a structured interface through which an assigned user can review business information and submit a decision.
In this scenario, the subject matter expert reviews discrepancies identified during invoice and purchase-order matching.
The Action App receives relevant process variables, presents the discrepancies, and collects the reviewer's decision.
The BPMN process can subsequently route execution through approval or rejection paths according to the submitted outcome.
Option B introduces a validation-specific action not represented by the standard task implementation shown. Options C and D introduce alternative action names that do not match the documented selection for this task.
UiPath's official Maestro implementation examples use Create action app task for human approval and discrepancy-resolution activities.
The appropriate choice is therefore A.
Official UiPath references/topics: Maestro Orchestrate — Tasks; Implementing a Complex Process; Extracting and Validating Documents.
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.
How is access to Context Grounding indexes controlled in UiPath Autopilot?
Access is managed through individual user permissions, requiring admin approval for each index regardless of folder assignment
Access is managed at the folder level, requiring the index to exist in the folder, the user to be assigned to the same folder, and the index to be enabled in Autopilot
Access is managed through role-based permissions, with only users having the Context Grounding Analyst role being able to access indexes
Access is managed at the tenant level, with all users in the tenant having equal access to all enabled indexes
Option B precisely matches UiPath's documented access-control requirements for Context Grounding indexes used by Autopilot for Everyone.
Context Grounding enables Autopilot to retrieve relevant information from indexed enterprise knowledge sources. Because those sources may contain confidential business information, access must respect established authorization boundaries.
UiPath manages index access through Orchestrator folder permissions.
Three conditions must be satisfied before a user can access a particular Context Grounding index through Autopilot for Everyone.
First, the index must exist in the appropriate Orchestrator folder. Second, the user must be assigned to that folder with suitable access permissions. Third, the index must be enabled in the Autopilot configuration.
Administrators enable indexes through Automation Cloud, under Admin, AI Trust Layer, and Autopilot for Everyone, using the Context Grounding configuration section.
During enablement, the administrator selects the relevant Orchestrator folder and index and supplies a description that helps Autopilot determine when the index should be queried.
Option A incorrectly requires independent administrator approval for every index access. Option C introduces an unsupported exclusive analyst role. Option D incorrectly assumes all tenant users receive identical access.
The documented folder-based model preserves logical separation between knowledge collections while allowing authorized users to retrieve relevant information.
Official UiPath references/topics: Autopilot — Context Grounding, Managing Access and Enabling Indexes.
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.
When designing an agent, which of the following practices best helps ensure that it remains maintainable, debuggable, and low-risk in production?
Allow the agent to handle several closely related tasks (for example "extract invoice data" + "classify invoice type") so you reduce switching overhead and reuse large context in one agent.
Design the agent to replace an entire workflow end-to-end (including many decision points and process branches) so it becomes autonomous and requires minimal oversight.
Use the same agent design pattern for all tasks across your organization to scale quickly, regardless of workflow structure or complexity.
Limit the agent's scope to a single task (for example "classify customer intent"), instead of combining multiple roles, so debugging and iteration are easier.
Option D follows UiPath's documented principle of narrowly scoped, specialized agent design.
An autonomous agent performs best when its objective, responsibilities, and permissible actions are clearly bounded. Assigning a single primary responsibility reduces prompt complexity, limits unnecessary tool usage, and simplifies the evaluation of execution results.
For example, an agent responsible exclusively for classifying customer intent can be evaluated against a clearly defined classification schema. Its accuracy, failure patterns, and response consistency can be measured independently from unrelated business operations.
When one agent performs extraction, classification, approval, reconciliation, and customer communication simultaneously, diagnosing an incorrect outcome becomes more difficult because several reasoning and execution stages contribute to the result.
Narrow responsibilities also help establish the principle of least privilege. Each agent can receive only the tools and enterprise data access necessary for its assigned objective.
Option A increases responsibility breadth, even though the tasks may be related. Option B attempts to replace deterministic process orchestration with unrestricted agent behavior. Option C ignores the different risk profiles and requirements of individual business processes.
Specialized agents can still collaborate through workflows, tool invocation, or multi-agent orchestration without each agent assuming responsibility for the entire process.
Official UiPath references/topics: Agents — Best Practices for Building Agents — Scope Narrowly and Specialize.
An insurance company needs to automate end-to-end policy validation by ingesting customer records from its CRM, invoking multiple REST APIs to verify coverage and eligibility against external data sources, and reconciling results for audit compliance. The process must handle authentication challenges, intermittent API outages, and changing response schemas, while providing clear progress and error reporting for business users.
Which workflow design approach is best?
Create a modular UiPath workflow with centralized API authentication, schema validation/adaptation for varying responses, resiliency (auto-retries, graceful outage handling), and real-time progress/error logs for business users.
Organize the workflow so each API call operates independently, with hardcoded credentials; in case of outages, aggregate error codes for later manual investigation, and generate a single compliance summary after all processing is complete.
Use separate UiPath workflows for each stage, CRM ingestion, API verification, and reconciliation, allowing manual intervention if an authentication failure or schema mismatch occurs, and emailing stakeholders occasional audit summaries for review.
Configure the workflow to only process customer records during periods of known API uptime, skipping records and deferring validation when external data sources are unavailable, then batch process any skipped validations later and compile a multi-stage report.
Option A represents the most appropriate enterprise integration architecture because it addresses reliability, security, maintainability, and operational transparency together.
UiPath Integration Service provides a centralized mechanism for establishing authenticated connections with external applications. These connections can be reused across automation activities, reducing credential duplication and supporting controlled authentication lifecycle management. Where a suitable connector is unavailable, custom API integrations can implement equivalent authentication controls.
A modular architecture separates CRM ingestion, eligibility verification, response transformation, and reconciliation into independently maintainable components. Schema validation is particularly important because external APIs may introduce optional properties, modify response structures, or return unexpected payloads. Normalizing these responses before downstream processing reduces integration failures.
Resilience can be implemented through exception handling, bounded retries, and appropriate recovery procedures. UiPath's Retry Scope activity supports retrying eligible operations. However, retry behavior must consider API rate limits, timeouts, and transaction idempotency to prevent duplicate changes.
Centralized logging and transaction-level status reporting allow administrators and business stakeholders to identify failed records, investigate exceptions, and support audit requirements.
Options B, C, and D introduce avoidable operational risks through hardcoded credentials, excessive manual intervention, or incomplete exception handling.
Official UiPath references/topics: Integration Service — Connections; Authentication Configuration; System Activities — Retry Scope.
An agent extracts customer email addresses from support tickets and must check that each extracted value exactly matches the format "" without variations.
Which evaluator type is best suited to this validation requirement?
Model-graded evaluator, because it can assess whether the extracted value structurally resembles an email address
Deterministic evaluator, because it performs rule-based precise pattern matching without requiring semantic interpretation
LLM-as-a-Judge evaluator, because it can understand the semantic intent behind the email format requirement
Semantic Similarity evaluator, because it can compare the extracted email against expected pattern variations
Option B is the intended answer because strict format validation requires deterministic assessment rather than semantic interpretation.
UiPath deterministic evaluators use predefined comparison rules that produce consistent outcomes for identical inputs.
These evaluators are appropriate when output requirements are precisely defined and the result must not depend on subjective language-model judgments.
For instance, an Exact Match evaluator can verify that an extracted value equals a specific expected string.
When validating arbitrary email addresses against a required format, however, the implementation must distinguish exact-value comparison from pattern validation.
A regular expression or equivalent deterministic validator can enforce requirements such as permitted characters, mandatory separators, domain structure, and whether the entire input matches the specified pattern.
An LLM-as-a-Judge evaluator may recognize that a value resembles an email address, but semantic assessment does not provide the same guarantees as a deterministic syntax check.
Options A, C, and D therefore introduce unnecessary interpretation and potential scoring variability.
The original question contains an additional technical problem: the required format is represented by empty quotation marks. Without the actual format specification, the exact validation rule cannot be constructed.
Furthermore, UiPath's built-in Exact Match evaluator is not inherently a general-purpose regular-expression validator.
Official UiPath references/topics: Agents — Evaluations — Deterministic Evaluators and Exact Match.
Technical qualification: Malformed question: Required email-format expression is missing between quotation marks; clarify whether the check is exact equality or pattern validation.
An evaluation repeatedly fails when the agent calls a particular tool, but the summary shows no explicit error.
Which action would provide the clearest diagnostic insight?
Replace the tool with an alternative that performs a similar function to avoid hidden issues.
Increase the number of evaluation examples to determine whether the issue persists statistically.
Inspect the recorded tool call inputs and outputs within the trace to verify correctness and sequencing.
Simplify the agent's objective so the tool call becomes optional in future runs.
Option C identifies execution-trace inspection as the most reliable method for diagnosing an agent evaluation failure associated with a particular tool.
UiPath's agent tracing functionality records execution details beyond the final result or evaluation score.
A trace can identify the tool selected by the agent, the arguments supplied during invocation, the response returned by the tool, and its position within the overall execution sequence.
These details help distinguish several possible failure conditions.
The agent may have selected the correct tool but supplied invalid arguments. Alternatively, the tool may have executed successfully but returned information that the agent interpreted incorrectly.
Another possibility is that the agent invoked the tool before retrieving required contextual information or completing a prerequisite operation.
Examining the recorded inputs, outputs, and sequence allows the developer to determine which condition caused the failed evaluation.
Option A replaces a component before establishing the failure mechanism. Option B expands test coverage but does not directly explain the failure. Option D changes the business requirement to avoid the problematic behavior.
UiPath also provides tool-call evaluators for validating invocation arguments, call counts, execution order, and returned outputs. These can supplement trace inspection when recurring defects must be detected automatically.
Official UiPath references/topics: Agents — Agent Traces; Managing Runtime Evaluations — Tool Call Evaluators.
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.
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.
How does Data Fabric’s integration with external data sources improve the outcomes of agentic automation?
It requires manually copying data into a centralized repository to standardize schemas before agents can access and use it.
It eliminates migrations and provides real-time, connected data so agents act on the most current business context.
It caches nightly ETL snapshots so agents work with near-real-time data without changing source systems.
It migrates selected fields on demand to reduce latency while agents operate on partially replicated data.
Option B describes the primary architectural benefit of UiPath Data Fabric's integration with external enterprise data sources.
UiPath Data Fabric provides a unified data-access layer that allows automation components to interact with information originating from multiple business systems.
Its external connectivity capabilities support access to live source information without requiring conventional bulk migration or continuous replication into a separate centralized repository.
This reduces the operational complexity associated with maintaining duplicated business data and enables agents to make decisions using more current enterprise information.
For example, a customer service agent may need account status from a CRM, transaction information from a financial platform, and order details from an enterprise resource planning system.
Using Data Fabric, these sources can be represented through a connected entity model that exposes relevant business information to supported automation components.
UiPath's Data Fabric architecture also incorporates access controls and governance mechanisms that help organizations manage interactions with enterprise information.
Option A incorrectly requires manual copying. Option C assumes a mandatory nightly ETL architecture. Option D describes partial data migration rather than the fundamental external connectivity model.
A technical qualification is necessary: Data Fabric does not guarantee identical freshness or true real-time behavior for every connector. Availability, query behavior, and freshness depend on the configured source and deployment.
Official UiPath references/topics: Data Fabric — June 2025 Release Notes; Data Fabric Feature Availability; Agents — September 2026 Release Notes.
Technical qualification: Data freshness qualification: “real-time” is source-dependent and not guaranteed by every connection.
An organization is assessing a proposed agent story to determine whether it meaningfully addresses operational challenges.
Which evaluation criterion aligns most directly with agentic discovery principles?
Verify that the agent story increases the total number of automated steps across the process.
Verify that the agent story introduces additional architectural complexity to support future scalability.
Verify that the agent story corresponds to documented inefficiencies and decisions from the "as-is" analysis.
Verify that the agent story expands automation scope beyond the boundaries of the documented workflow.
Option C establishes the correct relationship between current-state process analysis and the justification for introducing agentic automation.
The "as-is" analysis documents how an existing business process operates, including its activities, decision points, systems, exceptions, manual interventions, and operational inefficiencies.
An agent story should address identifiable problems revealed by this analysis rather than introducing AI capabilities without a clearly defined business requirement.
For example, a process assessment may identify that employees spend substantial time interpreting inconsistent customer requests before routing them to the correct department.
This finding could justify introducing an agent responsible for contextual classification while preserving deterministic routing and downstream execution.
The proposed agent should therefore be connected to a documented pain point, a clearly defined responsibility, and measurable expected improvements.
Options A and D focus on increasing automation scope without establishing business value. Option B incorrectly treats additional architectural complexity as an objective.
UiPath's workflow-mapping guidance recommends identifying judgment-intensive steps, ambiguous inputs, and decision points before selecting agentic components.
This approach supports a defensible business case and reduces the risk of applying autonomous reasoning to processes better handled by conventional automation.
The evaluation should ultimately determine whether the proposed agent improves operational outcomes while maintaining appropriate reliability, governance, and maintainability.
Official UiPath references/topics: Agents — Workflow Mapping and Design Principles; Cartographer — AS-IS Process Documentation.
Which of the following options includes all formats supported by Context Grounding in the 2025.10 release?
PDF, TIFF, DOCX, CSV, XLSX, PNG files
PDF, TIFF, CSV, XLSX, DOCX, TXT files
PDF, JSON, DOCX, CSV, XLSX, PNG files
PDF, JSON, CSV, XLSX, DOCX, TXT files
Option D matches the supported Context Grounding file formats documented for UiPath Automation Suite 2025.10.
The documented formats are PDF, JSON, CSV, XLSX, DOCX, and TXT.
Context Grounding provides managed ingestion and indexing capabilities that allow agents to retrieve relevant information from enterprise documents and structured business data.
PDF and DOCX support document-oriented knowledge retrieval, while TXT provides a straightforward format for unstructured textual information.
JSON supports structured content, and CSV and XLSX support tabular business information. UiPath also documents advanced structured querying for CSV data when Context Grounding is configured within an agent.
Options A and B incorrectly include TIFF. Option C introduces PNG while excluding TXT.
An important distinction is that the question explicitly references the 2025.10 release. The answer must therefore be evaluated against that version rather than the latest cloud service capabilities.
Current Automation Cloud documentation includes additional image formats in its supported-file list, but that does not change the historical release-specific answer.
Furthermore, support for file ingestion should not be confused with support for every search strategy. For example, particular DeepRAG configurations may impose narrower file-type requirements.
Option D is therefore the correct selection for the stated release.
Official UiPath references/topics: Automation Suite 2025.10 — About Context Grounding — Multi-Document Support.
What is the primary risk of using strict assertions in creative or generative tasks?
It guarantees higher evaluation scores for all runs
It reduces the need for evaluator conditions in datasets
It ensures outputs are always consistent and predictable
It may incorrectly flag valid outputs as failures due to minor variations
Option D correctly identifies the principal limitation of strict assertions when evaluating generative AI responses.
Generative tasks frequently permit multiple acceptable outputs that communicate equivalent information using different wording, sentence structures, or formatting.
UiPath provides Deterministic Exact Match evaluators for requirements where actual and expected outputs must satisfy precise equality conditions.
These evaluators are appropriate for fixed values such as transaction identifiers, Boolean decisions, specific numbers, and other tightly constrained outputs.
However, applying Exact Match to creative or conversational responses may produce false failures.
For example, a customer-support agent could generate two explanations containing identical policy information but expressing that information in different sentences. An exact-match assertion might reject one response despite its substantive correctness.
UiPath's LLM-as-a-Judge Semantic Similarity evaluator offers a more appropriate alternative when the evaluation objective concerns meaning rather than identical wording.
Option A incorrectly assumes strict checks improve evaluation scores. Option B incorrectly suggests that assertions become unnecessary. Option C confuses strict validation with consistency of the underlying language-model output.
The correct approach is to match evaluation strictness to the business requirement.
Critical structured fields should receive deterministic checks, while natural-language responses should generally use semantic assessment supplemented by factual and policy-compliance controls.
Official UiPath references/topics: Agents — Evaluations, Deterministic Evaluators, LLM-as-a-Judge, and Choosing the Evaluator Type.
In the illustrated insurance-claim automation, the agent analyzes incoming emails and escalates uncertain cases for confirmation before proceeding.
When configuring Human-in-the-Loop for this process, which configuration best ensures accurate claim identification while maintaining automation efficiency?

Original exhibit — Question 2
Configure human approval before notifying the customer of the final claim decision, regardless of how the claim was classified.
Configure human validation for a subset of processed claims selected based on predefined business priority categories.
Configure escalation to a human reviewer when the agent can't confidently confirm the email is an insurance claim.
Configure human review after the claim summary is generated to validate extracted details prior to uploading the processed claim into the data fabric.
Option C implements selective Human-in-the-Loop escalation at the point where uncertainty directly affects the insurance-claim workflow.
UiPath Agents support escalations that allow an autonomous agent to request human validation, approval, or additional information while executing a business process. Escalations are implemented using Action Apps and Action Center, enabling human reviewers to supply decisions that determine whether processing should continue.
In the illustrated process, the initial agent analyzes incoming email content to determine whether the message represents an insurance claim. When the classification is uncertain, the agent should request human confirmation before extracting detailed claim information or advancing to claim processing.
This approach establishes a controlled decision boundary. Clearly identified claims can follow the automated processing route, while ambiguous cases receive additional validation.
Option A requires approval regardless of classification confidence, introducing unnecessary workload. Option B selects cases using business priority rather than classification uncertainty. Option D delays validation until downstream processing has already occurred, potentially propagating an incorrect classification.
For reliable implementation, the escalation should define explicit triggering conditions, the information provided to reviewers, permitted outcomes, and the continuation behavior following human intervention.
Official UiPath references/topics: Agents — Escalations; Action Center — Creating Agent Escalations with Action Apps; Best Practices for Building Agents.
Technical qualification: Source attribution correction: The uploaded file cites Appian rather than UiPath for the claim-escalation rationale.
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.
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.
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.
When setting up a Context Grounding index in UiPath Orchestrator, which of the following describes a correct combination of source type and required setup steps?
Choose Connector and upload data directly into the index without selecting an external storage service by dragging and dropping the documents.
Choose Storage Bucket as the data source and then select the Orchestrator folder containing the bucket and the matching file types.
Choose Storage Bucket as the source and leave the file type unspecified, since Orchestrator automatically detects all file types by default.
Choose Connector, then directly upload files into Orchestrator without selecting a connection or specifying a folder path.
Option B correctly describes the required configuration when creating a Context Grounding index using an Orchestrator Storage Bucket.
UiPath Context Grounding enables agents to retrieve relevant information from enterprise knowledge sources and incorporate that information into their reasoning. Before the agent can retrieve documents, the source material must be configured and indexed.
During index creation, administrators select the desired data source under Data Settings. When Storage Bucket is selected, the administrator identifies the Orchestrator shared folder containing the relevant storage bucket and specifies the appropriate file type.
The configuration supports selecting individual file types or the All option when documents have multiple supported formats. Files can subsequently be uploaded using the available upload controls.
Alternatively, a Connector source requires an Integration Service connector, an authenticated connection, and the location of the external content repository.
Option A incorrectly treats Connector sources as direct document-upload mechanisms. Option C incorrectly assumes the file type can simply remain unspecified. Option D omits the connection and source-location requirements.
Proper index configuration also requires consideration of data permissions, ingestion settings, supported document formats, and synchronization schedules.
These controls ensure that agents retrieve relevant information from authorized knowledge sources.
Official UiPath references/topics: Orchestrator — Managing Indexes; Automation Cloud — Creating Indexes — Data Settings and Storage Bucket Sources.
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.
In UiPath Maestro, which of the following conditions must a variable meet to be usable in the Monitoring tab’s filter builder?
The variable must be linked to a BPMN gateway decision
The variable must be declared in the global scope of the automation project
The variable must be used in at least one completed process instance
The variable must be explicitly configured as searchable in the Maestro canvas
Option D is the answer indicated by the uploaded practice material, but it cannot be considered correct against the current UiPath Maestro documentation.
UiPath Maestro Orchestrate supports filtering process instances by variable values to investigate execution patterns, business outcomes, and operational exceptions.
The current documentation explains that variable filters are configured directly within the Monitoring view using the Configure filtering action.
Administrators select variables from those defined in the deployed process version, specify comparison operators, and apply the appropriate filter values.
Importantly, UiPath explicitly states that canvas-level configuration is not required to make variables available for filtering.
This directly contradicts option D's requirement to mark variables as searchable on the Maestro canvas.
Option A is not required because filtering is independent of BPMN gateway associations. Option B introduces an unsupported global-scope condition. Option C incorrectly requires prior use in a completed instance.
Consequently, none of the four options accurately describes the current configuration requirement.
For the current product, the relevant prerequisite is that the variable exists in the selected deployed process version and is available through Monitoring's variable selector.
Variable filtering applies to process instances executed after the filter is enabled, which should also be considered when analyzing historical execution data.
Official UiPath references/topics: Maestro Orchestrate — Variables and Element Filtering — Configure Element and Variable Filters.
Technical qualification: Outdated question: D is the legacy intended answer; current documentation does not require a canvas-level searchable-variable setting. None of the presented options is correct under the current product.
While designing a few-shot structured prompt for a customer support agent, you want the agent to handle refunds and send confirmation messages.
Which of the following is the best instruction for formatting the confirmation message?
Send a formal response including general refund details without specifying the estimated refund time or enclosing the output within structured XML tags.
Only mention the refund amount, excluding any other details or formatting in the response.
Include order ID, refund amount, estimated refund time, and a polite message enclosed within tags.
Provide the customer with a generic acknowledgment of the refund request without using any defined schema or structured output tags.
Option C provides the most complete instruction for producing structured refund confirmations through few-shot prompting.
Few-shot prompting supplies representative examples of inputs and expected outputs to demonstrate the required behavior. The examples help establish consistent formatting, information selection, and response structure across different customer requests.
For refund processing, the confirmation should include the order identifier, approved refund amount, estimated refund processing time, and an appropriate customer-facing message.
Each field serves a distinct business requirement. The order identifier provides transaction traceability, the refund amount confirms the financial value, and the estimated refund time establishes an expectation for the customer.
Using explicit XML-style tags provides recognizable boundaries around the generated content. This is useful when downstream systems must parse individual fields or validate the output against a predefined structure.
However, the prompt should define the actual tag names and provide representative examples rather than merely instructing the model to use unspecified tags.
Options A, B, and D omit important transaction information or fail to establish a predictable output structure.
UiPath recommends explicit task instructions and output formatting requirements to reduce ambiguity. Few-shot examples complement these instructions by demonstrating the desired result.
Official UiPath references/topics: Agents — Prompts; Best Practices for Building Agents — Output Formatting.
Technical qualification: Wording qualification: The source does not define actual XML tag names; a reliable few-shot implementation should specify them.
Which filters can be applied to refine the data displayed on the Monitoring tab?
Advanced filters override basic filters completely, making version and date range irrelevant when both are applied.
You can apply both basic filters and advanced filters to refine the displayed data.
Filters can only be applied after exporting the data, the Monitoring tab itself does not support filtering.
Only basic filters such as version and date range are available, element and variable-level filters are not supported.
Option B correctly describes the filtering capabilities available in UiPath Maestro Orchestrate's Monitoring interface.
Maestro provides process monitoring functionality that allows administrators and process owners to examine execution activity, identify exceptions, and analyze operational outcomes.
The Monitoring tab supports basic filters, including process version, date range, and execution status.
Version filtering allows users to isolate instances associated with a particular deployed process definition. Date filtering restricts the analysis to a specified observation period, while status filtering differentiates active, completed, cancelled, and faulted instances.
Advanced filtering extends these capabilities by allowing selection based on executed BPMN elements and process variable values.
For example, an administrator investigating delayed invoice approvals could select a particular process version, restrict the date range, and apply a variable condition identifying high-value transactions.
UiPath provides the Configure filtering action for creating element and variable filters directly within Monitoring.
Option A incorrectly assumes that advanced filters eliminate basic filtering criteria. Option C incorrectly requires data export before filtering. Option D excludes supported element- and variable-level filters.
An additional consideration is that variable filtering applies to process instances executed after the filter was enabled, which can affect historical analysis.
Official UiPath references/topics: Maestro Orchestrate — Variables and Element Filtering.
An automation developer needs an agent to extract the invoice number from incoming emails without being given any examples.
How should the zero-shot system prompt be written for this simple task?
Provide a short and direct instruction telling the agent to read the email content and return the invoice number if present.
Include multiple example emails and expected invoice numbers to demonstrate the correct extraction pattern.
Define several optional tools and escalation rules even though the task only requires simple text extraction.
Add a long explanation about different invoice formats and detailed reasoning steps for every possible variation.
Option A correctly applies zero-shot prompting to a narrowly defined information-extraction task.
Zero-shot prompting instructs a language model to perform a task without including demonstrations of the expected input-output relationship. This technique is appropriate when the task is sufficiently familiar and can be communicated through direct, unambiguous instructions.
In this scenario, the agent must read incoming email content, identify an invoice number, and return the extracted identifier when present.
A suitable instruction would define the source text, extraction objective, and expected output while avoiding unnecessary procedural complexity.
For production use, the prompt should also specify the behavior when no invoice number exists, such as returning a defined null value or an explicitly designated status. This prevents the agent from inventing identifiers when the required information is absent.
Option B describes few-shot prompting because it introduces example emails and expected outputs.
Option C adds tool and escalation complexity that is unnecessary for the stated extraction requirement. Option D increases instruction volume without necessarily improving reliability.
UiPath's prompting guidance emphasizes clear objectives, focused responsibilities, and explicit output requirements. These principles are especially important when an agent performs narrowly scoped extraction or classification operations.
Official UiPath references/topics: Agents — Prompts — System Prompt; Best Practices for Building Agents — Scope Narrowly and Specialize.
A company is deploying a UiPath agentic AI to automate invoice processing, customer support responses, and marketing campaign recommendations.
In which of the following scenarios is Human-in-the-Loop validation recommended?
The agent processes recurring invoices that match historical patterns and predefined approval criteria.
The agent generates customer responses using validated knowledge sources and established communication guidelines.
The agent recommends campaign adjustments based on consolidated performance data and prior approved strategies.
The agent processes invoices containing data discrepancies and policy deviations beyond standard approval conditions.
Option D identifies the scenario with the strongest requirement for Human-in-the-Loop validation because it involves discrepancies and exceptions outside established business approval conditions.
UiPath recommends human escalation when agents encounter ambiguous decisions, missing information, tool failures, or regulatory and business-rule exceptions.
Invoice processing frequently involves financial controls, supplier verification, purchase-order reconciliation, and approval thresholds.
When an invoice contains discrepancies or policy deviations, autonomous processing may result in unauthorized payments, incorrect accounting records, or compliance violations.
A suitable agentic workflow should detect the exception, assemble the relevant supporting information, and request human review before proceeding with the affected transaction.
UiPath Agents can initiate escalations using Action Apps and Action Center. The reviewer can examine the disputed information, approve or reject the exception, or supply corrected values.
After the escalation is resolved, the agent can continue according to the configured outcome behavior.
Option A describes predictable invoice processing within predefined approval criteria. Option B concerns responses generated from validated information. Option C involves recommendations consistent with previously approved strategies.
These scenarios can also warrant human oversight depending on organizational policy, but they do not inherently present the explicit exception condition described in D.
Official UiPath references/topics: Agents — Escalations; Agents — Human-in-the-Loop Best Practices.
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.
After observing a drop in retrievals, which action provides document-level details to verify whether fresh content was ingested successfully?
Open the index's Sync job history and select a specific entry to view the ingested documents
Change Interval to last month to display previews of the documents used for retrieval
Click the Queries metric to open raw query logs for every search request
Filter the index list by Last queried and export the table to review document details
Option A identifies the appropriate diagnostic procedure for examining document ingestion within UiPath Context Grounding monitoring.
Context Grounding indexes rely on successful ingestion and synchronization operations to make enterprise documents available for retrieval.
When retrieval activity decreases unexpectedly, administrators should distinguish reduced query demand from problems involving source synchronization or failed document ingestion.
UiPath Orchestrator provides index monitoring capabilities through the tenant-level Indexes monitoring interface.
Administrators can select an individual index to inspect its query metrics and Sync job history.
The Sync job history displays ingestion operations performed during the selected monitoring interval.
Selecting a particular synchronization job opens detailed information about the documents processed by that operation.
This allows administrators to investigate whether recently added documents were successfully ingested and identify failures that may affect retrieval quality.
Option B changes the observation interval but does not independently expose document-level ingestion details. Option C incorrectly describes the Queries metric as a comprehensive raw-query log interface. Option D relies on index usage metadata, which does not establish document ingestion success.
A complete investigation should correlate synchronization history with source updates, ingestion status, permissions, and representative retrieval tests.
Importantly, a reduction in retrieval queries does not, by itself, demonstrate an indexing failure.
Official UiPath references/topics: Orchestrator — Monitoring: Indexes and Sync Job History.
How can a UiPath process make sure that user input collected through the Properties Panel meets a specific format or set of constraints?
Capture the input and handle errors later in a separate activity
Rely on the Default Value to guide user input
Apply Validation Rules directly to the input field
Use the Input Label to describe the required format
Option C correctly identifies input validation as the mechanism for enforcing specific requirements before user-supplied information is accepted.
UiPath Forms and Apps provide configurable input controls with validation properties that can enforce requirements independently of the descriptive text displayed to users.
Depending on the component, validation settings include mandatory-field requirements, minimum and maximum lengths, regular-expression patterns, and custom error messages.
For example, a form collecting a customer reference number may require a specific number of characters or a predefined alphanumeric pattern.
Configuring the appropriate validation rule allows the form to reject values that do not meet the specified requirements.
UiPath's Form Designer provides a Validation configuration section containing relevant controls, including Required, Minimum Length, Maximum Length, and Regular Expression Pattern.
Option A allows invalid information to enter the process before validation occurs. Option B provides a suggested value but does not restrict user input. Option D supplies instructions that users may disregard.
Although labels and default values improve usability, they are not substitutes for enforceable input constraints.
For critical business information, field-level validation should also be complemented by server-side or workflow-level validation before consequential transactions are executed.
Official UiPath references/topics: Activities — About Form Designer Controls; Apps — Textbox Validation Properties.
Technical qualification: The original question does not identify the precise form or application designer; controls are documented under component validation settings.
Copyright © 2014-2026 Certensure. All Rights Reserved