Free LangChain Certified Agent Engineer Sample Questions

Correct answer: A — deepagents is a separate package built on top of create_agent's core building blocks, not a replacement for it.

• A. deepagents is documented as a separate package that layers additional capabilities on top of create_agent's foundational building blocks, rather than replacing that foundation.
• B. There is no supersession relationship; create_agent remains the recommended choice for lightweight, low-level agent building and is not being phased out in favor of deepagents.
• C. deepagents depends on and builds directly on create_agent's core loop, so the two are not unrelated packages from different organizations with no shared foundation.
• D. create_agent is the standalone, lower-level builder function that exists independently of deepagents; deepagents consumes it as a foundation rather than exposing it only after adoption.

Correct answer: A — create_agent, since it offers explicit low-level control with minimal defaults for teams that want to define each component themselves.

• A. create_agent's minimal defaults and low-level control are exactly suited to a platform team that wants to hand-assemble every component of its own opinionated framework.
• B. deepagents is described as an opinionated harness with capabilities bundled in by default; that is a different design goal from a team wanting to assemble every piece itself from a minimal base.
• C. create_agent does not force adoption of filesystem tools, skills loading, or sub-agent spawning; those are deepagents harness features layered on top, not mandatory parts of create_agent.
• D. Both builders ultimately run on the same LangGraph runtime, and deepagents is not uniquely positioned to customize that runtime for a bespoke framework; create_agent's minimal defaults are what serve this goal.

Correct answer: A — `LoggingMiddleware.after_model` runs, then `AuthMiddleware.after_model` runs, the reverse of their registration order.

• A. This is correct because after hooks execute in reverse of the middleware registration order, so the last-registered middleware's `after_model` runs first and the first-registered runs last.
• B. This is incorrect because that is the order for `before_model` hooks, which run in registration order; `after_model` hooks run in the opposite, reverse order.
• C. This is incorrect because node-style hooks execute sequentially in a defined order, not concurrently, so there is no race between the two `after_model` calls.
• D. This is incorrect because every registered middleware's `after_model` hook runs on each pass; none are skipped simply because another middleware is also registered.

Correct answers: A, B, C — `PIIMiddleware` configured to detect and redact account-number patterns in conversation messages.; `HumanInTheLoopMiddleware` configured with `interrupt_on` scoped to the `wire_transfer` tool.; `ToolCallLimitMiddleware` scoped to the `wire_transfer` tool with a `thread_limit`.

• A. This is correct because `PIIMiddleware` directly addresses protecting account numbers by detecting and redacting sensitive patterns in the conversation.
• B. This is correct because scoping `HumanInTheLoopMiddleware`'s `interrupt_on` to the `wire_transfer` tool pauses that specific tool for human approval before it executes.
• C. This is correct because a per-tool `thread_limit` on `ToolCallLimitMiddleware` caps how many times `wire_transfer` can be invoked within a single conversation, preventing unlimited attempts.
• D. This is incorrect because `ModelFallbackMiddleware` addresses model provider outages, not PII protection, approval workflows, or capping tool invocation counts.
• E. This is incorrect because `LLMToolEmulator` is meant for testing by replacing real tool execution with simulated responses, which would be unsafe and inappropriate for production wire transfers.
• F. This is incorrect because `TodoListMiddleware` equips an agent with task planning and tracking, which does not address PII protection, approvals, or invocation limits.

Correct answer: A — The `name` field must be lowercase alphanumeric with hyphens and exactly match the parent directory name, and underscores break that match.

• A. The `name` field is defined as a lowercase alphanumeric identifier with hyphens that must exactly match the parent directory name; using an underscore instead of a hyphen produces a mismatch and fails validation.
• B. Nothing in the scenario indicates the `description` field was omitted, so a missing description is not the cause of this particular failure.
• C. There is no requirement that a skill folder contain a `scripts/` subdirectory; supporting folders like scripts, references, and assets are optional additions, not prerequisites for parsing.
• D. There is no rule tying `allowed-tools` to whether `name` matches the folder path; `allowed-tools` is an independent, optional field for pre-approving tool access.

Correct answer: A — `name` and `description`

• A. Only the `name` and `description` fields are injected into the system prompt for every configured skill at startup, which lets the agent discover skills without paying the token cost of every full body.
• B. `allowed-tools` is not part of the startup metadata injection; it governs which tools a skill may call once it has been activated and its body has been read.
• C. `compatibility` describes environment requirements and is not one of the two fields injected at startup for every skill.
• D. `license` records licensing terms and is not part of the startup metadata; it is only relevant once the full skill body is loaded.

Correct answer: A — Trimming drops older messages for one model call without touching state, while summarization permanently overwrites state with a generated summary.

• A. Trimming is a transient, per-call adjustment that never writes back to state, while summarization is persistent — it replaces older messages in state with a generated summary so future turns see the summary instead of the originals.
• B. This reverses the mechanics: trimming does not touch state at all, and summarization is the one that persists a permanent change, not a temporary one.
• C. Trimming uses simple heuristics like keeping the most recent K messages and requires no LLM call; it is summarization that relies on a model to condense older turns.
• D. Trimming never persists anything to state — only summarization writes a permanent replacement — so the two approaches do not behave identically with respect to state.

Correct answers: A, B — Once messages fall outside the `keep` window, only the generated summary represents them, so nuanced early details can be lost during condensation.; The summary permanently replaces the original older messages in state, so any information the summarization step dropped is not recoverable from that state.

• A. Details outside the preserved window exist only through the generated summary, so any nuance the summarization step failed to capture is genuinely gone from the model's view.
• B. Because summarization permanently overwrites state, once information is lost during condensation there is no original copy left in state to recover it from on later turns.
• C. There is no separate always-consulted transcript log; the middleware relies on the summary once older messages are condensed, so it can indeed lose information this way.
• D. Messages inside the `keep` window retain their original form and are not condensed, so contradictions on early facts are not explained by recent-turn messages being summarized.
• E. Summarization is lossy by nature since it condenses content through a model, so assuming perfect lossless compression contradicts the observed behavior of losing early details.

Correct answer: A — Sandboxing isolates the agent from the host system but does not prevent context injection attacks that make the agent issue harmful commands within its own isolated environment

• A. This is correct: sandboxes protect against direct filesystem and process interference with the host, but they do not prevent context injection — an adversary controlling agent inputs can still get the agent to run arbitrary commands within the isolated environment it has access to.
• B. Sandboxing's protection is not limited to network traffic; its documented scope covers filesystem and process isolation from the host, and that scope still does not cover injected instructions driving in-sandbox commands.
• C. The `execute()` primitive is a generic command-execution method with no built-in intent screening; it runs whatever script or command it is given and returns the output.
• D. Context injection remains possible even with a sandbox configured, which is precisely why reviewers are advised to treat sandbox outputs as untrusted and add additional controls.

Correct answer: A — `BaseSandbox` constructs the scripts for each filesystem operation and runs them through the subclass's `execute()` implementation

• A. This is correct: `BaseSandbox` builds the scripts needed for operations like `ls`, `grep`, and `edit_file` and runs them through the single `execute()` method, so a subclass only needs to implement `execute()` for all of these filesystem tools to work.
• B. These filesystem tools are part of the sandbox backend abstraction itself, implemented on top of `execute()`, not something wired in independently by a model provider.
• C. These tools run real generated scripts against the sandbox and return actual results; they are not stub implementations that always return empty output.
• D. This contradicts how `BaseSandbox` is designed: it deliberately implements filesystem operations on top of a single `execute()` primitive precisely so subclasses do not need to reimplement each filesystem method individually.

Correct answer: A — Offline evaluation scores a curated dataset with reference outputs, typically pre-deployment, while online evaluation scores production traces without reference outputs.

• A. Offline evaluation is defined by running against a curated dataset that pairs inputs with reference outputs, typically before deployment, while online evaluation scores production traces that carry only inputs and outputs, without a ground truth to compare against.
• B. This reverses the actual definitions: production trace scoring without reference outputs describes online evaluation, and curated datasets with reference outputs describe offline evaluation, not the other way around.
• C. Online evaluation specifically operates without reference outputs on production traces, so claiming both modes always require them misstates a defining difference between the two.
• D. This also reverses the definitions: continuous scoring of live traffic describes online evaluation, while a single run against a fixed dataset before release describes offline evaluation.

Correct answers: A, B, C — A filter that scopes the rule to runs matching specific criteria, such as unsatisfactory feedback or a particular tool call.; A sampling rate that controls what percentage of matching traces get scored.; A weekly LLM cost cap on the evaluator, overridable from an organization-wide default.

• A. Correct: automation rules support filters that work like trace filtering, letting the rule target only runs matching chosen criteria rather than everything.
• B. Correct: sampling rate is a standard automation rule setting that limits scoring to a percentage of matching traces to manage cost.
• C. Correct: online evaluators support a weekly LLM cost cap, settable per evaluator or falling back to an organization-wide default, directly addressing cost-awareness.
• D. Incorrect: online evaluators score traces without needing a reference-output dataset; pulling reference outputs to score each trace describes offline evaluation instead.
• E. Incorrect: comparing against a prior offline run's experiment is not a setting on an online automation rule, and no such ranking step gates whether the rule scores a trace.

Correct answer: A — A custom judge factory function that produces an LLM-as-judge evaluator tailored to their compliance rubric

• A. Writing a function that returns a configured judge with a custom prompt and scoring schema is the definition of a custom judge factory function for an LLM-as-judge evaluator.
• B. Regular expression keyword matching is a deterministic code-based check and does not involve returning a configured model-backed judge with its own rubric.
• C. An automation rule filters and samples production traffic for online scoring and is unrelated to authoring a judge's prompt and scoring schema.
• D. Ranking two prompts against each other describes a comparative evaluator, not a factory function that produces a rubric-based judge for a single output.

Correct answer: A — The percentage of labeled examples where the evaluator's judgment matches the human expert's label

• A. The alignment score is defined as the share of labeled examples where the judge's output agrees with the human-assigned label. It is the core metric alignment work is trying to raise.
• B. Coverage of production traces by reviewers describes labeling throughput, not whether the judge's decisions match those labels. That is a different, unrelated statistic.
• C. Latency differences describe timing performance between calls, not judgment accuracy. Alignment work is concerned with agreement, not speed.
• D. Whether a dataset example carries a reference output describes dataset composition, not how well the judge's verdicts match human labels. It is unrelated to the alignment metric itself.

Correct answer: A — The UI offers different paths for sending dataset evaluators versus tracing project evaluators to an annotation queue

• A. Because dataset-based experiments and tracing-project runs are surfaced in different parts of the UI, sending each to an annotation queue follows a different path even though both end up as human-labeled examples for alignment.
• B. Dataset evaluators can also be sent to an annotation queue for labeling; offline labeling is not a requirement, so this restriction does not hold.
• C. Merging the two workflows into a single dataset before labeling is not a required step, and doing so would conflate outputs with and without reference outputs unnecessarily.
• D. Dataset evaluators still go through human labeling before examples are committed to a reference dataset; there is no direct write path that skips the annotation queue.

Correct answer: A — Inherent sampling variance in LLM generations means repeated runs of an unchanged configuration can still differ in score

• A. LLM generations are inherently stochastic, so even an unchanged configuration can produce different outputs, and therefore different scores, across repeated runs on the same dataset.
• B. Assuming the dataset changed is an unnecessary leap when normal generation variance is a simpler and far more common explanation for score differences between repeats.
• C. There is no such caching behavior that forces identical outputs across runs, and treating a normal variance result as a caching bug would be misdiagnosing the situation.
• D. A well-built evaluator scores based on the actual output content; describing it as assigning purely random scores mischaracterizes evaluators as unreliable rather than pointing at the real source of variance, which is generation sampling.

Correct answers: A, B, E — Most examples were drawn only from traces where the application already succeeded fully.; Reference outputs were copied without verifying they reflect the actually correct answer.; Nearly identical near-duplicate inputs make up a large share of the example set.

• A. Sourcing examples mostly from already-successful traces skews the dataset toward the happy path and gives the evaluator little exposure to failure cases it should catch.
• B. If reference outputs are copied without verifying correctness, the dataset's ground truth is unreliable, which directly undermines the evaluator's ability to grade correctly.
• C. Mixing manually written and imported examples is a normal, supported way to build a dataset and is not inherently a source of evaluator blind spots.
• D. Organizing examples into splits is an organizational feature for structuring experiments and does not itself cause an evaluator to miss failing cases.
• E. A dataset dominated by near-duplicate inputs lacks diversity, so it fails to exercise the range of behavior needed to reveal cases the evaluator should be failing.

Correct answers: A, B, C, E — A new dataset version is generated automatically whenever examples are added or edited.; Version tags can mark milestones so a CI pipeline can target a specific historical version.; Splits are named subsets used to organize examples, separate from per-example metadata tags.; Metadata key/value pairs can be used to filter examples by group without creating a split.

• A. Dataset editing triggers automatic versioning, so changes to examples produce a new version without a separate manual step.
• B. Tagging a version marks a meaningful point in the dataset's history, and CI pipelines can target that tag to run against a fixed, known example set.
• C. Splits are a distinct organizational feature from per-example metadata, used to group examples into named subsets such as training or validation groups.
• D. Splits are optional; an example does not need to belong to any split to be included in an experiment or evaluation run.
• E. Metadata key/value pairs support filtering and grouping examples by tag without requiring the more structural step of assigning them to a split.

Correct answers: A, B, C — A deployment is created by taking a graph and running it with a specific configuration.; A single graph's code can be used as the basis for more than one deployment.; A deployment provides the control plane and data plane infrastructure the graph runs on.

• A. A deployment is created by taking a graph's code and running it under a specific configuration, which is precisely what turns a workflow definition into a running instance.
• B. The same graph's code can serve as the basis for multiple deployments, such as separate staging and production instances, each with its own configuration.
• C. A deployment supplies the control plane and data plane infrastructure that lets the graph actually run, handle configuration, and execute requests.
• D. A graph is a code-level workflow definition that exists on its own before any deployment is created from it, so it does not require a deployment to exist first.
• E. A deployment's revision history tracks its own version number independently, and there is no requirement that it match a version number on the graph's source code.
• F. Nothing restricts a graph to a single deployment; the same graph code can be reused across staging, production, or any number of separate deployments.

Correct answers: A, B, D — Load credentials from environment variables or a secret management service rather than embedding them in code.; Configure production secrets through the deployment platform's settings so they are scoped per revision.; Rotate a credential and redeploy whenever there is any indication that the value may have been exposed.

• A. Loading credentials from environment variables or a secret management service is the core recommended pattern for keeping sensitive values out of source code.
• B. Configuring production secrets through deployment platform settings scoped per revision keeps credential changes tracked and applied through a controlled redeploy process.
• C. Committing a `.env` file with production keys exposes those credentials to everyone with repository access and permanently to the commit history.
• D. Rotating a credential and redeploying once exposure is suspected limits the window during which a compromised key remains usable.
• E. Printing credential values to logs exposes them to anyone with log access, turning a routine startup check into a credential leak.
• F. Pasting credential values into chat messages creates an unmanaged, unauditable copy of the secret outside any access-controlled system.

Correct answers: A, B, D — Secrets can be set independently for each revision, so a new revision can introduce or change a credential value.; Rotating a credential typically requires creating a new revision through a redeploy rather than a live in-place edit.; Runs and threads created under an earlier revision continue to reflect the environment that revision was deployed with.

• A. Secrets are scoped per revision, so each new revision can introduce a new credential or change an existing one independently of prior revisions.
• B. Because secret changes apply to a new revision rather than being live-patched onto a running one, rotating a credential normally requires triggering a redeploy.
• C. Revisions do not automatically inherit later secret changes; each revision keeps the environment it was created with unless it is itself redeployed.
• D. Runs and threads tied to an earlier revision keep using that revision's environment, which is why an older run can still reflect a since-rotated credential.
• E. Secrets configured through deployment settings are managed by the platform separately from `langgraph.json`, not stored in plaintext inside the checked-in configuration file.

Correct answer: A — No — threads, runs, and checkpoints are persisted in the PostgreSQL backing store of the specific deployment that created them, so the EU deployment has no visibility into US deployment data.

• A. Runs, threads, assistants, and checkpoints are stored in PostgreSQL scoped to the deployment that produced them, so a separate EU deployment has its own independent backing store and cannot see the US deployment's thread history.
• B. There is no shared logical thread store spanning all deployments in an organization; each deployment persists its own resources independently, which is exactly why separate regional deployments can satisfy data-residency separation.
• C. Thread and checkpoint data is explicitly persisted for durability and later retrieval, not deleted right after a run finishes, so this explanation misstates how the storage layer behaves.
• D. No cross-deployment checkpoint mirroring on any interval is part of the documented architecture; each deployment's checkpoints stay within its own backing store.

Correct answer: A — Cloud deployments are confined to the regions LangChain operates on AWS/GCP (default plus EU opt-in), whereas Self-Hosted and Standalone Server let the customer pick any region their own infrastructure runs in.

• A. Cloud deployments are limited to whatever regions LangChain has actually stood up infrastructure in — a default region plus an EU opt-in — while Self-Hosted and Standalone Server deployments run on customer-operated infrastructure, so their region is simply wherever that infrastructure lives.
• B. This reverses the actual constraint — it is Cloud deployments that are limited to LangChain's supported regions, while Self-Hosted setups are the ones with full freedom over where the customer's own cluster runs.
• C. There is no shared global PostgreSQL cluster across deployment types; each deployment, whether Cloud, Self-Hosted, or Standalone, persists to its own backing PostgreSQL instance.
• D. Cloud deployments have a documented default hosting region and only require `LANGGRAPH_HOST_URL` when opting into the EU endpoint; Self-Hosted and Standalone Server region placement is determined by where the customer deploys their infrastructure, not by that variable at all.

Correct answer: A — Authentication confirms who is making a request, while authorization decides what that already-identified caller may do.

• A. This matches the platform's model: an authentication handler establishes identity on every request, and separate authorization handlers then gate what that identified caller can do to threads, assistants, and crons.
• B. This reverses the roles; permission decisions belong to authorization, while confirming credential validity is part of authentication, not the other way around.
• C. Filtering which threads are visible is an authorization concern handled by resource-level handlers, not a description of authentication, and authorization is not limited to network origin checks.
• D. Authorization does not re-verify identity at all; it consumes the identity already established by authentication and applies permission logic to resources instead.

Correct answers: A, B, C — Threads; Assistants; Crons

• A. Threads are scoped through the standard metadata-filter pattern, where a search or list handler returns a dictionary matched against thread metadata.
• B. Assistants are also scoped through the standard metadata-filter pattern used by resource search and list handlers.
• C. Crons follow the same metadata-filter pattern as threads and assistants for scoping search and list results.
• D. The Store resource is authorized differently: its handlers rewrite the mutable `namespace` field to scope access, rather than returning a metadata filter dictionary.
• E. Deployment revisions are managed through the deployment platform's own release process and are not one of the resources exposed to `@auth.on` handlers.
• F. Docker build logs are an infrastructure artifact from the build pipeline and are not a resource type that authorization handlers can scope access to.

Correct answer: A — `InMemorySaver` keeps checkpoints only in process memory, so restarting the process discards them regardless of the durability mode chosen.

• A. The durability mode only controls the timing of writes relative to graph execution; it does not change where the checkpointer stores data. An in-memory backend never survives a process restart no matter how synchronously it writes.
• B. Sync mode works with any checkpointer implementation, including `InMemorySaver`; it does not require Postgres or silently disable itself when a different backend is used.
• C. Even with the correct `thread_id` supplied, an in-memory backend has nothing to look up after a restart because the underlying process memory holding the checkpoints was cleared.
• D. Durability modes are not disabled based on build type; the checkpoint writes did occur, they simply landed in memory that did not survive the process restart.

Correct answer: A — A snapshot of graph state scoped to a thread, written at superstep boundaries as nodes complete their scheduled work.

• A. This is correct: a checkpointer captures thread-scoped graph state snapshots and writes them at superstep boundaries, which is the core mechanism enabling resumption and fault tolerance.
• B. The checkpointer persists intermediate state throughout the run, not just a final output message, which is what allows recovery from mid-run failures rather than only capturing the end result.
• C. This describes the store's cross-thread scope, not the checkpointer, which is deliberately scoped to a single thread rather than aggregating across a user's threads.
• D. The graph's code definition is not what the checkpointer persists; it persists runtime execution state, which changes throughout a run rather than being fixed at deployment.

Correct answer: A — The tool call's run was not properly closed with an end time, so LangSmith cannot compute the duration between start and end.

• A. Latency is computed from a run's recorded start and end timestamps, so a run that never receives an end event (for example, due to an unhandled exception in the tool wrapper) will show no computable duration.
• B. Nested runs are timed independently of the root run; per-run latency at every level of the tree is a core part of what the trace UI displays, not something reserved for the root alone.
• C. The run cap limits how many runs a trace can capture in total, but it does not selectively strip the latency field from an individual run while leaving its other data intact.
• D. Latency tracking applies to any run type, including tool and retriever runs, since duration is measured from timestamps rather than being restricted to LLM calls.

Correct answer: A — It fetches the nested run payloads under each matched run so the local traversal can access child-run detail alongside the server-side filter results.

• A. `load_child_runs` fetches nested run payloads so that after the server narrows results with a filter like `run_type`, the caller can traverse into child-run detail locally, combining server-side filtering with local access to nested data.
• B. Enabling `load_child_runs` does not override or disable the `run_type` filter; the two work together, with the filter narrowing results and this flag adding nested detail to what's returned.
• C. The query still returns run-level records; it does not collapse into an aggregate project-wide cost summary, which is a separate reporting view entirely.
• D. This flag does the opposite of restricting to root runs only; it is specifically for accessing child-run payloads nested beneath matched runs.

Correct answer: A — `list_threads` defaults to the last 24 hours, so the `start_time` parameter must be widened to cover two weeks ago.

• A. `list_threads` defaults to a start time of the last 24 hours, so conversations from two weeks ago are excluded unless `start_time` is explicitly widened to cover that window.
• B. There is no calendar-month restriction on `list_threads`; the actual default window is the last 24 hours, controlled by the `start_time` parameter.
• C. Threads are not automatically archived after 48 hours or made permanently unqueryable; the missing results stem from the default `start_time` window, not archival.
• D. No manual re-indexing step is required to query older threads; simply adjusting `start_time` on the query resolves the issue.

Correct answers: A, B — thread_id; session_id

• A. `thread_id` is the primary metadata key LangSmith looks for when grouping related traces into a single thread.
• B. `session_id` is recognized as a fallback metadata key, used to group traces into a thread when `thread_id` is not present.
• C. `conversation_id` is not a metadata key LangSmith looks for when assembling threads, even though it sounds semantically similar to conversation grouping.
• D. `trace_id` identifies an individual trace, not the higher-level thread that groups multiple traces together, so it is not used for thread grouping.
• E. `correlation_id` is a common pattern in distributed tracing generally, but it is not one of the keys LangSmith checks for thread grouping.
• F. `run_id` identifies a single run within a trace, not the conversation-level grouping that thread metadata provides.

Correct answer: A — Filter to Input, aggregated with Sum

• A. Filtering the token metric to Input isolates prompt-side spend, and summing across the 30-day window produces the total prompt-token cost the team wants, excluding completion costs.
• B. Output isolates completion-side token spend, which is exactly what the team wants to exclude, so this combination measures the wrong side of the cost.
• C. Filtering to Total mixes prompt and completion spend together instead of isolating prompt tokens, and Average returns a per-period mean rather than a running total for the month.
• D. Input does isolate prompt-side spend, but Percentile reports a distribution value like p95 rather than the cumulative total the team is asking for.

Correct answer: A — A feedback score attached to the corresponding run or trace, usable as a binary sentiment signal

• A. Thumbs-up/thumbs-down clicks are logged as feedback scores attached directly to the run or trace they refer to, giving a simple binary signal of user sentiment that can feed dashboards and alerts.
• B. Forwarding a feedback click does not create or modify an automation rule; automation rules are configured separately and can optionally use feedback as a filter condition, but the click itself is just a feedback score.
• C. Feedback clicks do not alter the run's cost breakdown; cost figures come from token usage and pricing data, which is unrelated to user sentiment signals.
• D. Feedback is recorded against the specific run or trace, not appended as a tag on the project's name, so project-level tagging is not how this signal is stored.

Correct answer: A — A multi-turn evaluator, built to assess an entire conversation thread at once.

• A. LangSmith online evaluations distinguish multi-turn evaluators, which handle entire conversation threads, from run-level evaluators for single runs, so a whole-thread quality check calls for the multi-turn option.
• B. Run-level evaluators assess a single run in isolation, such as one LLM call, which does not capture quality across an entire multi-turn conversation.
• C. An Insights report surfaces aggregate usage patterns and failure modes across many traces, but it is a distinct capability from configuring an evaluator to score conversation quality.
• D. A latency alert monitors a numeric performance metric over time, not the semantic quality of an entire conversation thread.

Correct answer: A — A Feedback Score alert that specifies `answer_helpfulness` as the feedback key, since this metric type requires naming which feedback score to monitor.

• A. Feedback Score alerts require specifying which feedback key to monitor, so naming `answer_helpfulness` is necessary for the alert to average that specific rating and detect a downward trend.
• B. The Errors metric tracks run failure status, and its filters scope by status, run type, tag, or error type, not by feedback key, so it cannot monitor a feedback score this way.
• C. Run Count reflects traffic volume rather than sentiment, so a percentage of run counts carries no information about whether users are rating responses as helpful.
• D. Latency measures execution speed and has no established relationship to user helpfulness ratings, so it cannot substitute for directly monitoring the feedback key.