JPJobPrepfull-stack interview
RoadmapsJS CompilerStar on GitHub
Career Roadmaps · Agent Engineer

Career roadmap

AI Agent Engineer

Build LLM systems that take actions, use tools and recover from their own mistakes without a human watching.

Time
5-8 months part-time
Entry bar
Working software engineer with LLM API experience.
Stages
5 · 25 topics
0/25 studied0%
All roadmaps

Before you start Agent Engineer

  • Backend engineering experience
  • Familiarity with LLM APIs and prompting
  • Understanding of async programming

Foundations of agentic systems

4-5 weeks · 0/5 topics

An agent is a control loop around a model. Understanding the loop is the whole job.

  1. Frameworks hide this. Interviews expect you to be able to write it yourself.

    • Observe, decide, act, repeat
    • Termination conditions and step limits
    • State between iterations
    • Why loops fail to terminate

  2. Tool definitions are prompts. Their design determines reliability.

    • Tool schemas and descriptions that work
    • Parameter validation and coercion
    • Error messages the model can act on
    • Limiting the tool surface

  3. Agent prompts differ from chat prompts: they must constrain behaviour, not just style.

    Ch — Prompt Engineering
    • System prompt structure for agents
    • Reasoning and planning prompts
    • Output format enforcement
    • Prompt versioning and testing

  4. Capability, latency and cost differ enormously and change monthly.

    • Reasoning models versus fast models
    • Routing between models by task
    • Context window management
    • Provider differences in tool calling

  5. Most production agents end up with less framework than they started with.

    • What agent frameworks actually provide
    • Debuggability versus convenience
    • MCP and tool interoperability
    • Building your own minimal harness

BuildBuild a tool-using agent from scratch, without a framework, that completes a multi-step task.

Memory and context

4-6 weeks · 0/5 topics

Context management is the practical bottleneck in every real agent.

  1. Context is a budget. Spending it well is the core engineering discipline.

    • Token budgeting per component
    • Compaction and summarisation strategies
    • What to drop first
    • Measuring context efficiency

  2. Short-term, long-term and episodic memory, and the retrieval that makes them useful.

    • Conversation memory and summarisation
    • Persistent memory stores
    • Retrieval for memory versus documents
    • Memory staleness and conflicts

  3. Agents need retrieval on demand, not one shot at the start.

    Ch — RAG
    • Retrieval as a tool the agent calls
    • Query rewriting and decomposition
    • Reranking and result formatting
    • Grounding and citation

  4. Long-running agents must survive restarts, which most tutorials ignore.

    • Externalising agent state
    • Checkpointing and resumption
    • Idempotent tool execution
    • Handling partial completion

  5. Reliable parsing is what lets an agent integrate with real systems.

    • Schema-constrained generation
    • Validation and repair loops
    • Typed tool results
    • Handling schema violations

BuildAn agent that handles a long task without exceeding context, with a documented compaction strategy.

Reliability

5-6 weeks · 0/5 topics

The gap between a demo and a product is entirely about failure handling.

  1. Without an eval set you are guessing. This is the single biggest differentiator.

    Ch — Evaluation & Hallucination
    • Task success definitions
    • Building a regression suite of scenarios
    • Trajectory evaluation versus outcome
    • LLM-as-judge and its limits

  2. Agents fail in recognisable, catalogued ways. Knowing them speeds diagnosis.

    • Loops and repeated actions
    • Tool misuse and hallucinated parameters
    • Premature termination
    • Context poisoning from bad results

  3. Good agents recover; great ones do it without a human noticing.

    • Retry with modified approach
    • Backtracking and replanning
    • Escalation to a human
    • Partial success handling

  4. Deterministic checks around a non-deterministic core.

    • Preconditions and postconditions on tools
    • Permission and approval gates
    • Budget and step limits
    • Deterministic validation of outputs

  5. Often proposed, rarely necessary. Knowing when it helps is the senior signal.

    • Orchestrator and sub-agent patterns
    • Context isolation between agents
    • Coordination cost and latency
    • When one agent is better

BuildTake an agent from a 60% task success rate to over 90%, with the evaluation to prove it.

Production agents

4-5 weeks · 0/5 topics

Cost, latency, security and observability for systems that act autonomously.

  1. You cannot debug an agent from logs alone. Traces are mandatory.

    • Full trajectory tracing
    • Token and cost attribution per step
    • Replaying a failed run
    • Dashboards for agent health

  2. Agents multiply token usage. Cost surprises are the usual reason they get cancelled.

    Ch — Cost & Latency
    • Cost per completed task
    • Caching and prompt reuse
    • Model routing for cheap steps
    • Parallel tool execution

  3. An agent with tools is an attack surface with credentials.

    Ch — AI Security
    • Prompt injection through tool results
    • Least privilege for tool credentials
    • Sandboxing code execution
    • Confused deputy problems

  4. Deciding what requires approval is a product and a safety decision.

    • Approval gates for risky actions
    • Confidence-based escalation
    • Reviewing agent decisions
    • Audit trails for autonomous actions

  5. Agents are long-running, stateful and bursty, which complicates deployment.

    • Background jobs versus request/response
    • Queueing and concurrency limits
    • Timeout and cancellation
    • Versioning agents safely

BuildDeploy an agent with full tracing, cost tracking, and a security review of its tool permissions.

Interview preparation

3-4 weeks · 0/5 topics

Interviews focus on reliability engineering, not on prompt cleverness.

  1. Design an agent for a real workflow, with failure handling front and centre.

    • Tool decomposition for a task
    • Context and memory design
    • Failure and escalation paths
    • Cost and latency estimates

  2. Here is a failing trajectory. What went wrong and how would you fix it.

    • Reading a trace to find the failure point
    • Distinguishing prompt, tool and model issues
    • Proposing a targeted fix
    • Preventing regression

  3. Implement an agent loop with tools, without a framework.

    • Writing the loop and tool dispatch
    • Error handling and retries
    • Structured output parsing
    • Testing non-deterministic code

  4. How would you know this agent got better. The question that separates candidates.

    • Designing a task success metric
    • Building an eval set from production traces
    • Handling non-determinism in tests
    • Measuring regression across versions

  5. Reliability numbers are the currency. Demos without them are ignored.

    • An agent with a published success rate
    • The evaluation suite alongside it
    • A reliability improvement case study
    • Cost per task tracked over versions

BuildA public agent project with an evaluation suite and a written reliability report.

Agent Engineer tools on your CV

  • Claude / OpenAI APIs
  • MCP
  • LangGraph
  • Vector databases
  • OpenTelemetry / LangFuse
  • Pydantic
  • Python / TypeScript

What Agent Engineer employers ask to see

  • An agent with a published task success rate and eval suite
  • A reliability case study: failure taxonomy and fixes
  • A tool permission and security review write-up
  • Cost per completed task tracked across versions

The fastest-moving specialism in applied AI. Every company that shipped a chatbot in 2024 is now trying to ship an agent, and few engineers have done it reliably.

Content last reviewed 2026-08-31. Guidance only — no institute or paid placement is endorsed anywhere in this book.