UiPath-AAAv1 UiPath Certified Professional Agentic Automation Associate (UiAAA) Questions and Answers

The correct answer isC—Business Process Model and Notation (BPMN)is astandards-based modeling languageused byprocess excellence practitionersto visually define, communicate, and govern business workflows.

In UiPath’sMaestroorchestration platform, BPMN acts as acollaborative bridgebetween:

Business stakeholders(who define processes and goals)

Technical implementers(who build automations and agent logic)

BPMN includes rich constructs such as:

Gateways for conditional logic

Events for escalations and errors

Tasks, subprocesses, and human interventions

This makes itideal for dynamic, agentic workflows— not just static process mapping.

A and B are false — BPMN is built foradaptive,automated, andcollaborativeorchestration.

D is wrong — BPMN supportserror handling, retries, and fallback flows, all critical in agentic automation.

Cis correct — according to UiPath documentation,key-value pairs stored in Agent Memorypersist for12 months by default.

Agent Memoryis a persistent storage layer allowing agents to:

Recall decisions or context across runs

Store user preferences, status, or temporary flags

Maintain statefulness without relying on external databases

This capability is especially useful for:

Omnichannel customer interactions

Preference-aware recommendations

Tracking previously taken actions for continuity

Although memory storage is long-lasting (12 months), developers can:

Manually resetor expire entries

Use different memory scopes (e.g., per-user, per-agent)

Design memory-aware flows for personalization

Option D is incorrect — memory isnot auto-cleared on version updates.

A and B understate the retention policy — default expiration is clearly documented as12 monthsunless changed manually.

Agent Memory is a powerful enabler ofcontext-rich, stateful automations, especially for conversational or ongoing interactions.

Comprehensive and Detailed Explanation (from UiPath Agentic Automation documentation):

The correct approach isC, as it best reflects thefew-shot prompting pattern, which is a well-documented and recommended technique in both UiPath Autopilot™ and broader agentic AI design for improvingintent classificationaccuracy.

InUiPath Agentic Automation, especially inPrompt Engineering, few-shot examples serve to "ground" the Large Language Model (LLM) with task-specific context. Providingstructured input-output pairs(as shown in option C) allows the model to learn from the context and mirror the expected output more reliably — enhancing classification precision.

For instance, UiPath recommends using clearly formatted training examples in this structure:

Input: "[Text]"

Output: "[Label]"

This aligns with UiPath’s guidance under thePrompt Engineering Framework, which highlights that usingfew-shot exemplars with clear task demonstrationsignificantly improves model performance over zero-shot or ambiguous input formats (as in options A or B). Option D also underperforms due to insufficient grounding.

UiPath emphasizes the importance oflabel clarity,format consistency, andexplicit instruction— all of which are satisfied in Option C. This method also supportspromptgeneralizationfor new inputs by modeling how categorization should happen, not just what categories exist.

This technique is crucial in real-world agentic workflows where LLMs handle noisy, unstructured data (like emails), and are expected to trigger appropriate downstream actions such as ticket creation, escalation, or filtering.

D is correct — a major advantage of UiPath-built agents is their low-code creation model, which allows business users and developers to quickly create, test, and deploy agents.

Key points from UiPath’s Agentic Automation platform:

Agents are built in Studio Web, using a drag-and-drop UI and agent designer canvas.

Low-code tools allow teams to design agent prompts, behavior logic, tool connections, and escalations without deep programming skills.

Agents integrate with UiPath Orchestrator for full lifecycle management.

UiPath’s low-code stack is designed to:

Lower the barrier to AI adoption

Accelerate time-to-value

Allow cross-functional teams to collaborate on intelligent automation

Options A and B are incorrect — agents support both structured and unstructured workflows, and fully integrate with Orchestrator.

C is false — low-code is a core value prop.

The correct answer isA— zero-shot prompting refers toasking 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 isstraightforwardorfamiliar to the LLM

There'sno need for detailed contextor task demonstration

You want rapid generation without lengthy prompt design

UiPath distinguisheszero-shot,few-shot, andchain-of-thought promptingas part of itsPrompt Engineering Toolkit. While zero-shot is fast and scalable, it’s not ideal fornuanced or ambiguous tasks, which often benefit fromfew-shot examplesor structured reasoning steps.

Option B is misleading — complex scenarios usuallyrequiremore grounding.

C contradicts the definition of zero-shot.

D confuses prompting withmodel 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.

The correct answer isB. This prompt follows UiPath’sbest practices for system promptsby clearly establishing agent identity, defining behavior logic, and including formatting constraints — all in a numbered, readable structure. The agent is given a clear role (“supplier invoices only”), boundary rules (“reject any other request”), and step-by-step instructions to follow. Numbered steps improve clarity and make parsing easier for LLMs.

The inclusion of tool usage (LookupInvoice) and conditional logic (≤ $10,000 vs > $10,000) mirrors UiPath’s orchestration standards. Importantly, it also specifies how to format the output using tags and instructs the agent to maintain a professional tone — critical elements in UiPath'sPrompt Engineering Framework.

Compared to options C and D, which introduce a rigid JSON format, Option B balancesstructure with flexibility. JSON-only prompts (like C) are good for strict APIs but lack the natural language behavior, tone control, and task-scoping essential in real-world agents. Option A is close but lacks step numbering, making it slightly less robust.

UiPath recommends system prompts include:

Agent persona and role

Tool instructions and decision rules

Tone and refusal handling

Clear, consistent output formatting

Option B satisfies all these criteria, making it the most robust, agent-ready system prompt.

Bis correct — to pass runtime values into an agent’s prompt in UiPath, you must:

Declare the variable inData Manager

Reference it inside theuser/system promptusingdouble curly braces, e.g., {{CUSTOMER_EMAIL}}

This ensures the platform can:

Substitute values at runtime

Maintain traceability between arguments and prompts

Provide context grounding for the LLM

Option A is incorrect — angle brackets are not used for substitution.

C is wrong — single braces {} are not valid for UiPath’s binding syntax.

D is unreliable — LLMs do not infer values from prose without structured substitution.

This technique ensures consistentparameter injectionfor context-aware agent behavior.

The correct answer isD— selecting“Argument”allows a field value in an activity (such as a connector or tool call) to bedynamically inferred at runtime, based on variables, agent state, or previous node outputs.

UiPath Autopilot™ and Studio Web use the“Argument”option inactivity configurationto passdynamic values, especially in agentic workflows where:

Outputs of one step must inform inputs of the next

Contextual reasoning or prompt outputs need to feed tool parameters

Escalation decisions or classifications affect API calls or record updates

This is fundamental in making agent behavioradaptive and responsive to user context— a key trait of UiPath’s agentic orchestration layer.

Other options:

A (Static value) is hardcoded

B (Clear value) wipes any existing input

C (Prompt) is used when engaging the LLM, not connectors

Cis the correct answer — the"Start and wait for external agent"feature in UiPath Maestro is used toinvoke another agentthat has been configured within thesame project or automation environment.

This enables:

Agent-to-agent chaining

Modular designwhere complex tasks are offloaded to specialized agents

Return of results or outputs, once the external agent completes its task

Agents must be:

Properly configured

Input/output ready

Available within the orchestration context of the same solution

Option A is incorrect — this feature is about agents, not robots.

B is wrong — external platforms like Salesforce are accessed via connectors,not as agents.

D is false — input/output parameters can and often should be used between agents.

Bis correct — one of the defining strengths ofUiPath’s agentic automationis the ability for agents toadapt to dynamic environmentsusingLLMs and contextual grounding.

Agents differ from traditional RPA bots in that they:

Interpret natural language

Reason across structured and unstructured data

Adjust outputs based onreal-time context, grounding, and updated knowledge

When processes change — such as updates to escalation rules, variations in incoming requests, or new product names — agents can adjust without reprogramming, thanks to:

Flexible prompts

Grounded context from indexes or memory

Few-shot or zero-shot inference capabilities

This adaptability makes agents ideal for scenarios likeemail triage,customer service, orknowledge work, where inputs and conditions vary.

Option A and D falsely suggest agents are rigid or fully dependent on human intervention.

Option C applies to classic RPA bots — not LLM-powered agents.

While agents don’t“learn”in the ML retraining sense during execution, theydynamically interpret and adaptwithin the context of each session — a key feature enabled by UiPath’s Autopilot™, Context Grounding, and agent memory frameworks.

This flexibility is foundational to deploying agents in environments whererules evolve, data flows shift, or human-like understanding is needed.

Dis correct — includingwell-designed examplesin prompts is a key part offew-shot learning, which helps LLM-based agents better understand thetask 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:

Usetypical, real-world examplesrepresentative of the data the agent will encounter.

Keep formatsclear and consistentacross input-output pairs.

Pair examples withexplicit instructionsin 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 butdo not guarantee perfect output; testing and evaluation are still required.

In short,prompt engineering with examples is essentialto buildingreliable, generalizable, and scalableAI agents.

Dis correct — in UiPath agent design, when adding anescalation, a key step is to provide aclear and contextual promptin theProperties panelthat tells the agentwhen and whyto trigger that escalation.

This prompt:

Informs the LLM of thebusiness logicbehind escalation

Sets thethresholds or exception casesthat warrant human review

Ensures escalation is usedintelligently and selectively

For example:

"If the customer expresses dissatisfaction and refund amount exceeds $500, escalate to supervisor."

This guidance is crucial becauseagents rely on prompts to decide, not just flow logic. Without a well-written prompt, the LLM may over-escalate or miss critical cases.

Option A is partially correct, butoutcome behaviorconfigureswhat happens after escalation— notwhen to trigger it.

B skips the logic layer entirely.

C refers to field requirements but doesn’t influence agentdecision-making logic.

The prompt within the escalation tool is where theLLM’s judgment gets guided, making D the essential step for enabling smart, situational escalations.

This is a repeat of Question 16, and the correct answer remains A.

Even when few-shot examples are included, omitting clear formatting instructions leads to inconsistent outputs, which can break downstream processes in agentic automation.

UiPath’s Prompt Engineering guidance emphasizes that instruction clarity is as important as examples — especially when output format matters (like agendas, classifications, or structured text).

An optimal prompt includes:

A task description (e.g., “Convert meeting notes into a 3-section agenda”)

Clear format instructions (e.g., use bullet points, bold headers)

Few-shot examples

Optional constraints like length or tone

Without that first element — clear instructions — the LLM has to guess the output format, leading to variance and unreliability.

Dis correct — this example follows thegold standard for few-shot prompting, as defined in UiPath’s Prompt Engineering methodology. The format usesclearly labeled input-output pairs, giving the agent:

Consistent structure to follow

Explicit tone classification

Variety across sentiment categories

Each example models the task exactly as it should be performed:

Input: [Text]

Output: [Label] (Positive, Neutral, Negative)

This design teaches the agenthow to recognize patterns in user tone, even with subtle expressions. It works especially well in LLM-powered agents that handlefeedback analysis,review classification, orcustomer support automation.

Option A (listing keywords) lacks structure and will not generalize well.

B is incomplete — there’s no output for the model to learn from.

C uses a rating scale, which doesn’t match the classification labels needed.

UiPath emphasizes thatwell-structured few-shot examplesimprove LLM accuracy dramatically — especially when working with ambiguous or emotionally nuanced language.

This approach improvessentiment classification precision, reduces hallucination, and ensures consistent labeling across varied input phrasing — making the agent more reliable in real-world scenarios.

The correct answer isD, and this is a foundational concept in UiPath’sAgentic Discovery and Design Blueprint methodology.

Anagent storyserves as aclear, narrative-driven blueprintthat describes:

What the agent does

For whom it works

When it activates

How it makes decisions

What success looks like

UiPath emphasizes that a well-crafted agent story ensures alignment betweenbusiness stakeholders,subject matter experts (SMEs), andtechnical developers. It keeps the development team focused on value delivery by outlining thecore capabilities,contextual behavior, andinteractionsof the agent in a human-readable form.

This approach is critical during thedesign phase, as it:

Prevents scope creep

Clarifies success metrics

Enhances stakeholder buy-in

Anchors prompt design, orchestration, and escalation logic

UiPath also uses the agent story to guidegrounding strategies, tool selection, and even escalation paths — making it much more than a documentation artifact.

Options A, B, and C misrepresent the function of agent stories. Only D captures its value in focusing the team onwhat matters most for delivering real business outcomes.