LCAE study guide: domains, format and a 4-week plan

The LangChain Certified Agent Engineer (LCAE) exam tests whether you can build, test, deploy and monitor agents across what LangChain calls the Agent Development Lifecycle. It is aimed at developers who already build agents with LangChain and run them on LangSmith. You sit 40 multiple-choice questions in 120 minutes, live-proctored online, with a dedicated LangSmith organisation provisioned for you and a short list of LangChain sites you may consult.

LCAE at a glance

Details as of September 2026 — confirm on the official exam page before booking.

The credential is valid for 24 months. The exam guide sets the rules: you may use smith.langchain.com, docs.langchain.com and academy.langchain.com, but no web search, no AI tools (including the AI helper on the docs site), no notes or scrap paper and no second screen.

Who this exam is for

LCAE suits engineers who have shipped at least one agent and have spent time inside LangSmith looking at traces, datasets and deployments. There is no formal prerequisite, but the guide names a LangChain Academy course for every section (LangChain Foundations, Deep Agents Foundations, Building Reliable Agents, LangSmith Deployment Foundations and Monitoring Production Agents) and says to treat them as prerequisites, because the two-hour window is not designed for first-time viewing. The official page notes that these foundation courses are free.

If you have used LangChain only for simple chains, expect a gap: three of the four domains are about operating agents after the code is written.

What the exam covers

Each domain is worth 10 questions, or 25% of the score. Equal weighting means you cannot bank on a strong domain to carry a weak one.

Building Agents (25%)

This domain is about choosing and shaping the agent itself. Know when create_agent is enough and when deepagents, with its planning, file system and subagents, earns its extra structure. Expect questions on middleware (what you would intercept before or after a model or tool call, and why), on context engineering for long-running agents, on what belongs in AGENTS.md versus a SKILL.md, and on why agent-run code should execute in a sandbox.

Testing Agents (25%)

The guide's own framing is choosing the right evaluator and reading results without overfitting to noise. Be clear on when a deterministic code evaluator beats an LLM-as-judge, and the reverse. Know the difference between offline evaluation against a dataset and online evaluators that score production traffic. Evaluator alignment, meaning checking that a judge agrees with human labels before you trust it, and curating new dataset examples from real runs are both named focus areas.

Deploying Agents (25%)

Most questions here depend on vocabulary used precisely. Learn how a graph, deployment, revision, assistant, thread and run relate, because a scenario that mixes up an assistant and a deployment will offer both as answers. The remaining focus areas are multi-region serving, handling secrets, the split between authentication (who is calling) and authorisation (what they may touch), and which storage survives a restart or a new revision.

Monitoring Agents (25%)

This is about production signals. Practise reading a trace tree to find where time, tokens or errors come from, and learn how separate traces are grouped into a conversation thread. The guide also lists attributing cost, tracking user sentiment through feedback, the difference between Insights and Online Evals, and setting alerts. Most of these skills are exercised in the LangSmith console, so time spent there is the best preparation.

A 4-week study plan

The weights are equal, so the plan gives each domain one week, with a working LangSmith project running throughout.

Week 1: Building. Work through LangChain Foundations and Deep Agents Foundations. Build the same small agent twice, once with create_agent and once with deepagents, and write down what changed. Add one piece of middleware and a SKILL.md, and note what each one alters in the model's context.

Week 2: Testing. Take Building Reliable Agents. Create a dataset of 20 to 30 examples, run two experiments against it with a code evaluator and an LLM-as-judge, and compare them. Label a sample by hand to see how well the judge agrees with you. Then attach an online evaluator to the same project.

Week 3: Deploying. Take LangSmith Deployment Foundations and deploy your agent. Create a second assistant from the same graph, push a new revision, and follow a thread across both. Add a secret and a simple auth handler, and be able to explain what each one protects.

Week 4: Monitoring and rehearsal. Take Monitoring Production Agents, generate traffic, and practise answering questions from the console alone: which run was most expensive, which thread went wrong, what would an alert have caught. Take LangChain's official practice exam and at least one full-length timed mock, then spend the last days on your weakest domain.

Throughout, get used to finding things on docs.langchain.com quickly. Semi-open-book only helps if you know where to look.

Where candidates lose marks

• Treating open-book as a safety net. Forty questions in 120 minutes leaves about three minutes each, and some require work in the live organisation. Looking up every answer is not feasible, so the docs are for confirming a detail, not learning a concept.
• Mixing up deployment terms. Assistant, deployment, revision, thread and run are distinct objects. Questions often describe a behaviour (a configuration change without a rebuild, state that persists between calls) and ask which object is responsible.
• Confusing Online Evals with Insights. One scores traces against criteria you define; the other surfaces patterns you did not know to look for. Read what the scenario is trying to learn before choosing.
• Trusting an evaluator by default. The Testing domain rewards scepticism: a small score change across one experiment may be noise, and an unaligned judge can be confidently wrong.
• Authentication versus authorisation. A valid token proves identity; it does not decide which threads a user may read. Answers that fix one when the scenario describes the other are common distractors.
• Losing time on logistics. Join at least 15 minutes early; joining more than 10 minutes late counts as a no-show and must be rebooked at full cost. Accept the LangSmith invite as soon as it arrives, roughly two hours before the start; if it reports an error, log out of any SSO-based LangSmith organisation and accept it by signing in with email or Google, as the guide advises.

Practising for LCAE on CertifyAIx

Several LCAE questions are answered by looking something up or acting in a real LangSmith organisation during the exam. A question bank can rehearse the knowledge those questions rest on, but it cannot rehearse working in the console under time pressure, so pair our sets with regular practice in your own LangSmith organisation. What the [LCAE practice questions](/certifications/langchain-certified-agent-engineer) page offers:

• 501 original questions, written against the official exam guide and covering all four domains
• 3 full-length mock exams with 40 questions in 120 minutes and 10 questions per domain, the same as the real exam
• 21 mixed domain papers and 21 topic papers of up to 25 questions each, timed at 60 minutes per 25 questions
• An explanation for every question, covering why each option is right or wrong

Questions favour judgement, such as diagnosing a trace or choosing a primitive, over facts you could copy from a docs page in seconds. Read [how CertifyAIx practice questions are written](/blog/how-certifyaix-practice-questions-are-written) and [how to use practice exams effectively](/blog/how-to-use-practice-exams-effectively) for the method behind them.

Frequently asked questions

How hard is LCAE?

It is practical rather than theoretical. Candidates who already build agents and use LangSmith day to day will recognise most scenarios; those who know LangChain only from tutorials usually need extra time on evaluation, deployment and monitoring.

How long should I prepare?

Four to eight weeks is a reasonable range. The lower end fits someone already running agents on LangSmith; the upper end allows time to complete the five Academy courses and build a deployed project from scratch.

Are CertifyAIx questions real exam questions?

No. Every CertifyAIx question is original, written against LangChain's published exam guide. Using real exam content would breach the exam rules and puts your credential at risk.

What happens if I fail?

The exam fee includes one free resit, which you request from LangChain's certification support. Further attempts cost the full fee, and there is no limit on how many times you can resit.

Can I use documentation during the exam?

Yes, but only LangSmith, docs.langchain.com and LangChain Academy. Web search, AI assistants, notes, scrap paper and second screens are not allowed.

How long is the certification valid?

LangChain states a validity of 24 months.

CertifyAIx is independent and not affiliated with LangChain. LangChain Certified Agent Engineer is a trademark of its owner. All CertifyAIx practice questions are original.