Free Snowflake SnowPro Specialty: Gen AI (GES-C02) Sample Questions

Correct answers: A, B, C — Custom instructions can guide SQL generation behavior using natural-language guidance embedded in the semantic model; Custom instructions can be used to block or redirect questions about specific restricted topics via question categorization; Custom instructions support separate, more structured guidance for different parts of the Analyst workflow through modular components

• A. Custom instructions let administrators write natural-language guidance that steers how Cortex Analyst generates SQL for a given semantic model.
• B. The question categorization component of custom instructions is specifically designed to block or redirect questions on restricted topics.
• C. Custom instructions support modular, structured components covering different parts of the workflow, such as SQL generation and question categorization, rather than a single flat instruction blob.
• D. This is incorrect; custom instructions supplement the semantic model's tables, facts, and dimensions rather than replacing the need to define them.
• E. This is incorrect; custom instructions are configured within a given semantic model's YAML, so they are scoped per model rather than being account-wide only.

Correct answer: A — Call the endpoint with the default streaming behavior, which sends the response as server-sent events

• A. By default the agent:run API streams the response as server-sent events, which is exactly how an application can display output token-by-token as it is generated.
• B. Setting stream to false disables streaming and returns a single consolidated JSON response instead of incremental tokens, which is the opposite of what is needed here.
• C. Manually polling a status endpoint is unnecessary and slower than using the API's built-in streaming mode for incremental output.
• D. DATA_AGENT_RUN returns a non-streaming JSON response and does not provide token-by-token output; the REST API's streaming mode is the appropriate choice instead.

Correct answer: A — Change the model name argument passed to AI_COMPLETE to reference an available catalog model

• A. This is correct: catalog models such as Claude, Llama, and Mistral are called serverlessly by simply swapping the model name argument, with no separate deployment needed.
• B. This is incorrect: registering a custom model class is for bringing in externally trained models, not for switching between already-available catalog LLMs.
• C. This is incorrect: retraining weights is unnecessary and far more effortful than simply pointing the function call at a different catalog model.
• D. This is incorrect: provisioning dedicated GPU compute is unnecessary since catalog LLMs are already served in a fully managed, serverless way.

Correct answer: D — Snowflake Intelligence, a configured conversational layer built on top of Cortex Agents

• A. This is incorrect: adapting model weights is a training activity and does not provide an end-user-facing, configuration-driven chatbot interface.
• B. This is incorrect: containerized model hosting addresses infrastructure for custom models, not a business-user-facing conversational interface.
• C. This is incorrect: a terminal-based coding assistant targets engineers writing code, not business employees asking conversational questions.
• D. This is correct: this product delivers a configurable, no-code chatbot experience by packaging the orchestration already provided by Cortex Agents for end users.

Correct answer: A — Explicitly enumerate the allowed category labels in the prompt and instruct the model to return only one of those exact labels.

• A. Correct. Listing the exact allowed labels in the prompt and telling the model to return only one of them constrains its output space, which is the direct prompt-design fix for invented categories. Giving the model a closed set of choices makes off-list labels much less likely.
• B. Incorrect. Removing all instructions and constraints gives the model more freedom, not less. That makes invented, off-list category names more likely, which is the opposite of the goal.
• C. Incorrect. Warehouse size affects the compute resources available to the query, not the content or constraints of the prompt sent to the model. A larger warehouse does not make the model follow a category list it was never given.
• D. Incorrect. Embedding model choice and vector dimensionality matter for search and similarity tasks, not for a text-classification prompt sent to AI_COMPLETE. Switching to a smaller embedding model does nothing to stop the model from inventing labels.

Correct answers: A, B, C, D — AI_COMPLETE; AI_CLASSIFY; AI_FILTER; AI_EXTRACT

• A. AI_COMPLETE supports image inputs with vision-capable models, allowing prompts that combine text instructions with an image for tasks like description or analysis.
• B. AI_CLASSIFY supports classifying image inputs into user-defined categories in addition to text.
• C. AI_FILTER supports evaluating a boolean condition against image input in addition to text.
• D. AI_EXTRACT supports extracting structured information from images and documents in addition to plain text.
• E. VECTOR_L1_DISTANCE operates on numeric vector values already produced by an embedding step; it does not accept a raw image as direct input.
• F. GRANT USAGE is a SQL privilege statement for access control and has nothing to do with accepting image input for AI processing.

Correct answers: A, B, C, D — VECTOR_COSINE_SIMILARITY, for angular similarity between two vectors; VECTOR_L2_DISTANCE, for Euclidean distance between two vectors; VECTOR_INNER_PRODUCT, for a magnitude-weighted dot product between two vectors; VECTOR_L1_DISTANCE, for Manhattan distance between two vectors

• A. This is correct: this function measures angular closeness between two vectors, which is a real, documented vector similarity function commonly used with text embeddings.
• B. This is correct: this function computes Euclidean straight-line distance between two vectors and is a real documented distance function.
• C. This is correct: this function computes the dot product between two vectors, factoring in both direction and magnitude, and is a real documented vector function.
• D. This is correct: this function computes Manhattan (sum of absolute differences) distance and is a real documented vector function, often faster than Euclidean distance at high dimensions.
• E. This is incorrect: there is no vector-native classification function under this name; category assignment on text or images is handled by the AI_CLASSIFY function instead.
• F. This is incorrect: there is no function that converts a vector produced by one embedding model into another model's vector space; re-embedding the source input is required instead.

Correct answers: A, B, D — AI_SENTIMENT is row-level, returning one sentiment result for each input text; AI_CLASSIFY is row-level, returning one classification result for each input text; AI_AGG is an aggregate function that collapses many rows into one instruction-driven output per group

• A. This is correct: sentiment extraction evaluates one input text and returns one sentiment result for it, with no aggregation across rows involved.
• B. This is correct: classification evaluates one input at a time and returns category labels for that single input, making it a row-level operation.
• C. This is incorrect: this function is an aggregate that synthesizes a summary across every row in a group, it does not return a separate summary per individual row.
• D. This is correct: this function is documented as an aggregate that combines many rows into a single instruction-driven output per group, similar in spirit to GROUP BY aggregates.
• E. This is incorrect: translation operates on one text value at a time and has no aggregate behavior or GROUP BY requirement.
• F. This is incorrect: PII redaction operates on one text value at a time and returns scrubbed text or detection spans for that single input, it does not merge findings across rows.

Correct answer: A — SNOWFLAKE.CORTEX_ANALYST_USER

• A. This database role is scoped specifically to Cortex Analyst usage, so granting it gives a caller exactly the access needed without extending broader Cortex privileges.
• B. This is a general administrative role for managing database objects; it does not inherently grant the ability to call Cortex Analyst.
• C. This role has global account privileges, which is far broader than necessary and violates least-privilege design for a chat-with-data feature.
• D. This role grants access to Cortex functions more broadly than Analyst alone, so it is not the narrowest role available for this specific need.

Correct answers: B, D, E — Planning; Tool execution; Reflection

• A. Fine-tuning adjusts model weights ahead of time and is not a runtime step an agent performs while handling an individual request.
• B. The agent first analyzes the request, disambiguates it if needed, and decides which tools to call, which is the planning stage of the loop.
• C. Training a model is a separate offline process unrelated to how an already-configured agent handles an incoming request.
• D. After planning, the agent calls the selected tools, such as Cortex Analyst or Cortex Search, to gather the information needed to answer.
• E. The agent evaluates the results returned by its tools to decide whether to clarify, call further tools, or produce a final response, which is the reflection stage.

Correct answers: C, D — block; stage

• A. local volumes provide ephemeral storage shared between containers within the same service instance and do not persist once that instance is gone.
• B. memory volumes are RAM-backed scratch space that disappears when the container stops, so they do not persist data beyond the instance.
• C. block volumes provide persistent storage that survives service restarts, making them suited for stateful workloads that must retain data.
• D. stage volumes expose the contents of a Snowflake stage, which is durable storage outside the service instance, so data written there persists independently of the container's lifecycle.
• E. warehouse is not a valid volume type at all; virtual warehouses provide SQL compute and have no relationship to container storage mounts.

Correct answer: A — Load the MLflow pyfunc model in Python and pass it to log_model

• A. Because MLflow pyfunc models are natively supported by log_model, loading the existing pyfunc object and passing it directly to log_model registers it without retraining.
• B. Manually exporting to a Docker image and building compute pool infrastructure is unnecessary extra work when native MLflow support already exists in the registry.
• C. Retraining from scratch discards the existing MLflow-tracked model entirely and is not required since native import support exists.
• D. Converting to a SQL UDF is not a supported or necessary step for bringing an MLflow pyfunc model into the Model Registry.

Correct answer: A — A stream on the stage's directory table captures newly landed audio files, and a scheduled task calls AI_TRANSCRIBE against each new file reference and inserts the results into a transcripts table.

• A. Correct. A stream on the stage's directory table exposes only newly arrived files as change rows, so a scheduled task consuming it processes each recording once and avoids reprocessing earlier files. `AI_TRANSCRIBE` is the Cortex function built for audio transcription and can return timestamps and speaker labels when called on each new file reference, and the results are inserted into a transcripts table.
• B. Incorrect. Running `AI_TRANSCRIBE` against every file in the directory table each night reprocesses recordings that were already transcribed, which wastes compute and AI function credits. Overwriting the transcripts table also risks losing or duplicating historical results, and it violates the requirement not to reprocess handled files.
• C. Incorrect. `AI_COMPLETE` is a general text, image, and prompt completion function and is not the function designed to transcribe audio into timestamped, speaker-labeled text. The correct function for this purpose is `AI_TRANSCRIBE`, so this design would not reliably produce the required transcripts even with incremental refresh.
• D. Incorrect. `AI_SUMMARIZE_AGG` aggregates and summarizes text across multiple rows, so it cannot transcribe audio content into text with timestamps and speaker labels. Although the stream correctly detects new files, the transcription function is wrong for this requirement.

Correct answer: A — Lower MIN_NODES so the pool scales down further during idle periods while keeping MAX_NODES high enough for peak demand.

• A. Correct. MIN_NODES sets the floor the compute pool never drops below, so lowering it lets the pool shrink further overnight and cuts the standing GPU cost. Keeping MAX_NODES high enough still lets the pool scale out to absorb demand bursts during business hours.
• B. Incorrect. A different Model Registry version changes which model artifact serves inference, but it does not change the pool's MIN_NODES setting. The pool would keep the same minimum number of GPU nodes running overnight, so idle cost stays the same.
• C. Incorrect. Image repository retention only controls how long stored image tags are kept. It does not affect how many nodes the compute pool keeps running, so it does not reduce idle GPU cost. Faster node startup also does not lower the standing cost of the minimum nodes.
• D. Incorrect. Adding endpoints only changes which ports the service exposes for network traffic. Compute pool scaling is governed by MIN_NODES and MAX_NODES, so extra endpoints do not release idle GPU nodes or lower overnight cost.

Correct answers: A, B, C, D, F — AI_COMPLETE is the recommended replacement for the legacy COMPLETE function and accepts both text and image inputs.; The legacy COMPLETE function is being phased out and AI_COMPLETE is described as the canonical function going forward.; AI_CLASSIFY is the direct successor to the legacy CLASSIFY_TEXT function and covers SQL text classification workloads.; AI_EMBED supersedes the legacy EMBED_TEXT_768 and EMBED_TEXT_1024 functions for creating vector embeddings from text.; AI_PARSE_DOCUMENT supersedes the legacy PARSE_DOCUMENT function for extracting text and layout from staged documents.

• A. Correct. `AI_COMPLETE` is the recommended successor to the legacy `SNOWFLAKE.CORTEX.COMPLETE` function. It also extends beyond the older text-only function by accepting image inputs alongside text prompts.
• B. Correct. The legacy `COMPLETE` function is kept for backward compatibility but is being phased out. `AI_COMPLETE` is positioned as the canonical, go-forward function, so new and migrated SQL should target it.
• C. Correct. `AI_CLASSIFY` is the newer form of the legacy `CLASSIFY_TEXT` function. Both assign categories to text, so SQL text classification workloads can move to `AI_CLASSIFY`.
• D. Correct. `AI_EMBED` replaces the older fixed-dimension `EMBED_TEXT_768` and `EMBED_TEXT_1024` functions. It consolidates vector embedding generation from text under a single AI_* function name.
• E. Incorrect. Legacy Cortex functions are not removed immediately. They continue to exist alongside the AI_* functions and are being phased out gradually, so existing `COMPLETE` calls do not fail in every account after the AI_* release.
• F. Correct. `AI_PARSE_DOCUMENT` is the newer form of the legacy `PARSE_DOCUMENT` function. It extracts text and layout from staged documents and is the recommended path going forward.

Correct answer: A — Call the Complete function from the snowflake.cortex Python module inside the existing Python DataFrame pipeline.

• A. Correct. The `snowflake.cortex` Python module exposes `Complete`, which can be called directly on Snowpark DataFrame data inside an existing Python codebase. This adds the LLM step in the middle of the current workflow with no rewrite, and it keeps execution and data inside Snowflake, where it can run on a schedule.
• B. Incorrect. `AI_COMPLETE` is a valid SQL function, but rewriting the whole Python pipeline in SQL is a large and unnecessary effort. The same completion capability is already available from Python, so the team can keep its existing DataFrame transformations.
• C. Incorrect. Exporting the DataFrame to an external system to call a REST API, then reimporting the results, adds data movement, latency and operational complexity. The completion can be run in place from Python, so this round trip is not needed.
• D. Incorrect. Calling an external LLM provider's API from Python sends data outside Snowflake's governed environment. It also adds external credentials and network dependencies, when Cortex offers an equivalent in-platform function that can be called from the same Python code.

Correct answers: A, B, C, D — Improving chunking and retrieval so the model is grounded in the most relevant passages.; Choosing a more capable model when a task needs deeper reasoning over retrieved context.; Adding CUSTOM_INSTRUCTIONS or prompt guidance that restricts answers to the provided context.; Using semantic reranking to surface the most relevant passages ahead of less relevant ones.

• A. Correct. Better chunking and retrieval quality gives the model accurate, relevant source passages to base its answer on. Grounding the response in the right policy text reduces the need for the model to guess and fabricate.
• B. Correct. When a task needs deeper reasoning over retrieved context, a more capable model is more likely to synthesize an accurate answer. A smaller model tuned for speed or cost may misread or poorly combine the passages.
• C. Correct. Using `CUSTOM_INSTRUCTIONS` or prompt guidance to restrict answers to the provided context is a standard technique for reducing fabricated answers. It tells the model to decline or say it doesn't know rather than draw on unsupported knowledge.
• D. Correct. Semantic reranking improves the relevance ordering of retrieved passages. This makes it more likely that the most useful grounding content is included and prioritized in the final prompt.
• E. Incorrect. Randomly shuffling chunk order has no grounding benefit. It doesn't address the real cause of hallucination, which is missing or irrelevant context, and it can bury the most relevant passages.
• F. Incorrect. Removing all retrieved context eliminates grounding entirely. The model would then rely only on its prior knowledge, which makes hallucination more likely on internal policy content it has never seen.

Correct answers: A, B, C — CORTEX_USER is granted to PUBLIC by default, while AI_FUNCTIONS_USER is not; AI_FUNCTIONS_USER only covers scalar Cortex functions and excludes aggregate functions such as AI_AGG; CORTEX_USER grants broader access across Cortex AI functions than AI_FUNCTIONS_USER

• A. CORTEX_USER is granted to PUBLIC by default so that most Cortex functions work out of the box, whereas AI_FUNCTIONS_USER is not granted to PUBLIC and must be explicitly assigned.
• B. AI_FUNCTIONS_USER is scoped to scalar functions and specifically excludes aggregate-style functions like AI_AGG and AI_SUMMARIZE_AGG, unlike the broader CORTEX_USER role.
• C. CORTEX_USER grants access to the full set of Cortex AI functions, making it broader in scope than the more limited AI_FUNCTIONS_USER role.
• D. Setting the CORTEX_MODELS_ALLOWLIST parameter requires the ACCOUNTADMIN role and ALTER ACCOUNT privileges; it has no relationship to holding the AI_FUNCTIONS_USER database role.
• E. CORTEX_USER can be granted to any role, and in fact is granted to PUBLIC by default, so it is not restricted to ACCOUNTADMIN.

Correct answer: A — Keep the account allowlist restricted to the approved list for the contractor role's default access, and additionally grant the analytics role the specific per-model application role for the preview model

• A. Because RBAC is checked before the allowlist, granting the analytics role the specific model's application role lets it reach the preview model even though the allowlist otherwise restricts the account to the approved list used for the contractor.
• B. Opening the allowlist to 'All' would let the contractor role reach every model, directly violating the requirement to restrict the contractor to a short approved list.
• C. Blocking everything with no RBAC grants would also prevent the analytics role from reaching the preview model, failing the second requirement entirely.
• D. Granting CORTEX_USER to the contractor while withholding it from the analytics role reverses the intended access and does not grant the preview model access the analytics team needs.

Correct answer: A — AUTO_SUSPEND on the compute pool

• A. AUTO_SUSPEND automatically transitions an idle compute pool to the non-billed SUSPENDED state after inactivity, which stops credit accrual without manual intervention.
• B. A resource monitor can alert on or cap overall account or warehouse credit usage, but it does not automatically suspend a specific idle compute pool.
• C. A masking policy controls how column data is displayed to different roles and has no relationship to compute pool billing states.
• D. A network policy restricts client connections by IP address and does not affect whether a compute pool keeps accruing idle charges.

Correct answer: A — Run the COUNT_TOKENS function against the prompt text to estimate token volume before invoking the generative function

• A. COUNT_TOKENS reports token counts for given text without invoking the model itself, letting the engineer estimate cost ahead of running the actual generative workload.
• B. Running the function on even a single row still incurs an actual inference charge, which is exactly the cost the engineer is trying to estimate without incurring first.
• C. CORTEX_ANALYST_USAGE_HISTORY tracks Cortex Analyst requests, not AI_COMPLETE token usage, so it would not provide a relevant estimate for this workload.
• D. Token count depends on text length and content, not row count, since a single row can contain many tokens; row count alone is not a valid proxy for token volume.

Correct answer: A — SNOWFLAKE.CORTEX_AGENT_USER

• A. This is correct: calling a Cortex Agent is authorized by holding either CORTEX_USER or this agent-scoped role, which was purpose-built for that use case.
• B. This is incorrect: this role is scoped to Cortex Analyst requests and is not documented as sufficient for calling an agent by itself.
• C. This is incorrect: this role only covers embedding functions and managed search embeddings, unrelated to agent invocation.
• D. This is incorrect: this role covers scalar AI functions but explicitly excludes Cortex services such as Agents.

Correct answer: A — Call SNOWFLAKE.MODELS.CORTEX_BASE_MODELS_REFRESH() so model objects and their application roles are populated

• A. This is correct: the model objects in SNOWFLAKE.MODELS and their corresponding application roles must be populated via this refresh call before any model-specific role can be granted.
• B. This is incorrect: disabling the allowlist before RBAC grants are in place would leave users with fully-qualified model calls unable to fall back, so the refresh and grant steps must happen first, in that order.
• C. This is incorrect: the SNOWFLAKE.MODELS schema is system-managed and populated by the refresh procedure, not something an administrator manually drops or recreates.
• D. This is incorrect: this broad database-level privilege is not the documented prerequisite for enabling model-specific RBAC; the refresh procedure is what populates the grantable roles.

Correct answer: A — It marks the overall input and output of a single application invocation, anchoring record-level metrics such as answer relevance and correctness

• A. RECORD_ROOT designates the top-level call whose input and output represent the whole record, which is where record-level metrics like answer relevance and correctness attach.
• B. Retrieval functions are tagged with the RETRIEVAL span type, not RECORD_ROOT, so that context relevance can be computed against the retrieved chunks specifically.
• C. Generation functions are tagged with the GENERATION span type; RECORD_ROOT is not limited to token or latency capture and covers the whole record instead.
• D. Writing to the event table is an internal platform mechanism, not something a developer tags with a span type, and RECORD_ROOT has no connection to storage cost attribution.

Correct answer: A — External Agent objects share a namespace with model objects in the schema, so their names cannot collide

• A. External Agent objects share a namespace with model objects within a schema, so an existing model object with the same name will block creation of an External Agent using that name.
• B. External Agents are created in the developer's own schema, not restricted to the SNOWFLAKE system database, so that is not the source of this naming conflict.
• C. Creating an External Agent does not require the CREATE MODEL privilege or draw from a model quota; the conflict here is purely a duplicate-name issue in a shared namespace.
• D. External Agent names have no required relationship to Cortex Search service names, so a missing search service is not what is causing this registration failure.

Correct answers: A, B, C — The account-level USE AI FUNCTIONS privilege, or the relevant per-function grant, was revoked from both PUBLIC and the role.; The specific model being called is neither covered by a granted RBAC model role nor permitted by the account's allowlist.; The role is using Restricted Caller's Rights without the required CALLER-qualified privilege grants held by the owning role.

• A. Correct. Holding SNOWFLAKE.CORTEX_USER does not by itself guarantee access, because the account-level USE AI FUNCTIONS privilege (or the relevant per-function grant) is a separate layer. If it has been revoked from both PUBLIC and the role, the call fails even though the role holds the database role.
• B. Correct. Model-level access is governed separately from the feature-level CORTEX_USER role. If the specific model is neither covered by a granted RBAC model role nor permitted by the account's allowlist, the call fails regardless of the role holding CORTEX_USER.
• C. Correct. Under Restricted Caller's Rights, the owning role's access is limited to privileges granted as CALLER-qualified grants. If those grants are missing, execution can fail even when the calling role is otherwise fully provisioned with CORTEX_USER.
• D. Incorrect. Password rotation age is an authentication hygiene control and has no documented effect on authorization to call Cortex AI functions. A password policy may force a reset at login, but it does not selectively block Cortex functions for a session.
• E. Incorrect. Cortex AI function availability is governed by the privilege, role and model-access grants described in the other options, not by requiring Business Critical edition. Being on a different edition is therefore not a documented reason for this failure.

Correct answer: A — Enable Cortex Guard by setting guardrails to true in the COMPLETE call, so outputs are screened for unsafe content.

• A. Correct. Cortex Guard is Snowflake's native safety filter, and enabling it by setting guardrails to true in the `COMPLETE` call screens model output for harmful categories such as hate, violent content, and self-harm. Unsafe responses are replaced automatically, so no custom application logic is needed to meet the compliance requirement.
• B. Incorrect. `AI_REDACT` is designed to detect and mask personally identifiable information in text, not to evaluate content for hate speech, violence, or self-harm. It has no setting for stripping those categories, so it cannot meet the content-safety requirement.
• C. Incorrect. Temperature controls the randomness and creativity of generated text, not its safety. Changing it gives no guarantee against harmful content and is not a compliance control, and raising it would make outputs more random rather than more conservative.
• D. Incorrect. Restricting the account allowlist limits which models can be used but adds no content-safety filtering to their outputs. Smaller models can still generate unsafe content, so this does not satisfy the requirement for native filtering.

Correct answer: A — Iterate the response's pages array and reference each element's content field alongside its zero-based index field

• A. When page_split is TRUE, the response contains a pages array whose elements each expose a content field and an index field identifying that page's position.
• B. There is no single combined content field once page_split is enabled, and pageCount is not a mechanism for splitting text by newlines.
• C. The images array holds extracted picture content when extract_images is enabled; page-level text is never rerouted into image objects.
• D. The metadata field is tied to setting return_error_details to TRUE, not to page_split, so its availability does not depend on page splitting.

Correct answer: A — 2,000 pages

• A. The April 2026 platform update raised AI_PARSE_DOCUMENT's supported page count to 2,000 pages for both OCR and LAYOUT modes.
• B. 500 pages understates the current documented limit after the April 2026 increase, which raised the ceiling well beyond that figure.
• C. 300 pages reflects an earlier, lower ceiling and is no longer accurate after the documented April 2026 page-limit increase.
• D. AI_PARSE_DOCUMENT does enforce a documented maximum page count per call in addition to any token-related constraints on output size.

Correct answer: A — Load the files into a stage, then reference them via TO_FILE()

• A. Both functions operate on FILE objects created from documents sitting in an internal or external stage, and TO_FILE() is the mechanism used to reference a staged document in the call.
• B. Storing raw bytes in a VARIANT column bypasses the stage-based FILE reference these functions expect, so it is not a supported input path.
• C. A Snowpark DataFrame represents tabular query results, not a staged document reference, so it cannot substitute for a FILE object built from a stage.
• D. The model registry stores machine learning models and artifacts, not source documents awaiting parsing or extraction, so it is unrelated to this requirement.

Correct answer: A — It fails, since a single call allows at most 100 entity questions and 10 table questions

• A. AI_EXTRACT limits a single call to at most 100 entity extraction questions and 10 table extraction questions, so requesting 120 entities and 12 tables exceeds both caps and the call fails.
• B. The function does enforce documented per-call caps on both entity and table questions, so there is no unlimited-question behavior to rely on here.
• C. The actual documented caps are 100 entity questions and 10 table questions per call, not the lower thresholds stated here.
• D. Exceeding the documented caps produces a failure rather than a silent truncation of the request down to the allowed limits.

Correct answers: A, B, C — A SCHEDULE expression, using either a fixed interval or a cron pattern, that runs the task on a recurring cadence; An AFTER clause that positions the task as a child of a predecessor task within a task graph; A WHEN clause using SYSTEM$STREAM_HAS_DATA so the task only executes its body when the referenced stream has unconsumed records

• A. SCHEDULE accepts either a fixed interval like '5 MINUTE' or a cron-style expression, both of which are standard, documented ways to run a standalone task on a recurring cadence.
• B. AFTER defines a task's position in a task graph as a child of one or more predecessor tasks, causing it to run once its predecessors complete rather than on its own independent schedule.
• C. SYSTEM$STREAM_HAS_DATA is commonly used in a task's WHEN clause to conditionally skip execution when the associated stream has no new change records, avoiding wasted runs.
• D. Changing table ownership is an access-control operation and has no relationship to task scheduling or triggering; it does not cause any task to fire.
• E. Task comments are free-text metadata for documentation purposes only; Snowflake does not parse them for scheduling keywords or derive execution timing from them.

Correct answer: A — The EXECUTE TASK privilege on the account, or ownership of the task combined with the appropriate operate privilege

• A. Executing or resuming a task requires the EXECUTE TASK privilege (typically granted at the account level to the role that manages the task) along with sufficient ownership or operate rights on the task object itself; this is separate from privileges needed to call Cortex functions.
• B. CORTEX_USER governs access to Cortex AI functions like AI_COMPLETE or AI_PARSE_DOCUMENT; it does not grant the ability to execute or resume a task, which is a distinct object-level operation.
• C. USE AI FUNCTIONS gates access to AI/Cortex functions, not task execution; a role could hold this privilege and still be unable to run or resume a task without EXECUTE TASK.
• D. MONITOR on a warehouse allows viewing warehouse usage and status, but it does not grant the ability to execute or resume a task; that requires the task-specific EXECUTE TASK privilege.

Correct answers: A, B, C — Query CORTEX_FUNCTIONS_USAGE_HISTORY for hourly usage aggregated by function, model, and token or credit consumption; Query METERING_HISTORY to track overall credits consumed by AI services alongside other account activity; Attach a resource monitor with a defined credit quota to the warehouse running extraction queries so the team is alerted before costs exceed a threshold

• A. CORTEX_FUNCTIONS_USAGE_HISTORY provides aggregated hourly usage broken down by function, model, and token or credit consumption, which is exactly the breakdown the dashboard needs. This is a purpose-built view for Cortex cost tracking.
• B. METERING_HISTORY reports overall credit consumption across account activity, including AI services, giving a broader cost picture alongside the function-level detail from the Cortex usage view. Combining both views supports a complete cost dashboard.
• C. A resource monitor with a credit quota on the relevant warehouse provides proactive alerting before spend gets out of hand, which directly supports the FinOps goal of tracking and controlling cost. This is a standard cost-governance practice.
• D. The default query history page does not surface the aggregated, function-level Cortex credit and token breakdown that dedicated usage views provide. Relying on it alone would leave the dashboard missing key cost detail.
• E. Resource monitors do not interfere with how token-based billing is calculated, since they operate independently as a spend-control mechanism. Disabling them removes a useful safeguard rather than protecting billing accuracy.
• F. Warehouse size does not change the per-token billing rate charged for Cortex functions, so increasing it would add warehouse compute cost without lowering extraction costs. This contradicts documented cost guidance for Cortex functions.

Correct answer: A — Reduce the warehouse to Medium or smaller, since larger sizes do not improve Cortex function performance and only add extra compute cost.

• A. Correct. Snowflake's cost guidance recommends a warehouse no larger than Medium when calling Cortex functions, because the inference runs on Snowflake-managed compute rather than on the warehouse. Since latency did not improve on the 2X-Large, scaling down to Medium or smaller removes the wasted warehouse credits without any performance loss.
• B. Incorrect. Cortex functions are billed by the tokens processed, and that rate does not change with warehouse size. Keeping the 2X-Large warehouse would only keep adding warehouse credit spend on top of the token charges, with no discount in return.
• C. Incorrect. A multi-cluster warehouse adds concurrency for many simultaneous queries, but it does not make a single Cortex function call run faster. It would also add compute cost without addressing the cost problem the review identified.
• D. Incorrect. Cortex inference throughput does not scale with warehouse size, so the 2X-Large warehouse already showed no latency gain over Medium. Moving to 3X-Large would increase credit consumption further with no expected speedup.