Cohere AI Engineer interview questions

The most frequently asked applied GenAI question, and the one most candidates turn into a definition dump. What the interviewer wants is a decision framework with a default and the conditions that override it. Here is the call that earns points.

Alignment has become a baseline expectation even beyond 'safety' roles. The interviewer is looking for the three-stage RLHF pipeline and a sharp account of why DPO threw out the reward model completely. Here is the answer that leads with mechanism, not the buzzwords.

A tidy fundamentals question that trips up anyone who only knows GPT. The signal is pairing each architecture to its task through its attention pattern, and explaining why the field settled on decoder-only even for tasks that are not generation. Here is that answer.

Every customer wants to know how to stop the model inventing things. The weak reply is 'better prompts.' The signal is understanding why models hallucinate and stacking grounding, abstention, and measurement into a system you can defend.

Tokenization reads like plumbing until it accounts for your bill, your latency, and why the model stumbles on numbers and rare languages. The signal is understanding how subword tokenizers operate and the consequences that follow from them.

Every LLM product tunes these knobs, and the interviewer wants to hear what each one does to the probability distribution and which setting suits which task. That includes why factual and creative tasks call for opposite settings.

Embeddings are the foundation of modern NLP and retrieval. This tests whether you grasp the distributional idea behind them, not just 'words become vectors.' What matters is how training on context yields geometry that encodes meaning.

Perplexity is the classic LM metric. What matters is knowing it is just exponentiated cross-entropy, what it intuitively captures, and why low perplexity does not mean a good product.

PEFT is how everyone fine-tunes large models now. What matters is the low-rank insight behind LoRA, why it cuts memory so sharply, and what 4-bit QLoRA adds. Here is the answer that goes past 'it's efficient fine-tuning.'

What separates a demo prompt from a production prompt is structure, versioning, and defense. What matters is treating the system prompt as a contract and templates as parameterized, testable artifacts. Here is the answer.

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.

Instruction tuning converts a bare next-token predictor into a model that obeys instructions. What you are being tested on is slotting it correctly into the pretrain to SFT to alignment pipeline and stating precisely what it does and does not repair.

Fine-tune a model on your domain and it may lose the ability to do everything else. What earns the signal is explaining why shared weights cause it and listing the concrete mitigations that all boil down to one principle.

PEFT is a family, not only LoRA, and interviewers test whether you know how each one injects trainable parameters. The signal is where each method adds capacity and the latency and quality tradeoffs that result.

The classic automatic metrics for generated text. Interviewers want you to pair each with its task and identify the blind spot common to all three. Candidates who pass explain why none of them is the last word on quality.

Fine-tuning lives or dies on data, not on hyperparameters. What shows depth is spelling out what makes a set good (quality, diversity, format, dedup) and defending why a few thousand clean examples outperform a million noisy ones.

LLM-as-judge is how you grade open-ended generation at scale, and G-Eval put a formal frame on it. What shows depth is naming the biases that make raw judge scores untrustworthy and demonstrating exactly how you harden them.

Cross-attention is how a model attends from one sequence into another, the mechanism behind encoder-decoder models and multimodal conditioning. What shows depth is knowing exactly where the queries versus keys/values come from.

This is an architecture and business decision, not a religious one. What shows depth is weighing capability, cost, privacy, control, and operational burden, then committing to a call instead of declaring 'open is always better.'

RLAIF and Constitutional AI trade human preference labels for AI-generated ones to scale alignment. What shows depth is naming exactly what they substitute for human feedback, and the consistency-versus-bias tradeoff that swap introduces.

DPO simplified RLHF, and a family of variants now trade off what data and reference model they require. The signal is knowing what each variant drops or alters (reference model, paired data, separate SFT stage). Here is the answer.

How you decode from the model's probabilities shapes the output as much as the model itself. The signal is knowing the deterministic vs sampling methods and where each fits (factual vs creative). Here is the answer.

BERT and GPT diverge on one decision made before a single weight is trained: what does each token get to see? That choice ripples into attention, use case, and why one family now dominates. Here is the answer.

Multilingual models are uneven across languages, and most candidates cite only the obvious cause. The differentiator is the tokenizer: the same sentence can cost a non-English user several times as many tokens. Here is the answer.

A transformer emits one vector per token, but retrieval needs one vector per text. The signal is knowing the pooling options and the catch nearly everyone overlooks: the model has to be trained for whichever one you pick.

RAG and fine-tuning get cast as either/or. RAFT trains the model to be good at RAG itself. The tell is what goes into the training set: relevant docs mixed with distractors. Here is the answer.

Hand-tuned prompts break on the next model upgrade and fail to compose across pipeline stages. Frameworks like DSPy compile prompts against a metric instead. The signal is treating prompting as an optimized program. Here is the answer.

The senior signal is fitting the method to what is genuinely missing rather than reaching for your favorite. Knowledge, behavior, or actions each steer you to a different tool. Here is the decision framework that scores highest.

A single trained embedding you can cut to any length and still use. The signal is the nested-prefix training objective and the coarse-to-fine retrieval win it enables at scale. Here is the answer.

Token count is latency and dollars, not merely style. 'Be concise' hardly works, and max_tokens just cuts off mid-sentence. Here is how to genuinely shape length without amputating answers.

Alignment that piles on refusals and politeness often quietly erodes reasoning and coding. The alignment tax is real and measurable. Here is how to hold onto the safety gains without paying for them in capability.

Push any proxy hard enough and the model discovers the exploit, not the goal. Sycophancy, padding, and fake citations are reward hacking. Here is why it happens and the controls that actually hold.

Neural text degeneration is a known failure of likelihood-maximizing decoding, not a broken model. The fixes are specific decode-time knobs. Here is which lever to reach for and what each one costs.

Generation has to end somewhere, and the wrong stop rule either truncates answers or wastes tokens on trailing garbage. Here is how the EOS token, stop strings, and max-token caps actually interact.

When a drug name or a Hindi word splits into nine subword tokens, you pay in cost, context, and accuracy. Adding tokens is easy and adding them well is not. Here is the tradeoff.

A few thousand carefully chosen examples can beat a million scraped ones. The signal is knowing which filters matter, how you gauge example quality, and why diversity beats raw volume.

DPO is simple and stable, but it can drive down the probability of chosen responses, overfit the preference margin, and magnify length bias. The signal is naming these and the variants that fix each.

A reward model can only match the quality of its labels, and human preference labels arrive noisy and inconsistent. The signal is measuring inter-annotator agreement and the concrete steps that raise label quality.

Pairwise asks which one wins, pointwise asks how good a single output is. The signal is knowing which is more reliable, how Elo/Bradley-Terry aggregates comparisons, and where each method quietly misleads.

A reward model converts pairwise preferences into a scalar signal RLHF can optimize. The signal is the Bradley-Terry loss, the base-model and head choices, and how you validate it before trusting it.

By swapping costly human labels for an LLM's preferences, RLAIF scales cheaply but carries over the labeler model's biases. What matters is how AI feedback gets gathered and where it silently breaks down.

Modern embedding models expect a task instruction prepended to the text, and a wrong prefix quietly wrecks retrieval. The signal is why instructions help and the asymmetric query/passage convention.

Autoregressive models commit one token at a time, left to right. Diffusion language models generate the whole sequence at once and refine it over several denoising steps, which buys parallel decoding and global editing but has not yet caught the frontier. The signal is knowing the tradeoff, not just the buzzword.

A paraphrased prompt comes back with a training answer, verbatim. This is small-dataset SFT overfitting, not the pretraining memorization problem people confuse it with, and the fix has a strict order of operations.

Appending every turn is the default in tutorial code and it fails twice: on the context window and on cost. The signal is the layered assembly, the constraints you refuse to let the summarizer touch, and what you do the moment the user changes subject.

Every LLM is one function: tokens in, a distribution over the next token out. The signal is what you say next, because the distance from that function to a useful assistant is three training stages, and almost every production complaint lands in exactly one of them.

Definitions take thirty seconds. The interview is about the four things log-probs buy you in production: a confidence signal, banning tokens, guaranteeing valid output, and classification you can calibrate. Plus the tokenization gotcha that quietly breaks all of them.

The follow-up every interviewer holds in reserve after you say you fine-tuned something. A task-metric win proves almost nothing on its own. Here is the five-part protocol that separates a shipped model from a demo.

Most staleness complaints are not model problems, and the engineer who says so first wins the round. Here is which changes belong in the index, which belong in the weights, and the lifecycle machinery that keeps months of refreshes from eroding the model.

A one-word rewrite moving your accuracy several points is not a prompting problem, it is an uncalibrated decision function. The fix is measuring the model's prior over labels and dividing it out, not another round of tinkering.

Three different systems are failing at once (the tokenizer, the model, and your pipeline) and most candidates blur them into one. Separating them tells you which fix buys the most, and the highest-leverage one is not the prompt.

The most repeated trick in prompt engineering, and the evidence for it is much thinner than the folklore. A screening question for whether you measure your prompts or inherit them from a thread of screenshots.

One of the most common AI, ML, and GenAI design rounds. Sketching embed-retrieve-generate is easy; the signal lives in chunking, hybrid retrieval, the rerank/latency tradeoff, and how you prove it works. Here is the structure that scores.

The two knobs that decide whether a RAG system works, and the two candidates tend to gloss over. The signal is tuning chunking against recall and knowing precisely what dense retrieval drops that BM25 recovers. Here is the reasoning, not the rules of thumb.

Most RAG systems ship without genuine evaluation, which is why most of them quietly degrade. The signal is breaking evaluation into retrieval and generation, and scoring faithfulness apart from relevance. Here is the framework that makes RAG improvements measurable.

Enterprise RAG breaks on isolation, not on retrieval quality. The signal is enforcing tenant and document-level permissions server-side, at retrieval time, so the model can never surface data a user is not allowed to see. Here is the design that survives a security review.

Every RAG system rests on a vector index, and the interviewer wants proof you grasp the recall/latency/memory tradeoff, not just 'use a vector DB.' The signal is why exact search will not scale and how HNSW and IVF place different bets.

Retrieval quality is bounded by the query, and raw user queries are frequently poor for search. The signal is knowing the techniques that rewrite the query ahead of retrieval and which failure each one fixes.

Vector RAG quietly breaks on two query shapes: multi-hop chains and global 'what are the themes' questions. The signal is knowing precisely what the graph gives you and the construction cost it demands.

Retrieving every time is wasteful and occasionally harmful; retrieving never leads to hallucination. Self-RAG turns retrieval into a decision the model controls, then critiques what came back. The signal is the retrieve-on-demand plus self-critique loop.

Chunking quietly caps RAG quality, and 'split every 500 tokens' leaves recall on the table. The signal is knowing the strategy families and the parent-child trick that separates retrieval size from context size.

Citations turn a RAG answer from 'trust me' into something checkable, and they are a genuine engineering problem. The signal is grounding each claim to a specific passage and verifying the attribution, not tacking a bag of links onto the end.

Real corpora contradict themselves (old versus new policy, different teams), and naive RAG quietly picks one or fuses them into a wrong answer. The signal is spotting conflict and resolving it through recency, authority, and transparency.

The embedding model is the base of retrieval, and swapping it is deceptively risky. The signal is choosing on domain-relevant retrieval quality (not a leaderboard) and knowing that a new model means re-embedding everything. Here is the answer.

Dense versus sparse is the core retrieval tradeoff, and 'just use embeddings' quietly loses every exact-match query. The signal is knowing what each representation captures and why production blends them. Here is the answer.

Garbage parsing means garbage retrieval, and naive PDF text extraction wrecks tables and reading order. The signal is fixing the parser, not the retriever. Here is the answer.

Real documents carry images, charts, and tables, not only text, and text-only RAG quietly drops them. The signal is knowing the two retrieval approaches and why the generator has to change too. Here is the answer.

RAG and agents turn expensive and slow quickly: retrieval plus reranking plus big-model calls, multiplied across agent steps. The signal is naming the dominant cost first, then the levers that genuinely move it. Here is the playbook.

Reranking is the cheapest large win in RAG quality: pull a broad set, then reorder it precisely. The signal is the bi-encoder-versus-cross-encoder distinction and the retrieve-then-rerank two-stage design. Here is the answer.

Pure vector search drops exact terms; pure keyword search drops meaning. The signal is understanding why each fails on its own and how to merge two rankings on incomparable scales without hand-tuning weights. Here is the answer.

Single-shot retrieval breaks on questions that chain facts ('who directed the highest-grossing film of 2019?'). The signal is decomposing or iterating retrieval rather than retrieving once, and guarding against errors compounding across hops. Here is the answer.

A RAG system is only as current as its index, and stale or duplicated content quietly degrades answers. The signal is an incremental pipeline with deletes, updates, and recency signals, rather than a one-time bulk load. Here is the answer.

Late interaction reaches cross-encoder-like quality with near-bi-encoder scalability. The signal is the per-token embeddings plus MaxSim matching that earns you the middle ground, and understanding what it costs. Here is the answer.

Pushing every query through one pipeline wastes latency, money, and precision. A router decides what each query actually needs. The signal is naming the four decisions a router makes and how you stop a misroute from sinking the answer.

A short question and the passage that answers it sit in different neighborhoods of embedding space. HyDE bridges that gap by embedding a fake answer rather than the question. The signal is understanding why a wrong hypothetical still retrieves the right docs.

Small chunks match precisely but starve the LLM of context; big chunks carry context but match badly. Parent-child retrieval declines to choose. The signal is separating what you match on from what you feed the model.

A chunk embedded in isolation forgets which document, section, and entity it came from, so it retrieves poorly. Contextual retrieval writes that context back in before indexing. The signal is fixing retrieval at index time rather than query time.

Fixed-size chunking cuts a coherent idea mid-thought; semantic chunking splits on meaning. The signal is naming the methods (structure-aware, embedding-similarity, LLM-based) and the tradeoffs that decide which one to ship.

Standard RAG retrieves once and generates; agentic RAG makes retrieval an iterative, reasoning-driven loop. The signal is the agent deciding whether, what, and when to retrieve, then re-retrieving until the evidence holds.

Standard RAG trusts whatever it retrieves, even when it's irrelevant. Corrective RAG scores retrieval quality and acts on it. The signal is the grade-then-correct loop: re-retrieve, fall back to web search, or discard.

RAG failures are usually retrieval failures, yet most teams measure only the final answer. The signal is scoring retrieval on its own (recall@k, precision@k, MRR/nDCG) to pin down exactly where the system breaks.

Late chunking reverses the usual order of operations to solve the lost-context problem with zero additional LLM calls. Everything hinges on which step runs first. Here is the answer.

A model that leads MTEB can still stumble on your jargon-heavy corpus, and most teams reach straight for the costly fix. There is a ladder, and the cheap rungs are the ones people skip. Here is the order to climb it.

When the right answer isn't even in the top-50, the generator can't rescue you. Low recall has a short list of usual suspects. Here is the order to check them so you fix the cause, not a symptom.

More chunks means higher recall but also more noise, more cost, and more lost-in-the-middle. The right k is an empirical tradeoff, not a default of 5. Here is how to find it.

Late interaction keeps one vector per token, so a corpus that fit in a few GB as single vectors can swell 100x. Interviewers want to see you know the compression and indexing tricks (centroids, residuals, PLAID) that make multi-vector retrieval shippable.

A single embedding cannot capture a question with three independent parts. Interviewers want to see you know when to split a query, how to retrieve and recombine per sub-query, and the latency and drift costs that make decomposition a net loss on simple questions.

HyDE produces a fake answer to embed, which helps on vague queries but actively hurts on factual or out-of-domain ones. Interviewers want to hear you name precisely when the hypothetical document misleads retrieval and which multi-draft and hybrid variants recover.

An answer can be correct yet still unfaithful, asserting things the retrieved context never said. The signal is scoring faithfulness against the context, not against truth, and knowing why LLM-judge faithfulness scores drift.

Pushing top-k higher raises recall but buries the answer in noise, and a tight reranker raises precision but can discard the one chunk you needed. The signal is knowing which metric caps the system and how to move both with a retrieve-wide-then-rerank shape.

Hybrid retrieval only beats either method when the fusion is tuned. The signal is knowing why you cannot simply add BM25 and cosine scores, how RRF's k constant behaves, and when a learned weight beats rank fusion.

An off-the-shelf cross-encoder is general; your domain carries jargon and relevance rules it never encountered. The signal is knowing when fine-tuning pays off, how to mine hard negatives, and how to avoid training a reranker that merely memorizes your retriever's mistakes.

A 0.91 cosine score and a useless passage are not a contradiction. The candidates who score here name the encoding mismatch, the topical-but-not-answering chunk, and why an absolute score cutoff was never going to work.

Six stages, six isolating experiments, six metrics. The candidates who score do not guess at knobs, they bisect the pipeline, and they instrument the rungs nobody else does: ranking, context assembly, generation.

Retrieval is exonerated, so the bug lives in generation. There are four usual causes and they have different fixes, and the one nobody names is that the model was never given permission to say it does not know.

float32 is far more precision than ranking needs. int8 is close to free, binary is 32x smaller, and the difference between a working binary index and a recall disaster is one word: rescoring.

Beam search is the decoding algorithm everyone cites and few can code correctly. The signal is keeping k hypotheses by cumulative log-prob, adding logs (not multiplying probs), and handling completed sequences and length. Here is a correct implementation and the tradeoffs.

The core operation beneath every embedding/RAG retrieval, posed as a coding exercise. The signal is vectorizing the similarity, normalizing correctly, and using a partial selection (argpartition) rather than a full sort. Here is the efficient implementation and the scaling follow-up.

BPE powers GPT-style tokenizers, and coding it shows you grasp how subword vocabularies get constructed rather than just knowing they exist. What interviewers watch for is the repeated merge of the most common adjacent pair.

Every chat model's 'temperature' and 'top_p' knobs come down to a few lines of logit surgery. Implementing them proves you understand decoding rather than just calling it. Here is the from-scratch version.

Ahead of transformers, this was the language model, and it remains the clearest way to prove you grasp what perplexity truly measures. Smoothing is where people slip up. Here is the implementation.

Every RAG system packs a prompt, and the packing bug is always the same one: the input fits the window exactly, so the model has nowhere left to answer. The arithmetic here is what separates a candidate who has shipped from one who has read about it.

Every RAG system starts here, and most candidates ship the same bug: they size the chunk in characters and call it tokens. Below is running code for all four strategies, plus the infinite loop in the overlap arithmetic and the one in the recursion.

Anyone can call a rerank endpoint. The word doing the work in this question is 'prove': you have to implement DCG, ideal DCG, and nDCG@k from graded labels and report the before-and-after. Plus the ceiling nobody mentions until it bites them in production.

Everyone can write the happy path. The screen is decided by the two branches most candidates skip: what the system does when retrieval finds nothing good, and what it does when the model cites a chunk you never sent.

Metric learning succeeds or fails on the pairs you feed it. Random negatives teach almost nothing, and the margin plus the mining strategy determine whether the embeddings are any good. Here is how the choices interact.

Accuracy against a held-out label is the wrong instrument for a system with no single right answer, an open failure space, and a metric that is itself a model. Here is what breaks, what survives, and what replaces it.

The moment a company runs LLMs in more than one place, it needs a gateway. The signal is the cross-cutting concerns (cost, reliability, observability, governance) that a gateway consolidates, not merely 'proxy the API.' Here is the design.

Selling RAG as a product means wrangling messy ingestion, multi-tenant isolation, and per-customer index freshness, all behind a simple API. See the ingestion and query planes, how to keep tenants isolated, and how to hand customers eval and observability.

Moving a cloud-API POC into a bank or defense network kills your model provider, your judge API, and your vendor dashboards in one stroke. Learn the signed-bundle supply chain, local evaluation loop, and zero-egress observability that make an air-gapped LLM stack actually operable.

Routing each request to the right model is one of the biggest LLM cost/latency levers in production. What counts is matching query difficulty to model capability and knowing when the cascade pattern beats a classifier.

Eyeballing a few outputs does not scale, and a prompt tweak that fixes one case quietly breaks ten. A real LLM eval pipeline pairs a versioned dataset, layered scorers, and a CI gate. Here is the architecture.

FP8 serving is fast and usually fine, until it quietly degrades on the one workload your benchmark did not cover. What counts is knowing what FP8 breaks and how to validate it. Here is the recipe.

RLHF with PPO is not one model training, it is four models in the loop at once, three of them on the GPU during every step. The memory math and the generation bottleneck are what catch people out.

The classic closer, and most candidates answer it with a horoscope or a list of tool names. The signal is whether you hold an actual view, can justify it from what is already happening, and know what it means for the job.