Skip to content
SkillPilotNavigate Your Career

AI Agents Engineer Roadmap

A path from LLM and programming fundamentals through agent orchestration, tool use, and production deployment for building autonomous AI agent systems.

Entry level
$101,541
AI Engineer Entry Level salary estimate (average, US)
Mid level
$147,289
AI Agent Engineer salary estimate (average, US)
Senior level
$164,244
Senior AI Agent Engineer salary estimate (average, US)
Glassdoor

This path assumes you write Python and call REST APIs comfortably, but have not built agentic systems. If you have used an LLM API for a chatbot or a summariser, you have started.

One property makes this different from everything else you have built: the same input does not produce the same output. Unit tests asserting exact values, bugs that reproduce, "works on my machine" — none of it holds. An agent that succeeded nine times can fail the tenth with no line of code to fix. That is why evaluation and safety come before production deployment here, and it is the ordering people most often skip. It is also why agents fail differently: a conventional bug throws, while an agent produces something plausible and wrong, confidently, and a user may act on it before anyone notices.

The arithmetic that constrains every design below: a single call at 95% reliability is usually fine, but ten chained calls at 95% each land near 60%.

Each phase lists what to learn, what to build, and how to know you are done. Expect 9–14 months. Treat the named frameworks as a current starting point rather than a permanent stack — the field moves, but tool design, evaluation rigour and failure analysis transfer.

Your progress0%

The path, phase by phase

  1. LLM & Programming Foundations

    How models behave at a level useful for engineering. Done when you can predict which prompts will fail before running them, and explain a wrong answer in terms of context and sampling rather than "the model is dumb". Build on a system whose behaviour surprises you and you write workarounds for problems you have misdiagnosed.

    1-2 months
    8 Skills
    Python for AI
    LLM Fundamentals
    Tokenisation & Context Windows
    Sampling Parameters
    Prompt Engineering
    Structured Output & JSON Mode
    Model Selection & Tradeoffs
    API Integration
    Show details, projects and resources

    Skills you'll master

    Python for AIintermediate
    LLM Fundamentalsadvanced
    Tokenisation & Context Windowsintermediate
    Sampling Parametersintermediate
    Prompt Engineeringadvanced
    Structured Output & JSON Modeintermediate
    Model Selection & Tradeoffsintermediate
    API Integrationintermediate

    Hands-on projects

    1. 01Build a CLI that summarises a text file with configurable length and reports token usage and cost per run
    2. 02Write a harness that runs one task against three prompt variants and scores the outputs against a rubric you defined in advance
    3. 03Run the same prompt twenty times at temperature 0 and at temperature 1, and characterise the difference in the output distribution
    4. 04Deliberately overflow a context window and observe what the model loses first, then design around it
    5. 05Get the same task working on a small cheap model and a large one, and record the quality and cost difference — the answer is often not the expensive one
    6. 06Force structured JSON output and handle the cases where it comes back malformed anyway

  2. Tool Use & Function Calling

    The smallest complete agent: one model, one tool, one decision about whether to call it. Done when your agent picks the right tool for ambiguous requests and recovers when a tool returns an error instead of stopping or inventing a result. The tool description matters more than its implementation — it is what the model actually reasons over.

    1-2 months
    7 Skills
    Function Calling
    Tool Description Design
    Structured Output Parsing
    Argument Validation
    Error Handling in Agent Loops
    Retry & Fallback Strategy
    Model Context Protocol (MCP)
    Show details, projects and resources

    Skills you'll master

    Function Callingadvanced
    Tool Description Designadvanced
    Structured Output Parsingadvanced
    Argument Validationintermediate
    Error Handling in Agent Loopsadvanced
    Retry & Fallback Strategyintermediate
    Model Context Protocol (MCP)intermediate

    Hands-on projects

    1. 01Build an agent that answers questions using two tools and picks correctly based on the request
    2. 02Implement retry and fallback so one failed call does not end the task, and make the failure legible to the model rather than opaque
    3. 03Give the agent a deliberately ambiguous request and watch which tool it picks — then improve the descriptions until it picks right
    4. 04Return a malformed response from a tool on purpose and verify the agent recovers instead of hallucinating a result
    5. 05Validate tool arguments before execution and handle the case where the model invents a parameter that does not exist
    6. 06Write the same tool with a vague description and a precise one, and measure the difference in selection accuracy

  3. Agent Orchestration & Memory

    Where errors start compounding: ten chained calls at 95% reliability each land near 60%. Done when your agent completes a five-step task reliably, and when it fails you can say which step and why from the trace alone. This phase is about structuring work so failure does not multiply unchecked.

    2-3 months
    8 Skills
    Agent Orchestration Frameworks
    Task Decomposition
    Planning & Replanning
    State Management Across Steps
    Context Window Management
    Long-Term Memory Design
    Retrieval (RAG)
    Vector Databases
    Show details, projects and resources

    Skills you'll master

    Agent Orchestration Frameworksadvanced
    Task Decompositionadvanced
    Planning & Replanningadvanced
    State Management Across Stepsadvanced
    Context Window Managementadvanced
    Long-Term Memory Designintermediate
    Retrieval (RAG)intermediate
    Vector Databasesintermediate

    Hands-on projects

    1. 01Build a research agent that plans a multi-step task, executes it, and revises the plan when a step fails or returns something unexpected
    2. 02Add a memory layer so the agent recalls facts across sessions, and demonstrate correct recall after twenty-plus turns
    3. 03Measure your agent's per-step success rate, then compute the end-to-end rate — and see whether the arithmetic matches what you observe
    4. 04Take a task that fails end to end and decompose it until each step is reliable enough that the chain holds
    5. 05Handle a conversation that outgrows the context window without losing the thread
    6. 06Build the same feature twice, once with retrieval and once with a well-designed tool call, and decide which was actually warranted

  4. Evaluation, Safety & Guardrails

    Before deployment, deliberately. With non-deterministic output, "it seemed better" is not measurement, and the evaluation harness is what tells you whether the thing works at all. Done when you can say whether a prompt change made things better with a number rather than an impression.

    1-2 months
    8 Skills
    Evaluation Set Design
    Automated Scoring & LLM-as-Judge
    Regression Testing for Agents
    Guardrail Design
    Red-Teaming
    Prompt Injection Defence
    Human-in-the-Loop Review
    Least-Privilege Tool Access
    Show details, projects and resources

    Skills you'll master

    Evaluation Set Designadvanced
    Automated Scoring & LLM-as-Judgeadvanced
    Regression Testing for Agentsadvanced
    Guardrail Designadvanced
    Red-Teamingintermediate
    Prompt Injection Defenceadvanced
    Human-in-the-Loop Reviewintermediate
    Least-Privilege Tool Accessadvanced

    Hands-on projects

    1. 01Build an evaluation suite of 30+ cases covering both expected-success and expected-refusal, running in CI on every change
    2. 02Implement a guardrail that blocks destructive tool calls without explicit human confirmation
    3. 03Make a prompt change and prove with your eval set whether it helped — including the case where it helped one thing and broke another
    4. 04Red-team your own agent with prompt injection through tool output, not just through user input, and fix what gets through
    5. 05Scope your agent's credentials to the minimum, then verify by removing a permission and confirming it fails safely rather than silently
    6. 06Build a human review queue for low-confidence outputs and define what "low confidence" concretely means

  5. Production Deployment & Observability

    Agent observability is its own problem: traditional metrics tell you it responded in 800ms and cost $0.02, not that it was wrong. Done when you know your per-request cost, your p95 latency and your task success rate in production — especially the third, which most teams never measure.

    2-3 months
    8 Skills
    Agent Observability & Tracing
    Task Success Rate Measurement
    Cost & Token Monitoring
    Caching & Cost Reduction
    Latency Optimisation & Streaming
    Rate Limiting & Backpressure
    Deployment Pipelines
    Graceful Degradation & Fallback Models
    Show details, projects and resources

    Skills you'll master

    Agent Observability & Tracingadvanced
    Task Success Rate Measurementadvanced
    Cost & Token Monitoringadvanced
    Caching & Cost Reductionintermediate
    Latency Optimisation & Streamingintermediate
    Rate Limiting & Backpressureintermediate
    Deployment Pipelinesintermediate
    Graceful Degradation & Fallback Modelsintermediate

    Hands-on projects

    1. 01Deploy an agent behind an API with request logging, per-user rate limiting and a dashboard for token spend and latency
    2. 02Instrument task success rate in production, not just latency and cost — decide what "success" means before you can measure it
    3. 03Alert on error rate and cost per request crossing a threshold, with a runbook for whoever is on call
    4. 04Cut cost per request by at least 30% through caching, prompt trimming or model routing, and show the before and after
    5. 05Trace one production request end to end across every model and tool call it triggered
    6. 06Add a fallback path for when the primary model is unavailable, then test it by blocking the primary

  6. Multi-Agent Systems & Coordination

    One agent hits a ceiling a team of specialists does not: a single prompt trying to plan, research and write well is worse at all three than three agents doing one each. Done when you can hand a task to a coordinator, watch it delegate to two or more sub-agents, and explain from the trace why the split made the result better rather than just slower and more expensive.

    3-4 weeks
    7 Skills
    Multi-Agent Architecture Patterns
    Agent-to-Agent Communication
    Task Delegation & Handoff
    Shared State & Coordination
    Deadlock & Loop Detection
    Sub-Agent Evaluation
    Cost-Aware Agent Routing
    Show details, projects and resources

    Skills you'll master

    Multi-Agent Architecture Patternsadvanced
    Agent-to-Agent Communicationadvanced
    Task Delegation & Handoffadvanced
    Shared State & Coordinationintermediate
    Deadlock & Loop Detectionintermediate
    Sub-Agent Evaluationintermediate
    Cost-Aware Agent Routingintermediate

    Hands-on projects

    1. 01Build a coordinator agent that delegates research, drafting and review to three separate sub-agents and merges their output into one deliverable
    2. 02Compare a single generalist agent against your multi-agent split on the same ten tasks, and report where the split won, lost and tied — not just the average
    3. 03Add loop detection so two agents handing a task back and forth terminate with a clear failure instead of burning budget silently
    4. 04Give one sub-agent a cheaper model than the others and measure the cost and quality tradeoff on the whole pipeline
    5. 05Instrument per-agent cost and latency so you can say which sub-agent is the bottleneck, not just the total

  7. Enterprise Integration & Data Access

    Agents earn their keep against real systems, not demo data — a CRM with inconsistent fields, a database you cannot rewrite, an API with rate limits nobody documented. Done when your agent reads from and writes to a production-shaped system under real permission constraints, and a bad write is rejected before it lands rather than cleaned up after.

    3-4 weeks
    7 Skills
    Database & API Integration for Agents
    Schema-Aware Querying
    Write-Action Safety & Confirmation
    Authentication & Scoped Credentials
    Data Freshness & Caching Tradeoffs
    Enterprise Search & Document Retrieval
    Audit Logging
    Show details, projects and resources

    Skills you'll master

    Database & API Integration for Agentsadvanced
    Schema-Aware Queryingintermediate
    Write-Action Safety & Confirmationadvanced
    Authentication & Scoped Credentialsadvanced
    Data Freshness & Caching Tradeoffsintermediate
    Enterprise Search & Document Retrievalintermediate
    Audit Loggingintermediate

    Hands-on projects

    1. 01Connect an agent to a real database schema with 10+ tables and have it answer questions that require a join, verifying the generated query before execution
    2. 02Build a write action — creating a ticket, updating a record — that requires explicit confirmation and logs who approved it and why
    3. 03Scope the agent's database credentials to read-only on everything except one table, then verify a write attempt elsewhere fails safely
    4. 04Integrate an internal document search so the agent cites the specific document and section it drew an answer from, not just "based on our docs"
    5. 05Simulate a stale-cache scenario and show your agent either refreshes the data or flags that its answer may be out of date

  8. Specialization & Portfolio

    Pick a direction — agent platform tooling, a vertical like legal or customer support, or research-adjacent evaluation work — and build the piece that shows judgment under real constraints, not another tutorial clone. Done when someone outside your team used something you built, on their own data, without you sitting next to them.

    3-4 weeks
    6 Skills
    Domain Specialization
    Agent Platform Tooling
    Technical Writing & Case Studies
    Open Source Contribution
    Stakeholder Communication
    Cost Modelling for Agent Products
    Show details, projects and resources

    Skills you'll master

    Domain Specializationadvanced
    Agent Platform Toolingintermediate
    Technical Writing & Case Studiesintermediate
    Open Source Contributionintermediate
    Stakeholder Communicationintermediate
    Cost Modelling for Agent Productsintermediate

    Hands-on projects

    1. 01Ship an agent for a real workflow in a domain you chose, get a person outside your team to use it unsupervised, and fix what they got stuck on
    2. 02Get one non-trivial pull request merged into an open-source agent framework — a bug fix, an integration or documentation that someone needed
    3. 03Write a case study of a production agent you built, including what failed, what the evaluation numbers actually said, and what you would change
    4. 04Build a cost model that predicts monthly spend from expected request volume, then check it against a week of real usage
    5. 05Present your production agent's failure modes and mitigations to someone technical who was not involved, and revise based on the questions they ask

    Resources

    Anthropic Engineering Blog
    Anthropic · Free
    LangChain Blog
    LangChain · Free
    Designing Data-Intensive Applications
    Martin Kleppmann · Paid · aff — Affiliate link — we may earn a commission at no extra cost to you. A free alternative is always listed alongside.

    Some resources are affiliate links, marked AFF. They cost you nothing extra, we may earn a commission, and a free alternative is listed alongside wherever one exists.

What the job is actually like

Day to day
Far more evaluation than prompting. A normal week is reading traces of agent runs that went wrong, deciding whether the failure was the model, the tool contract or the context you assembled, and turning the interesting ones into test cases. Real time goes on unglamorous plumbing: retries around flaky APIs, token budgets, and the schema of a tool the model keeps calling incorrectly. The hardest habit to build is refusing to fix a failure you cannot reproduce — an agent that behaves differently on identical input is telling you something about your context assembly, not about the model.
The interview
Usually a take-home where you build a small agent against a real API, and the review is about your evaluation harness more than the agent. Expect to defend why a step is a tool call rather than a prompt instruction, and to be pushed on what happens when the model returns something malformed. A systems round covers cost and latency: how many model calls does this design make, what caches, what runs in parallel. Teams that have actually shipped agents will ask what broke in production and how you found out, which is where a candidate who has only built demos becomes obvious.
How people get in
Most arrive from backend or application engineering, bringing the API design instinct that matters most here — a tool the model can call reliably is a well-designed interface, not a clever prompt. Data and machine learning engineers arrive with evaluation habits and tend to underrate the systems work. A smaller group comes from the AI security path, and traffic moves in both directions: the two roles read the same traces looking for different things. What transfers from any origin is debugging under uncertainty. What does not is the expectation that the same input gives the same output.
After senior
Titles are still unsettled, which is both the opportunity and the risk. The technical fork leads toward agent infrastructure — the platform other teams build agents on, which is closer to platform engineering than to prompting. A second fork goes deep on evaluation, owning whether the systems are getting better rather than building them. A third moves toward AI security, as the permission and blast-radius questions stop being someone else's job. Because the ladder is not yet standard, seniority here is argued with shipped systems and their failure data rather than with a title.
Why people leave
The common one is a demo that never became a product. Agents are unusually easy to make impressive in a controlled run and unusually hard to make dependable, and an engineer who cannot show what their system does on its worst inputs has not finished the job. The second is building on abstractions you do not understand: frameworks change fast, and a career resting on one vendor's orchestration layer ages badly. The third is organisational — being hired to add agents to a product with no problem an agent solves, where success is measured by adoption of a feature nobody asked for.

Frequently asked questions

Related certifications

Related roadmaps