Agentic AI terms interview questions and answers

Retrieval-augmented generation: before the model answers, relevant passages are retrieved from your own data (usually by embedding similarity) and added to the prompt, so the answer is grounded in current, citable information rather than only the model's training data.

The model is given tool definitions (name, description, JSON-schema arguments) and can respond with a structured request to call one. Your code runs the tool and returns the result as a message, and the model continues. It is the basic mechanism behind agents.

Models read and write tokens, pieces of words (roughly 3–4 characters of English each). The context window is the maximum number of tokens the model can consider at once, covering the prompt, history, retrieved documents, tool results and the answer. Cost and latency grow with tokens.

Confident but false output. Reduce it by grounding answers in retrieved sources and asking for citations, allowing 'I don't know', using tools for facts and calculations, constraining output formats, lowering temperature for factual tasks, and evaluating faithfulness.

The cycle of model call, optional tool calls, observing results and calling the model again until it produces a final answer or hits a limit. It is the core of almost every agent framework, whatever name it uses.

Instructions placed before the conversation that set the model's role, rules, tone and available context. It shapes every answer, and it should be stable, specific and tested, because small wording changes can change behaviour.

Making a model's answers rely on supplied, verifiable sources (retrieved documents, tool results, databases) rather than only its training data, usually with citations. It reduces hallucinations and makes answers checkable.

An embedding is a vector representing the meaning of text (or images). Similar meanings are close in vector space. Vector databases (pgvector, Pinecone, Qdrant, Weaviate) store embeddings and find the nearest ones quickly with approximate nearest-neighbour indexes such as HNSW.

The Model Context Protocol is an open standard from Anthropic for connecting AI applications to external tools and data. Servers expose tools, resources and prompts; clients such as Claude, ChatGPT, IDEs and agent frameworks connect to them over stdio or Streamable HTTP. Write a server once, use it everywhere.

Chain-of-thought is asking a model to work through intermediate steps before answering, which improves multi-step reasoning. Reasoning (or 'thinking') models are trained to do this internally, spending extra tokens on reasoning before the final answer, trading latency and cost for accuracy on hard problems.

Using a language model to grade outputs against a rubric or a reference answer, or to choose the better of two outputs. It scales evaluation but must be calibrated against human judgements and watched for bias.

Checks around a model or agent: input filters (prompt injection, disallowed topics), output filters (PII, toxicity, format validation), tool permission limits and policies that block or escalate actions. They can be rules, classifiers or other models.

A model, often a cross-encoder, that scores each candidate passage against the query together and reorders retrieved results. It is slower than vector search but more accurate, so it runs on the top results only.

Combining keyword search (such as BM25) with vector similarity search and merging the results, for example with reciprocal rank fusion. It catches both exact terms and semantic matches.

A repeatable test that measures model or system quality on a set of examples with scoring rules: exact match, code checks, human labels or LLM judges. Evals replace 'it looks fine' with numbers you can track across changes.

Several specialised agents that collaborate, through a supervisor, handoffs or a shared workspace, each with its own role, tools and context. It helps with complex, parallelisable tasks but adds coordination cost.

Direct injection is a user typing instructions to override the system prompt. Indirect injection hides instructions in content the model reads, such as web pages, emails or documents, which can make an agent take unintended actions.

Storing previous answers keyed by the meaning of the question (an embedding), so a new question that is similar enough reuses the answer. It cuts cost and latency but needs a careful similarity threshold to avoid wrong matches.

Prompting changes behaviour through instructions and examples, cheaply and instantly. RAG adds up-to-date knowledge at query time. Fine-tuning changes the model's weights to learn a style, format or task reliably; it costs more and is poor at injecting changing facts. Most applications start with prompting and RAG.

A sampling setting controlling randomness. Low temperature makes outputs more deterministic and focused; higher temperature makes them more varied and creative. Factual extraction uses low values; brainstorming higher ones.

Constraining a model to return data matching a schema (JSON Schema, Pydantic), using provider features or tool calling, so programs can parse results reliably instead of scraping free text.

Designing an AI workflow so a person reviews, approves, edits or rejects certain steps, typically risky actions or uncertain outputs, before the system continues.

Reasoning models spend extra tokens thinking before answering; a budget sets how many. More thinking improves hard tasks like maths and coding at the cost of latency and price.

Training a smaller student model to imitate a larger teacher's outputs, giving a cheaper, faster model that keeps much of the teacher's quality for a specific task.

Low-rank adaptation: fine-tuning by training small extra matrices added to a model's layers instead of all its weights. It is far cheaper in memory and storage, and adapters can be swapped per task.

A token limit is how much text fits in one request (context window) or one response (max output tokens). A rate limit caps requests or tokens per minute for your account. Exceeding either causes errors that apps must handle.

Short-term memory is the current conversation or task state in the context window. Long-term memory persists across sessions in a store (facts, preferences, past outcomes) and is retrieved when relevant.

A proxy between apps and model providers that adds a single API, routing and fallbacks between models, caching, rate limiting, cost tracking, logging and key management.

Providers can cache a long, repeated prompt prefix (system prompt, documents, tool definitions) so later requests reuse it at lower cost and latency. Put stable content first and changing content last to benefit.

Models that accept or produce more than text, such as images, audio, video or documents, so they can read screenshots, describe charts, transcribe speech or generate images.

1. AModel weights
2. BImages only
3. CRandom examples
4. DRetrieved, relevant documentsCorrect answer

Why: Retrieval supplies grounding context.

1. AScreen size
2. BThe maximum tokens a model can consider at onceCorrect answer
3. CTraining time
4. DAPI rate limit

Why: Input and output tokens share it.

1. AA slow response
2. BConfident output that is falseCorrect answer
3. CA refused request
4. DA tool error

Why: Models can produce plausible but wrong statements.

1. AForever
2. BA final answer or a limit is reachedCorrect answer
3. CThe server restarts
4. DThe user closes the tab

Why: Model, tools, observe, repeat.

1. AOnly training data
2. BLonger prompts
3. CSupplied, verifiable sourcesCorrect answer
4. DRandom sampling

Why: Often with citations.

1. AThe API key
2. BContent the model reads, such as web pagesCorrect answer
3. CThe system prompt
4. DThe model weights

Why: Agents reading data are exposed.

1. AB-tree only
2. BHNSWCorrect answer
3. CBitmap
4. DHash only

Why: HNSW graphs enable fast approximate nearest-neighbour search.

1. AMCPCorrect answer
2. BSMTP
3. COAuth only
4. DgRPC only

Why: MCP defines servers exposing tools, resources and prompts.

1. AMore deterministicCorrect answer
2. BLonger
3. CMultilingual
4. DMore random

Why: Less randomness in sampling.

1. ARAGCorrect answer
2. BHigher temperature
3. CBigger context only
4. DFine-tuning weekly

Why: Retrieval reads current data at query time.

1. ASplits documents
2. BStores vectors
3. CReorders retrieved passages by relevanceCorrect answer
4. DGenerates embeddings

Why: Usually a cross-encoder.

1. ATwo LLMs
2. BSQL and CSV
3. CImages and text
4. DKeyword and vector searchCorrect answer

Why: Merged with rank fusion.

1. AThe tokenizer
2. BSmall added low-rank matricesCorrect answer
3. CAll model weights
4. DOnly embeddings

Why: Cheap fine-tuning.

1. AA smaller model imitating a larger oneCorrect answer
2. BA larger model
3. CA dataset only
4. DAn embedding index

Why: Student and teacher.

1. ATime of day
2. BMeaning (embeddings)Correct answer
3. CExact string only
4. DUser ID

Why: Needs a similarity threshold.

1. AAbout 1
2. BAbout 4Correct answer
3. CAbout 20
4. DExactly 8

Why: A rule of thumb is ~4 characters or ~¾ of a word.

1. AA user session
2. BA file's size
3. CMeaning as a numeric vectorCorrect answer
4. DA database table

Why: Similar meanings are close in vector space.

1. AAudio
2. BRandom JSON
3. CMarkdown only
4. DData matching a schemaCorrect answer

Why: Programs can parse it reliably.

1. AChain-of-thoughtCorrect answer
2. BTop-k
3. CQuantisation
4. DFew-shot

Why: Stepwise reasoning improves multi-step problems.

1. AModel size
2. BPrompt language
3. CRequests or tokens per time periodCorrect answer
4. DContext length

Why: Handle 429 errors.

1. AVector storage only
2. BA chatbot UI
3. COne API with routing, fallbacks and cost trackingCorrect answer
4. DModel training

Why: Sits between apps and providers.

1. AHow many tokens a model reasons withCorrect answer
2. BMonthly spending only
3. CEmbedding size
4. DImage resolution

Why: More thinking, more latency.

1. AA model license
2. BA GPU benchmark
3. CA repeatable quality test with scoringCorrect answer
4. DA JavaScript function

Why: Track quality over changes.

1. AIs the user's last message
2. BIs the model output
3. CIs a tool result
4. DSets the model's role and rulesCorrect answer

Why: Placed before the conversation.

1. AOnly within one message
2. BIn the GPU
3. CIn the browser cache
4. DAcross sessions in a storeCorrect answer

Why: Retrieved when relevant.

1. AThe changing part comes first
2. BThe stable prefix comes firstCorrect answer
3. CPrompts are random
4. DTemperature is high

Why: Only a repeated prefix can be reused.

1. AImproves accuracy
2. BReduces memory by using lower-precision weightsCorrect answer
3. CAdds tools
4. DIncreases context

Why: Smaller numbers make models cheaper to run.

1. ATraining on few GPUs
2. BAnswering briefly
3. CUsing few tokens
4. DIncluding a few examples in the promptCorrect answer

Why: Examples show the model the expected pattern.

1. AOnly read text
2. BOnly write code
3. COnly translate
4. DTake inputs like images and audioCorrect answer

Why: More than text.

1. ACount tokens
2. BMerge ranked result listsCorrect answer
3. CTrain embeddings
4. DCompress prompts

Why: Common in hybrid search.