Anthropic AI Engineer Interview Process

Anthropic tests AI Engineers on building with language models, not on describing them. The defining rounds hand you a model as a component, such as a broken tool-calling agent, a prompt that must work every time, or an inference service with a latency budget, and grade what you do after the first version works. One candidate finished all three parts of an agentic coding task and was still rejected; others lost an agent round when asked to cut tool-call rounds without losing accuracy. A values conversation about AI safety carries real weight, and recruiters start probing it in the first call.

This guide breaks down each stage of the Anthropic AI Engineer interview, what interviewers evaluate in each round, and how to prepare, with questions candidates were actually asked.

Verified: Based on 22 candidate-reported interview experiences, primarily from 2025 Q3 through 2026 Q3, cross-checked against recent public accounts.

Anthropic AI Engineer interview process

The track covers applied roles that build on Claude, such as applied AI and forward deployed engineers, plus engineering-heavy research teams, and each team assembles its own loop. The technical screen is assigned from a short menu of topics (practical coding, coding and design, ML configuration, prompting and engineering with language models, agents and tool use), and recruiters have changed the sequence to fit a candidate's background.

Most candidates sit an online assessment, one or two screens of about 55 minutes, and a virtual onsite of four or five rounds, with stages typically two to three weeks apart. Senior candidates may open with a system design screen, and research-leaning teams can substitute a take-home.

Here's what the interview process can look like:

• Recruiter screen: About 30 minutes on motivation, your view of Anthropic and AI safety, and the next round's topics.
• Online assessment (most candidates): A timed, multi-level recipe-building task, sometimes with a debugging exercise.
• Technical phone screen (one or two): About 55 minutes in a shared notebook on the assigned topic, such as a weighted data batcher or a tokenizer.
• Agent and prompt engineering interview: Build or repair an agent loop with tool calls, or make a model do a task reliably, then optimize under a new constraint.
• Coding interview (onsite): Practical Python such as a web crawler that becomes multithreaded.
• System design interview: A broad production prompt, often an inference API or a design document review.
• Hiring manager and project deep dive: One past project in depth, your exact role, and conflict.
• Culture and AI safety interview: Your own position on safety and deployment risk, including where you disagree with Anthropic.

Tip: Ask the recruiter which screen topic you have been assigned. Recruiters give unusually specific preparation prompts for the screens, while onsite design prompts are deliberately left open.

Recruiter screen

The recruiter call runs about 30 minutes and is more rigorous than an introduction. One recent call skipped small talk and spent 20 minutes on layered follow-ups: why Anthropic, which recent company interviews or announcements you read and where you disagreed, why AI safety matters to you personally, and where you have applied it in your work. Others covered your preferred language, a recent project and collaboration style. The last minutes outline the next rounds, sometimes with exact screen topics, and flag that reference checks are standard. If the team seems a poor fit for your background, say so here.

Interviewers evaluate:

• Considered views on Anthropic: Specific announcements or research you read, with a point you would challenge.
• A personal reason for safety: A concrete experience; recruiters said generic mission answers do not stand out.
• Applied safety in past work: A decision where you chose the more careful path and what it cost.
• Collaboration style: A supportive, low-ego way of working is assessed, not just advertised.

Prepare a two-minute answer on why Anthropic and why safety, anchored in one recent piece of company writing you can discuss critically.

Sample questions for the recruiter screen

Here are some questions reported by recent candidates:

• Why Anthropic rather than another AI company?

• What recent Anthropic interview or announcement did you read, and did you disagree with anything?

• Have you applied AI safety principles in your own work? Give a specific example.

• Recruiter Screen — Why Anthropic Deep-Dive

Online assessment

The assessment is a timed implementation task whose requirements unlock in levels, scored out of 600; candidates who advanced reported 600 out of 600. For this track the recurring task is a recipe problem: model ingredients and recipes whose outputs feed later recipes, then find a valid, minimal sequence of steps to a target dish under transformation rules. Some versions add a debugging exercise with off-by-one and branching errors in a supplied function, and one centered on code that calls a language model.

Time is the main enemy. A candidate who hit a bug in the third part could not finish because the editor made copying and pasting awkward, and was rejected. Each level builds on the last, so a data model that cannot absorb new rules forces a late rewrite.

Interviewers evaluate:

• Modeling the constraints: Intermediate products, quantities and cycles represented explicitly before any search logic.
• Completeness: Every level submitted and passing; an unfinished level tends to end the process.
• Extensibility: State and classes that take the next level's rule without a rewrite.
• Debugging speed: Tracing a failing case to the exact branch without IDE help.

Practice multi-level implementation tasks in a plain browser editor, typing everything by hand against a timer.

Note: A full score is common among those who advance, so treat partial credit as risky and keep buffer for one unexpected bug, the reported cause of an incomplete submission.

Sample questions for the online assessment

Here are some questions reported by recent candidates:

• Given ingredients and recipes with transformation rules, produce the shortest sequence of operations that yields a target dish.

• Find and fix subtle off-by-one and branching errors in a supplied function.

• Recipe Manager

• Find All Possible Recipes from Given Supplies

• Task Manager (TTL + Snapshot)

Technical phone screen

Screens run about 55 minutes with an engineer in a shared notebook. The most reported coding-and-design problem is a weighted data batcher built on a supplied registry that returns an iterator per dataset: yield batches of indices by per-dataset weights, then add an offset with deterministic save and resume, then drop the guarantee that the batch size divides the weight total. Discussion follows on weights changing between saves, sharding, weight lists too large for memory, and testing determinism in distributed training.

Other screens: a longest-match tokenizer with an unknown-token fallback that merges consecutive unknowns and bounds its scan by the longest vocabulary entry; stack traces with hidden prefixes and partial leaf samples; the mode and then the median across many workers; and matmul FLOPs, arithmetic intensity and whether a 72-layer network fits on a 40 GB GPU. Some open with 10 to 15 minutes on temperature, transformer structure and a non-converging training run. Research-leaning teams use planted bugs in a GRPO implementation, and one such screen allowed no AI assistance.

Interviewers evaluate:

• State you can checkpoint: Exactly which counters and offsets you save so a resumed iterator emits the same next batch.
• Generalizing without breaking: Relaxing an assumption in part three without invalidating earlier parts.
• Proactive optimization: Bounding the tokenizer's look-ahead before being asked.
• Estimation fluency: Calling a workload compute-bound or bandwidth-bound from FLOPs and bytes moved.

Write small deterministic, stateful iterators and practice explaining what state they need to resume exactly.

Sample questions for the technical phone screen

Here are some questions reported by recent candidates:

• Build a batcher that samples several datasets by weight, then add an offset, checkpoint and resume, and batch sizes that do not divide the weight total.

• Tokenize by longest match against a vocabulary, emitting one unknown token per run of unmatched characters.

• Estimate a matrix multiplication's runtime on an A100 and whether a 72-layer model's weights fit in 40 GB.

• Weighted Data Batcher with Checkpointing

• Longest-Match Tokenizer

• Performance Modeling — Matmul Arithmetic Intensity

• Distributed Mode and Median

Agent and prompt engineering interview

This round defines the track. It appears as a screen labeled prompting and engineering with language models, an onsite round, or an agentic coding session, and runs about 55 minutes. In the agent form you write or repair code that calls the Anthropic API, defines tools, parses tool-use responses, keeps conversation state and loops until the model answers. One version had three parts: fix the bugs, make the agent answer every question within two turns, then within one. Another asked for multi-step reasoning and then fewer tool-call rounds.

In the prompting form you iterate live until a model performs a task reliably in a required output format, while the interviewer adds edge cases. The code around the prompt is graded too: parsing, handling off-format output, keeping prompts swappable. An AI-assisted variant supplies a command-line coding assistant and open web search; its preparation notes list message roles, token limits, prompt caching, time to first token, parallel and strict tool use, subagents, and failure modes such as hallucinations and unintended actions, with deep ML knowledge out of scope.

Interviewers evaluate:

• Correct tool-call mechanics: Matching results to calls, feeding them back, and ending the loop safely.
• Optimization after it works: Batching tool calls, planning up front and instruction design that cut round trips without losing accuracy.
• Systematic iteration: Naming the failure each prompt change targets and how you check it worked.
• Reasoning about model behavior: Explaining why the model produced an output rather than retrying blindly.

Build a small agent on the Anthropic API with two or three tools, rework it to finish in fewer turns, and note each failure and its fix.

Note: Finishing is not the bar. A candidate who completed all three agentic parts in 55 minutes, after rehearsing a near-identical prompt many times, was rejected a week later. Another found the rubric unclear; ask early whether correctness, efficiency or design clarity matters most.

Sample questions for the agent and prompt engineering interview

Here are some questions reported by recent candidates:

• Fix the bugs in a tool-using agent, then make it answer every question within two turns, and then within one.

• Build an agent loop with tool calling and multi-step reasoning, then reduce the tool-call rounds it needs.

• Given a domain and an output format, iterate on prompts until a model's answers are correct and parseable as new edge cases arrive.

• Agents / Coding with LLMs

• Token Usage Calculation

• High-Concurrency Prompt Template Deduplication (Array + Hash Map)

Coding interview

The onsite coding round is about 60 minutes of practical Python. The staple is a web crawler: parse HTML for links, crawl breadth-first from a start URL in one thread, then make it concurrent with a thread pool. The details that cost candidates are keeping only URLs on the start hostname and stripping fragments so a page is not crawled twice. Other loops use a tokenizer or file deduplication with performance follow-ups. Tool rules vary by round, so confirm them beforehand.

Interviewers evaluate:

• A correct baseline first: A working single-threaded crawler before concurrency.
• Concurrency correctness: A shared visited set and queue without races, and clean termination.
• URL hygiene: Hostname filtering and fragment normalization without reminders.
• Readable, tested code: Small functions and your own quick tests.

Practice converting a single-threaded crawler into a thread-pool version in under 20 minutes.

Sample questions for the coding interview

Here are some questions reported by recent candidates:

• Crawl every page under the starting hostname by parsing HTML for links, then make the crawler multithreaded.

• Treat URLs that differ only by fragment as the same page.

• Web Crawler

• Concurrent Web Crawler

• Tokenize (Python)

System design interview

The design round runs 55 to 60 minutes and is broader than candidates expect. An inference API is the most common prompt: why GPU inference is memory-bound rather than compute-bound, and how to batch and dispatch requests to accelerators. One loop used a design document review: add a batching layer and load balancer to an inference service with 100 ms batches at 10,000 queries per second. The candidate found two or three flaws, then went deep on batching, server count, load shedding and circuit breaking, and scheduling several model types.

Other prompts were an ML-powered service judged on scaling, infrastructure, observability and performance rather than model architecture; data infrastructure covering ingestion, storage, access control, cost and fault tolerance, with no ML knowledge expected; and an internal prompt playground with versioning, sharing and prompts over 10 MB. Clarifying questions count, because the prompts are intentionally open.

Interviewers evaluate:

• Hardware-aware serving: Batching, memory bandwidth and accelerator utilization tied to latency and throughput targets.
• Numbers: The servers a stated latency budget and load require, worked out explicitly.
• Overload behavior: Shedding, backpressure and what happens when one model type saturates.
• Production lifecycle: Monitoring, versioning, rollout and cost, raised unprompted.

Prepare one inference-serving design you can size numerically, opening with requirements and load.

Tip: Do not expect a modeling discussion. Candidates who prepared model architectures were steered to deployment, monitoring and cost, and one who prepared only algorithms got a design document to critique.

Sample questions for the system design interview

Here are some questions reported by recent candidates:

• Design an inference API that batches requests onto GPUs, and explain why inference is memory-bound.

• Review a design that adds batching and load balancing for 100 ms batches at 10,000 queries per second, then size the fleet and handle overload.

• Design a prompt playground for internal researchers with versioning, sharing and very large prompts.

• Design GPU Inference Serving System

• Review and Scale an Inference Service Design

• Design AI Prompt Playground

• System Design Q5 — Data Infrastructure

Hiring manager and project deep dive

One onsite conversation, usually with the hiring manager and sometimes a 45-minute project deep dive, covers your past work: the size and duration of your teams, your specific role and impact, the hardest technical decision, and how you handled pushback from teammates or stakeholders. A substantial, well-understood project is the most valuable thing to bring.

Interviewers evaluate:

• Personal ownership: What you decided and built, separated from the team's work.
• Depth under follow-up: Architecture, trade-offs and what you would change.
• Handling disagreement: How a conflict was resolved and what changed afterward.
• Working with ambiguity: Progress made when requirements were unclear.

Rehearse one substantial LLM-related project from a two-minute summary down to its hardest decision.

Sample questions for the hiring manager and project deep dive

Here are some questions reported by recent candidates:

• Walk through a significant project: team size, duration, and exactly what you owned.

• Tell me about pushback from a teammate or stakeholder and how you handled it.

• Describe your most impactful project

• Hiring Manager Round — Behavioral & Collaboration

Culture and AI safety interview

The final round probes your views on AI safety, often with a senior interviewer. Reported topics include Anthropic's constitution for Claude, whether you can genuinely critique the company's safety positions, the Long-Term Benefit Trust, the risks of deploying language models in production, and how you handle being wrong. Interviewers want candidates who engage critically rather than repeat the company line.

Interviewers evaluate:

• Independent judgment: A specific, reasoned critique of an Anthropic position, delivered constructively.
• Knowledge of the company's commitments: Enough familiarity with the constitution and governance to discuss them.
• Deployment realism: Concrete risks of systems you would ship.
• Intellectual honesty: A real time you changed your mind and why.

Read Anthropic's constitution for Claude and its governance materials, with one point of agreement and one of disagreement for each.

Sample questions for the culture and AI safety interview

Here are some questions reported by recent candidates:

• What do you think of Claude's constitution, and where would you change it?

• What concerns you most about deploying large language models in production?

• Describe a time you were wrong and changed your mind.

• Explain AI Safety and Weigh Advanced AI Benefits and Risks

• Why Anthropic and its values?

• Identify the Most Important AI Safety Risk

How Anthropic levels and evaluates AI Engineer candidates

A hiring committee decides, and candidates were told the level is set after that decision rather than fixed up front. Rounds are weighed together: a couple of merely acceptable rounds have sunk otherwise positive loops, and friendly live feedback predicts little. In loops split over two days, weak early rounds can cancel later ones. Team matching now follows the full technical loop for some candidates and does not guarantee an offer if your background fits no team. References from a former manager and a current colleague are checked before the offer, and at least one candidate was rejected after that step. Decisions usually arrive within two days to a week of the final round, without detailed feedback.

Tip: Brief two references before the onsite; the request typically arrives within about a week of the final round.

How to prepare for the Anthropic AI Engineer interview

1. Build an agent on the Anthropic API: Implement tools, tool-result handling and a terminating loop, then cut its turn count without losing accuracy.
2. Practice live prompt iteration: Make a strict-format task reliable and explain each change by the failure it fixes.
3. Learn the API surface: System prompts, tool use variants, prompt caching, token limits and latency metrics come up in AI-assisted rounds.
4. Drill the recipe assessment by hand: Finish multi-level tasks in a plain editor with time left for one bug.
5. Master stateful iterators and crawlers: The checkpointed weighted batcher and the concurrent crawler recur across screens and onsites.
6. Size an inference service numerically: Practice batching, latency budgets and memory-bound reasoning, plus critiquing a flawed design document.
7. Ask for your screen topic: Prepare for the assigned topic instead of every possible screen.
8. Form your own view on safety: Prepare a constructive critique of an Anthropic position and an example from your own work.

About the Anthropic AI Engineer role

AI Engineers at Anthropic build production systems on Claude. Applied AI engineers act as technical advisers to customers on the Claude Developer Platform through pair programming, architecture reviews, evaluation suites and code contributions, and feed repeatable patterns back to product teams. Forward deployed engineers embed with strategic customers to ship applications inside their systems, delivering MCP servers, subagents and agent skills, with travel of about a quarter of the time in some postings. Remote employees are expected onsite about 25% of the time, and a recruiter described a typical week of around 60 hours.

Anthropic hires AI Engineers across several teams. Teams include:

• Applied AI, Startups: Advises AI-native startups building on the Claude Developer Platform as they scale.
• Applied AI for technology companies: Advises tech-forward companies scaling on the platform, in the US and London.
• Forward deployed engineering: Builds production Claude applications inside strategic enterprise customers.
• Forward deployed engineering, federal civilian: Works with federal civilian agencies and some state and local customers.
• Research engineering: Alignment and interpretability groups that hire through RL-debugging, coding-and-design or take-home screens.
• Data infrastructure: Builds ingestion, processing and storage for large datasets, with no ML background required.

AI Engineer experience and education requirements

Postings lead with experience: typically three or more years in a technical, customer-facing role such as forward deployed engineer, or as a software engineer with consulting experience, and former technical founders are encouraged to apply. Applied roles ask for production LLM application experience, strong Python and familiarity with current model capabilities; TypeScript and MCP appear in several postings. Research engineering roles add PyTorch, basic linear algebra and plotting in Python. Nearly every reported round is conducted in Python.

FAQs about the Anthropic AI Engineer interview

How long does the Anthropic AI Engineer interview process take?

Usually one to two months. Candidates describe two to three weeks between most stages, then a decision within about a week of the last round, with reference checks before the offer.

What is the hardest round of the Anthropic AI Engineer interview?

The agent and prompt engineering round, because it is graded on what happens after the code works: fewer turns, reliable output and explanations of model behavior. The culture and AI safety round is the next most common place to fall short, when answers stay at general agreement with the mission.

Is there an online assessment?

Most candidates take one: a staged recipe-building task, sometimes with a debugging exercise, scored out of 600. Some research-leaning teams use a take-home instead, such as a four-hour experiment presented as a slide deck.

Can you use AI tools during the interview?

It depends on the round. One research screen allowed no AI assistance, while an AI-assisted coding round supplied a coding assistant and open web search. Confirm the rules for each round with your recruiter.

Is the process remote?

All reported rounds were virtual, and some onsites were split over two days. The job itself is hybrid, with remote employees onsite about a quarter of the time.

---

Other Tracks at Anthropic

• Anthropic Software Engineer Interview Process
• Anthropic Infrastructure Engineer Interview Process
• Anthropic Machine Learning Engineer Interview Process
• Anthropic Research Scientist Interview Process