C is correct — an agentic story that falls into the "Do Later" quadrant typically represents high feasibility but low impact .

In UiPath’s Impact vs. Feasibility Matrix , used during the Agentic Discovery phase, automation ideas are evaluated on:

Feasibility (ease of implementation)

Impact (business value, time saved, ROI)

Quadrants:

Quick Wins : High impact, high feasibility

Do Later : Low impact, high feasibility

Strategic Bets : High impact, low feasibility

Avoid/Backlog : Low on both

‘Do Later’ agentic stories are often simple to automate but don’t deliver meaningful outcomes — e.g., automating low-volume tasks or internal reports with limited audience.

Focusing on impactful use cases ensures agent development time translates to real business value — one of the key lessons from UiPath’s agentic blueprint methodology.

The correct answer is A — clear, structured instructions about output format are essential for consistent LLM responses, even when few-shot examples are present.

UiPath’s Prompt Engineering Framework emphasizes the use of:

Explicit formatting rules (e.g., “Use bullet points with bolded headers”)

Output instructions (e.g., “List items under appropriate sections: Decisions, Action Items, Next Steps”)

Consistent prompt structure : combining examples with a detailed task instruction

Without such instructions, LLMs — even with examples — may hallucinate structure , interpret outputs loosely, or switch formats between runs.

This is especially important in agentic automation , where the output feeds downstream steps (e.g., emails, documents, summaries). Inconsistent format breaks reliability and automation flow.

Option B (length constraints) helps refine but isn’t the root issue here.

C (randomized formatting) introduces inconsistency — not helpful.

D describes the issue but not the missing critical step , which is the instruction.

UiPath advises combining:

Few-shot examples +

Task description +

Format constraints → for best results in structured content generation.

The correct answer is A — zero-shot prompting refers to asking an LLM to perform a task without providing any prior examples in the prompt . In UiPath Agentic Automation, this is considered the simplest form of task prompting and is often used when:

The request is straightforward or familiar to the LLM

There's no need for detailed context or task demonstration

You want rapid generation without lengthy prompt design

UiPath distinguishes zero-shot , few-shot , and chain-of-thought prompting as part of its Prompt Engineering Toolkit . While zero-shot is fast and scalable, it’s not ideal for nuanced or ambiguous tasks , which often benefit from few-shot examples or structured reasoning steps.

Option B is misleading — complex scenarios usually require more grounding.

C contradicts the definition of zero-shot.

D confuses prompting with model fine-tuning , which is a separate concept.

Zero-shot works well for common, templated tasks (e.g., classifying "Is this urgent?") but is less reliable in dynamic, multi-intent agent behaviors.

A is correct — in UiPath’s agent framework, a system prompt serves as the agent’s core grounding mechanism . It is responsible for:

Defining the agent’s identity (“You are an IT support assistant...”)

Outlining its goal (“Your job is to classify, triage, and resolve tickets...”)

Setting operational boundaries and behaviors

Specifying when to escalate to a human or use tools

This aligns with UiPath’s Context Grounding strategy , which separates system prompts , user prompts , and tools orchestration . The system prompt provides persistent context , guiding the LLM's behavior consistently across user interactions and actions.

Option B downplays its influence — which is critical.

C reduces it to output formatting, which is only a small part.

D is unrealistic — LLMs generalize; they don’t require enumerating every path.

Correct system prompting ensures safe, consistent, goal-aligned behavior from the agent across dynamic scenarios.

D is correct — in Task Capture and BPMN modeling , the Exclusive Gateway is the BPMN element that represents a decision point . It is used to:

Split the process into mutually exclusive paths

Route flow based on a condition or choice

When mapping these processes to agent behavior , the Exclusive Gateway typically translates to a “Decision” node , where the agent:

Evaluates logic (e.g., “Is amount > $10,000?”)

Selects one path forward (e.g., “Escalate” vs. “Auto-approve”)

This is a fundamental construct in UiPath’s agentic process modeling , enabling agents to handle branching logic , make contextual choices, or call different tools based on runtime data.

Option A (Task) represents an activity, not a decision.

B (Swimlane) is used to group actions by role — not functional logic.

C (User Task) represents human involvement — not branching conditions.

UiPath emphasizes decision modeling to make agents adaptive and responsive , and Exclusive Gateways are the tool to model such decisions cleanly and visually.

The correct answer is B — UiPath’s Agentic Blueprint Design process emphasizes the importance of grounding automation opportunities in real user context and operational pain points .

During the validation stage , developers and stakeholders assess:

Specific persona roles and responsibilities

Current pain points and time-consuming tasks

Impact potential of agent assistance

This ensures the agent story reflects value-driven automation , not just technical ambition. It also validates that the agent solves a real bottleneck — such as handling repetitive approvals, prioritizing requests, or managing context-based escalations.

UiPath warns against the pitfalls outlined in A, C, and D:

A and D overlook persona-centricity , which is essential.

C skips the critical discovery and mapping phase that should come before prototyping.

By focusing on B, teams ensure their agent is purpose-built for the right users, delivering measurable outcomes aligned to business needs.

D is correct — the defining feature of few-shot prompting is the inclusion of multiple input-output examples within the prompt to demonstrate the desired behavior or output structure to the LLM.

In UiPath’s Agentic Prompting practices, few-shot examples help:

Anchor the model to a consistent format

Reduce ambiguity in task instructions

Improve performance in tasks like classification, transformation, or content generation

Example:

Input: “My password isn’t working.”

Output: “Category: Login Issue”

Input: “App won’t open.”

Output: “Category: Access Error”

This trains the model within the prompt — no fine-tuning required — making it a powerful design pattern in building intelligent agents.

Option A describes chain-of-thought prompting .

B refers to zero-shot prompting .

C refers to prompt chaining , used in advanced orchestration, not few-shot logic.

D is correct — including well-designed examples in prompts is a key part of few-shot learning , which helps LLM-based agents better understand the task structure, output style, and expected behavior .

UiPath encourages the use of examples for:

Classification (e.g., labeling sentiment, email categories)

Transformation tasks (e.g., turning unstructured text into tables)

Step-by-step instructions (e.g., troubleshooting flows)

These examples serve two purposes:

Pattern induction : The model picks up on consistent structures or rules used across examples.

Generalization : With diverse examples, the agent can apply logic to unseen but similar cases.

Best practice:

Use typical, real-world examples representative of the data the agent will encounter.

Keep formats clear and consistent across input-output pairs.

Pair examples with explicit instructions in the system or user prompt.

Option A is flawed — focusing only on edge cases can confuse the model.

B is false — omitting examples forces the LLM to guess the structure, reducing accuracy.

C is misleading — examples improve performance but do not guarantee perfect output ; testing and evaluation are still required.

In short, prompt engineering with examples is essential to building reliable, generalizable, and scalable AI agents.