Cognition AI Engineer interview questions

The model's training cutoff is frozen, but your dependencies shift weekly. Retraining is the wrong reflex. Here is how teams keep code suggestions current without touching the weights.

Candidates who cite one leaderboard number fail the follow-up. The interviewer wants you to name what SWE-bench measures, what it cannot (long-horizon multi-file refactors, real tool use, business logic), and which complementary benchmarks close those gaps.

An emerging alternative to stuffing the window or building an index: keep the context outside the prompt and let the model write code to inspect it, recursing into the pieces. Knowing when it does not pay is most of the score.

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.

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.

MCP standardized how agents connect to tools and data, but tool design is what determines reliability. The signal is knowing what MCP actually standardizes and the principles behind a tool the model can call correctly from its description alone.

Reflection is the pattern in which an agent critiques and revises its own work. The signal is knowing when it truly helps (external feedback grounds the critique) versus when self-critique on its own is theater.

Plan-and-Execute and ReAct are the two leading agent control patterns. The signal is knowing the upfront-plan versus step-by-step tradeoff, why one costs less, and why most production agents wind up blending them.

Context engineering is the discipline that took over from 'prompt engineering' for serious agent work. The signal is grasping that what you place in the context window (and what you omit) shapes behavior more than clever wording. Here is the answer.

Code-execution agents are powerful and risky: arbitrary model-generated code runs on your infrastructure. The signal is genuine isolation (containers/VMs), resource limits, and network/filesystem restrictions, not 'trust the model.' Here is the answer.

Agents fail in the middle, not only the end, so final-answer-only scoring conceals the real problems and rewards lucky paths. The signal is evaluating the whole trajectory and pinpointing where it broke. Here is the answer.

Sub-agents are how you scale a complex agent task without one huge, noisy context. The signal is context isolation and clean delegation: a focused subtask in, a compact result out. Here is the answer.

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.

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.

When a chain of LLM calls and tools yields a wrong final answer, 'the model was bad' is not a diagnosis. You need visibility into every step. Here is the tracing layer that turns a black box into something debuggable.

Frameworks promise speed and hand you abstraction you'll eventually fight. Rolling your own is more code but full control. Here is the honest tradeoff, and why many production teams end up thinner than they started.

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.

Splitting source files every 500 characters slices functions in half and wrecks retrieval. Interviewers want to see you chunk on syntax, retrieve by symbol and dependency, and blend lexical exact-match with semantic search the way code search actually needs.

Multi-agent systems coordinate through handoffs and shared state. The signal is knowing the orchestration topologies, what a clean handoff protocol carries, and why naive multi-agent often loses to a single good agent.

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.

An hour-long agent run is a distributed workflow wearing an LLM hat. The signal is designing serializable state with step-level checkpoints, and knowing why resume is easy while replaying a side effect is not.

Tool calling costs one LLM round trip per action. Code costs one round trip for a loop over 500 records. The signal is knowing exactly what you trade away when you let the model write the program instead of the call.

Everyone says 'cap the budget'. The signal is the enforcement mechanism: a budget object that travels with the run, checked before each call rather than after, with reserved headroom for a final answer and correct accounting across sub-agents.

The runaway loop gets all the attention. The failure that actually ships is the agent that declares victory on step 4 with half the work missing. The signal is a finish tool the harness can reject, and a completion check that reads the artifact instead of taking the model's word for it.

AI code review succeeds or fails on precision: a handful of noisy comments and the team silences the bot for good. The signal is grounding in the diff plus repo context, unforgiving false-positive control, and winning developer trust one accepted comment at a time.

Code migration is a high-value agentic task with a strict correctness bar: the migrated code has to still work. The signal is grounding in the real repo, transforming in verifiable chunks, and gating on tests, never one huge LLM rewrite.

A Devin-style agent that carries an issue all the way to a merged PR is the hardest kind to make reliable, since every step can fail and errors pile up. Here is the architecture and the loop that keeps it honest.

An agent that clicks through a real website is slow, brittle, and a single wrong click away from a costly mistake. The architecture comes down to perception, action, and guardrails around irreversible steps. Here is how to build it.

Inline completion lives or dies on tail latency: a suggestion that lands after the developer keeps typing is useless. Learn how to assemble the context window, hide model latency behind speculation and caching, and keep a tight feedback loop on acceptance rate.

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.