reliability

Complex tasks rarely fit one prompt, and free-text LLM output rarely drops into code cleanly. What matters is decomposing into chained steps and parsing each output. Here is the answer that ties prompting to real pipelines.

Models are trained to be helpful, which quietly teaches them to never refuse. Restoring honest abstention is a system problem, not a prompt tweak. Here is the stack that actually shifts the refuse-when-unsure rate.

Few-shot accuracy can swing on example order by itself. If your prompt is fragile to things that shouldn't matter, the fix is structural, not lucky example-hunting. Here is what genuinely reduces variance.

Agents get reached for too often. A strong answer pushes past the hype: most tasks are better served by a single structured call, and agents pay off only under particular conditions. Here is when one is worth it and how to stop it from compounding errors.

Agents and integrations depend on the model returning valid, schema-conforming output. The signal is stacking constrained decoding, schema validation, and retries, rather than trusting a prompt to do the job. Here is the production-reliability answer.

Multi-agent is the pattern most often reached for without cause in AI today. The signal is holding back unless the task genuinely calls for specialization or parallelism, knowing the supervisor and handoff patterns, and grasping why coordination magnifies failure.

Tool selection and parameter extraction are where agents quietly break. The strongest answer treats the tool spec as the only thing the model sees, then repairs the design, not the model. Here is how.

One model can behave completely differently depending on the harness wrapped around it. The signal is recognizing that the scaffolding frequently sets agent quality more than the underlying model does. Here is the answer.

A computer-use agent operates a real browser or desktop via screenshots and clicks. The signal is the perceive-decide-act loop together with the containment for an agent that can click, buy, or delete anything. Here is the answer.

An agent that retries the same failed action 40 times means a runaway bill and a stuck user. Termination is something you build into the harness, not something the model reliably decides. Here is the control layer.

Real tools time out, rate-limit, and hand back malformed JSON. An agent that assumes every call succeeds is a demo, not a product. Here is the error-handling layer that keeps it running in production.

The industry uses 'agent' for anything that calls an LLM. The distinction that matters is how much control you hand to the model, and more autonomy is not better. Here is the spectrum and the decision rule.

Per-step accuracy looks fine, yet a 50-step task fails. The signal is grasping compounding error and the techniques (decomposition, verification, checkpointing) that keep long-horizon agents from collapsing.

Screen-driving and browser agents break in ways chat agents never hit: stale DOM, pages that keep shifting, misplaced clicks. What interviewers watch for is the grounding and reliability methods that move a flaky demo toward something dependable.

A model can rank perfectly and still output meaningless probabilities. The signal is knowing precisely when calibration matters, how to measure it, and the post-hoc fixes. Here is the answer most candidates miss.

Agents that loop for minutes, invoke tools, and spawn sub-tasks demand durable execution rather than one request handler. See how to checkpoint state, recover after failures, cap runaway loops, and trace every move a non-deterministic agent makes.

A provider outage should cost you quality, not the feature. The answer that scores is a pre-decided fallback ladder, a timeout policy that treats slow as down, and the discipline to test the path you hope never runs.

Classic SRE SLOs assume a request is right or wrong. ML predictions are probabilistic and labels lag, so naive uptime SLOs miss the failures that count. Here is how to set SLOs that actually cover model quality.

ML incidents are trickier than service outages: nothing crashed, the model was just wrong. The strong answer covers detection, mitigation, and a blameless postmortem that fixes the system, not the person.

A 256-GPU job that freezes with no error at 3am is a special kind of pain. The causes come from a short, recurring list. Here is the systematic way to identify which one hit you.

On a large training run a node will drop, and the interesting question is not whether but how many GPU-hours vanish when it does. Checkpoint cadence, sharded writes, and quick restart settle that.

AI fails in ways traditional software does not: bias, hallucination, harmful output, silent quality regression. The strong answer is a concrete playbook (detect, contain, communicate) plus a blameless post-mortem that ships systemic fixes. Here is the answer.

Most candidates answer this with a speech about tradeoffs. The ones who get hired describe a mechanism: the teams that ship fastest in AI are not the ones with fewer guardrails, they are the ones whose guardrails make a mistake cheap.