# What is Agentic AI Engineering?

An agentic AI engineer is a software engineer who designs, builds, and operates AI agent systems. That includes multi-agent orchestration, RAG pipelines, tool-calling architectures, and LLM-powered products that automate business processes with minimal human intervention.

Udacity defines the role as "designs, builds, and maintains intelligent systems made up of autonomous agents that can reason, plan, use tools, and take action toward goals." IBM describes the discipline as building AI systems that pursue goals autonomously: planning multi-step tasks, using tools, recovering from errors, and collaborating with humans when stakes are high.

This is not about using AI coding agents like Cursor or Copilot for productivity. That is AI-native engineering, a related but different discipline. Agentic AI engineers build the agent systems that enterprises are deploying at scale.

## Agentic AI Engineer vs AI-Native Engineer vs AI/ML Engineer

Job postings say "AI engineer" and could mean any of these. Agentic AI engineers build agent systems. AI-native engineers use AI coding agents to build software. AI/ML engineers train and optimize models.

| Dimension   | Agentic AI Engineer                              | AI-Native Engineer                  | AI/ML Engineer                          |
|-------------|--------------------------------------------------|-------------------------------------|-----------------------------------------|
| What they do| Builds AI agent systems                          | Uses AI coding agents to ship code  | Trains and optimizes ML models          |
| Output      | Agents, RAG pipelines, multi-agent systems       | Software built with AI assistance   | Trained models, MLOps, inference APIs   |
| Core tools  | LangChain, CrewAI, OpenAI Agents SDK, vector DBs | Cursor, Claude Code, Copilot        | PyTorch, TensorFlow, Hugging Face       |
| Builds for  | End users, enterprises, business processes       | Their own software projects         | Data teams, model consumers, research   |
| Focus       | Agent behavior, orchestration, tool use          | Code generation, review, arch       | Accuracy, training, inference opt       |

The role emerged because AI agents moved from experimental to production-critical in 2025-2026, and building reliable agent systems turned out to require its own skill set around orchestration, evaluation, and guardrails.

## What Agentic AI Engineers Build

Six system types show up repeatedly in production.

1. **Customer-facing AI assistants.** Conversational agents for support, sales, and onboarding. Salesforce's Agentforce has closed 29,000 deals and generated $800M ARR across marketing, sales, and service.
2. **RAG systems.** Retrieval-augmented generation grounding LLM responses in company data. Hybrid retrieval (vector + BM25) is standard. Mature implementations report 2.8x ROI with a 14-month payback.
3. **Multi-agent orchestration.** Multiple specialized agents coordinating via supervisor, swarm, pipeline, or hierarchical patterns. Enterprises report 3x faster task completion and 60% better accuracy vs single-agent approaches.
4. **Business process automation.** Agents handling KYC/AML, document processing, trade accounting, regulatory reporting. Goldman Sachs deployed Claude-powered agents overseeing $2.5 trillion in assets, cutting onboarding time by 30%.
5. **Tool-calling and MCP integration.** Connecting agents to APIs, databases, SaaS platforms, and internal services. Model Context Protocol hit 97 million installs by March 2026.
6. **Evaluation and observability pipelines.** Tracking agent success rates, latency, costs, and token usage. Platforms include LangSmith, Langfuse, Braintrust, and Arize Phoenix.

## The 2026 Tech Stack

### Orchestration frameworks

| Framework                     | Language    | Strength                                               |
|-------------------------------|-------------|--------------------------------------------------------|
| LangChain + LangGraph         | Python      | Market leader, graph-based stateful workflows          |
| CrewAI                        | Python      | Role-based multi-agent, fastest-growing                |
| OpenAI Agents SDK             | Python      | Lightweight, minimal abstractions                      |
| Google ADK                    | Python/Go   | Deep Google Cloud integration, A2A native              |
| Microsoft Agent Framework     | Python/C#   | Merged AutoGen + Semantic Kernel, enterprise SDK       |
| PydanticAI                    | Python      | Type-safe, Temporal integration, production durability |
| Mastra                        | TypeScript  | TypeScript-native leader, OpenTelemetry support        |
| Vercel AI SDK                 | TypeScript  | Type-safe UI streaming, MCP support                    |

### Vector databases

Pinecone (managed), Weaviate (hybrid vector + BM25), Qdrant (Rust, on-prem), Milvus (billion-scale), pgvector/pgvectorscale (Postgres-native, 471 QPS at 99% recall on 50M vectors).

### LLM providers

Most agentic engineers work across providers: Anthropic (Claude, originator of MCP), OpenAI (GPT, Agents SDK), Google (Gemini, ADK, A2A), Meta (Llama, self-hosted), Mistral (multilingual). Multi-model routing and fallback strategies are core competencies.

## Core Competencies

Eight skills that keep showing up in job postings on agentic-engineering-jobs.com.

1. **Agent architecture design.** Single-agent vs multi-agent vs hierarchical patterns. Supervisor/orchestrator topologies, swarm coordination, state graphs (LangGraph), role-based composition (CrewAI).
2. **RAG pipeline engineering.** Hybrid retrieval (vector + keyword/BM25), chunking strategies, embedding model selection, domain-specific tuning. This is where the line between "works" and "hallucinates" sits.
3. **Tool integration and function calling.** MCP servers and clients, API orchestration across databases, SaaS, and internal services. A2A protocol for agent-to-agent interop. Without solid tool integration, agents are just chatbots.
4. **LLM provider integration.** Multi-model routing, prompt engineering, context window management, cost optimization across providers.
5. **Evaluation and testing.** Offline evals (regression, accuracy, hallucination), online monitoring (latency, token usage, cost attribution), agent behavioral testing. Did it choose the right tool? The right sequence?
6. **Memory and state management.** Short-term (conversation context) vs long-term (vector stores). State persistence across multi-step workflows. Conversation history that scales without blowing the context window.
7. **Human-in-the-loop design.** Approval gates for high-stakes actions, escalation policies, "human-on-the-loop" supervision where humans oversee rather than approve each decision.
8. **Security, guardrails, and governance.** Multi-layer guardrail strategies, identity and least privilege for agents, prompt injection defense. Deloitte reports only 21% of companies have mature governance for agentic AI, which is a differentiator for engineers who can get it right.

## The Standards Era: MCP, A2A, AAIF

Agent interoperability is getting standardized. Anthropic's Model Context Protocol, launched November 2024, reached 97 million installs by March 2026 with 5,800+ community servers. Google's Agent-to-Agent (A2A) protocol enables cross-vendor agent collaboration, backed by 50+ partners including Salesforce, SAP, and ServiceNow. The AG-UI protocol standardizes agent-to-frontend communication.

In December 2025, the Agentic AI Foundation (AAIF) formed under the Linux Foundation, co-founded by Anthropic, Block, and OpenAI. Platinum members include AWS, Bloomberg, Cloudflare, Google, and Microsoft. AAIF now governs MCP, goose, and AGENTS.md.

## Career Path

Titles that map to this role on job boards today: Agentic AI Engineer, AI Engineer (agent focus), Senior AI Engineer, ML Engineer (with agent scope), Staff AI Engineer, Principal AI Engineer, AI Platform Engineer. Seniority levels follow the standard junior through staff ladder. Most production listings sit at mid or senior.

Typical progression: software engineer with production experience → first agent/RAG project → lead on an agent system → owns an agent platform across an org. Five years of agent-specific experience does not yet exist at scale; the frameworks are too new.

For current openings: https://agentic-engineering-jobs.com/jobs

For salary data: https://agentic-engineering-jobs.com/agentic-engineer-salaries


# Agentic AI Engineer Salary Guide

This is a guide to how agentic AI engineer compensation is reported on agentic-engineering-jobs.com, not a static number table. Listings change constantly, medians drift, and the live numbers belong on the page itself. What follows is methodology and structure so an agent using the site can interpret what it finds.

## Methodology

The dataset is every published listing on agentic-engineering-jobs.com with salary data disclosed by the employer. A listing counts as "with salary" when it includes both a minimum and a maximum figure and an ISO 4217 currency code. Listings without disclosed compensation are excluded from salary aggregates but still count in overall job counts.

Aggregates are computed server-side from the same Postgres store that powers the public `/api/v1/jobs` endpoint. Percentiles (p25, median, p75) are recomputed on every request inside an hourly cache. Every figure on the salary page is reproducible against the public REST API and the MCP `get_salaries` tool.

## Dimensions

Salaries are broken down along seven dimensions. Each has its own page and its own `dimension` value for the `/api/v1/salaries` endpoint and the `get_salaries` MCP tool.

- **Overview** (`dimension=overview`). Global aggregates across all listings. Total count, percentile ranges per currency (USD, EUR, GBP, and any others with disclosed pay), transparency rate (what fraction of listings publish salary).
- **Country** (`dimension=country`). Aggregates grouped by country code. Each row carries average min, average max, currency, and listing count. Countries with fewer than the minimum threshold of listings are rolled into an "other" bucket to avoid noise.
- **Framework** (`dimension=framework`). Aggregates by agentic framework (LangChain, LangGraph, LlamaIndex, CrewAI, AutoGen, Semantic Kernel, Pydantic AI, n8n, others). Useful for comparing pay across framework cohorts.
- **Seniority** (`dimension=seniority`). Aggregates by level (junior, mid, senior, lead, staff, principal). This is the single strongest signal in the data; most salary variance comes from seniority, not framework or tool.
- **Tool** (`dimension=tool`). Aggregates by AI tool (Cursor, Claude Code, Copilot, Windsurf, Codex, others). Tool co-occurrence with agentic frameworks is what makes this dimension useful.
- **Tech stack** (`dimension=tech-stack`). Aggregates by programming language and infrastructure technology (Python, TypeScript, Docker, Kubernetes, AWS, GCP, Azure, FastAPI, Pinecone, Weaviate, vLLM, and others).
- **Location type** (`dimension=location-type`). Aggregates by remote, hybrid, or onsite. Remote listings tend to span wider currency bands.

## Patterns in the Data

These hold directionally as of April 2026. For current numbers, see the live page.

- **Transparency is low.** Fewer than a third of agentic listings publish salary. This is in line with the broader tech market and gives posted ranges outsized signal.
- **USD posts higher than EUR and GBP nominally.** Staff-level USD ranges approach $300k at the top end. EUR staff ranges cluster lower nominally but account for differences in total comp structure in Europe (more base, fewer equity-heavy offers).
- **Framework-agnostic roles pay more than framework-tagged roles.** Not because frameworks hurt compensation, but because framework-tagged listings skew implementation-level and framework-agnostic listings skew architect-level. Staff-level LangChain roles close the gap.
- **CrewAI sits at the top of the framework-tagged cohort by average mid-point.** LangChain sits below, with the largest sample size. LlamaIndex and AutoGen sit in between.
- **Mid-level roles are overrepresented in the LangChain cohort.** Framework maturity lets companies hire mid-level. Rarer frameworks skew senior.
- **Hybrid outpaces remote in framework-tagged listings.** Remote dominates broader software, but agentic roles with enterprise employers skew hybrid, especially in Europe.

## For Current Numbers

Static docs like this one go stale within weeks. For live medians, percentiles, and per-dimension breakdowns, use one of:

- Human-readable: https://agentic-engineering-jobs.com/agentic-engineer-salaries
- Per-dimension pages (framework, country, seniority slugs): https://agentic-engineering-jobs.com/agentic-engineer-salaries/langchain
- REST API: `GET https://agentic-engineering-jobs.com/api/v1/salaries?dimension=framework`
- MCP: `get_salaries({ dimension: "framework" })` against https://agentic-engineering-jobs.com/api/mcp

For current numbers see https://agentic-engineering-jobs.com/agentic-engineer-salaries.


# Agentic AI Engineer Hiring Guide

Nine interview questions to evaluate agentic AI engineers. Tier 1 can be asked by any recruiter or hiring manager. Tier 2 assumes basic technical context. Tier 3 needs a technical interviewer who can evaluate depth.

## Scoring Framework

Most candidates land at Intermediate. Frontier is rare and worth paying a premium for.

| Level        | Description           | Typical signals                                                               |
|--------------|-----------------------|-------------------------------------------------------------------------------|
| Beginner     | Has built demos       | LangChain quickstart, API wrapper, no eval, ChatGPT for everything            |
| Intermediate | Production practitioner | Working agent in prod, error handling, basic monitoring, one framework      |
| Advanced     | System owner          | Multi-agent arch, cost optimization, eval in CI/CD, security model, observability |
| Frontier     | Platform builder      | Agent infra for the org, provider abstraction, team-wide standards            |

## Tier 1: Basics (Any Interviewer Can Ask)

### Q1: "What agent or LLM-powered system have you shipped to production?"

Green flags: names a specific system with real users; can describe architecture (which models, what tools, how failures are handled); talks about what went wrong (production always comes with war stories); distinguishes between a demo and a production system without being prompted.

Red flags: only personal projects or hackathon demos; describes a thin chat API wrapper as an "agent"; can't explain error handling or bad-output recovery; everything "worked perfectly the first time" (it did not).

### Q2: "How do you know when your agent gives a wrong answer?"

Green flags: systematic evaluation approach; names specific tools (Braintrust, Langfuse, RAGAS) or a custom pipeline; builds eval datasets from real production traffic; knows the difference between retrieval quality and generation quality; mentions LLM-as-judge with explicit scoring rubrics.

Red flags: "we review outputs manually"; can't describe what metrics they track or what a regression looks like; conflates model self-reported confidence with actual evaluation; has never caught a regression after a prompt or model update.

### Q3: "When would you build an agent vs write regular code?"

Green flags: clear criteria (dynamic reasoning, tool selection, highly variable inputs justify an agent; deterministic logic stays deterministic); names a case where they chose NOT to use an agent and why; articulates cost, latency, and reliability tradeoffs; treats agents as tools with real costs, not a default.

Red flags: thinks everything should be an agent; can't name the downsides (cost, latency, non-determinism, debugging complexity); has never decided against using an agent.

## Tier 2: Intermediate (Tech-Aware Interviewer)

### Q4: "Walk me through how you test and evaluate an agent before deploying it."

Green flags: repeatable eval pipeline with golden dataset, automated scoring, baseline comparison; tests agent trajectories (full sequence of tool calls and reasoning), not just final outputs; runs regression tests before prompt changes go live; handles LLM non-determinism via multiple runs, statistical thresholds, acceptable variance; CI/CD integration for eval.

Red flags: "I test it manually"; evaluates only final answer, ignoring reasoning path; no regression testing for prompts; treats prompts as throwaway strings, not versioned assets.

### Q5: "How do you manage costs when agents make hundreds of LLM calls per task?"

Green flags: model routing (cheap model for simple steps, expensive for hard ones); prompt caching for shared prefixes; token budgets per task; can estimate cost per request or per user with specific numbers; knows when a smaller model is good enough; monitors and alerts on spend.

Red flags: "we just use GPT-4 for everything"; can't estimate system cost; no cost budget, alert, or token limit; treats LLM API calls like they're free.

### Q6: "Your agent needs to call external APIs and tools. How do you build and secure that?"

Green flags: describes tool integration end-to-end (schema, input validation, error handling, retries, timeouts); scopes each tool to least privilege; write ops require explicit approval or deny-by-default; knows MCP (Model Context Protocol) and when to use it vs native function calling; validates tool parameters before execution; has dealt with rate limits, auth rotation, partial failures in production.

Red flags: only used pre-built tools; no security model (agent can do whatever the API key allows); can't explain function calling under the hood; passes user input directly into tool parameters.

## Tier 3: Advanced (Technical Interviewer)

### Q7: "Design a multi-agent system for [domain]. How do agents coordinate, and what happens when one fails?"

Green flags: decomposes into agents with clear responsibilities and boundaries; addresses coordination (state sharing, conflict resolution, loop prevention); has a failure strategy (what happens when one agent returns garbage, preventing cascading failures); knows when multi-agent is overkill; mentions observability for tracing a request across agents.

Red flags: no coordination model; happy-path only, no fallback or circuit breakers; can't explain cost and latency overhead of multi-agent vs single-agent; assumes multi-agent always beats single-agent.

### Q8: "Your RAG pipeline retrieves relevant documents but the agent still gives wrong answers. Debug this."

Green flags: separates into layers (retrieval quality, context assembly, generation faithfulness) and debugs each independently; checks chunk boundaries (relevant info might be split or truncated); looks at context window utilization; tests with different query formulations; measures faithfulness (does the answer follow from the retrieved context).

Red flags: "just add more documents" or "increase top-k" without analyzing the failure; can't distinguish retrieval from generation problems; doesn't know their chunking strategy; no concept of faithfulness metrics.

### Q9: "How do you defend an agent processing user-uploaded content against prompt injection?"

Green flags: knows the difference between direct injection (user overriding system instructions) and indirect injection (malicious instructions in retrieved documents); concrete defenses (input/output separation, treating retrieved content as untrusted, canary tokens, allowlisted tool parameters); layered permissions so a compromised prompt can't call unauthorized tools; mentions red-teaming before deployment.

Red flags: "we tell the model to ignore bad instructions"; doesn't know what indirect injection is; no permission boundaries on agent actions; treats security as a post-launch add-on.

## What Level to Expect by Role

| Role           | Minimum       | Ideal         | Key signal                                                      |
|----------------|---------------|---------------|-----------------------------------------------------------------|
| Junior         | Beginner      | Intermediate  | Has built a working agent, learns fast, asks good production questions |
| Mid            | Intermediate  | Advanced      | Production agents with monitoring, eval coverage, cost awareness |
| Senior / Lead  | Advanced      | Frontier      | Multi-agent architecture, owns cost profile and failure modes end-to-end |
| Staff+         | Frontier      | Frontier      | Agent platform infrastructure, org-wide standards, cross-team tooling |

## Practical Assessments

Three formats that reveal things verbal answers cannot.

- **Agent debugging session (45 min).** Broken agent system: RAG returning wrong answers, tool calls timing out, cost budget exceeded. Watch how they trace the issue through system layers. Evaluate diagnostic process, not the fix.
- **Take-home: build a tool-calling agent (4-6 hours, time-boxed).** Give a spec and tool definitions. Evaluate error handling, eval coverage, cost awareness, and written design-decision tradeoffs. Follow-up review session where they walk through choices.
- **System design sketch (30 min).** Product requirement needing agent orchestration. No code. Evaluate decomposition, coordination model, failure handling, and whether they reach for multi-agent when single-agent would do.

Skip LeetCode. You need someone who can debug a hallucinating agent at 2am, not solve algorithmic puzzles.

## Red Flag Quick Reference

**Dealbreakers.** Claims production experience but can't describe a single failure mode. No evaluation strategy beyond manual spot-checks. No concept of agent permissions, tool scoping, or any security model.

**Serious concerns.** Only used one LLM provider and one framework (no basis for comparison). No awareness of token costs. Treats prompts as throwaway text rather than versioned, tested, reviewed code.

**Minor / contextual.** Unfamiliar with a specific framework by name (LangGraph, CrewAI, Mastra) — frameworks change fast, fundamentals transfer. Hasn't built multi-agent systems (single-agent is often the right choice). Uses different tooling than your stack (tools transfer easily, system thinking does not).

## A Note on Fairness

Agentic AI engineering as a distinct discipline barely existed before 2025. Nobody has five years of production agent experience because five years ago the models could not use tools.

Focus on reasoning quality and system thinking over specific framework names. A strong software engineer who understands distributed systems and can reason about non-deterministic behavior will often outperform someone with flashy agent demos and no production discipline.

For a live list of candidates who build this stuff, see the job board at https://agentic-engineering-jobs.com.


# LangChain Job Market 2026

Analysis of 591 agentic AI engineering job listings on agentic-engineering-jobs.com as of April 14, 2026. The headline: LangChain is the most in-demand agentic framework by a wide margin. It also has a salary gap with framework-agnostic roles. And LangGraph is quietly becoming its own category.

## Dataset

- 591 published listings total.
- 156 listings in the LangChain ecosystem (LangChain + LangGraph combined) — 26.4% of all agentic postings.
- 132 listings tag LangChain (22.3%), 89 tag LangGraph (15.1%).
- Salary figures are USD unless noted.

## The Salary Gap

LangChain jobs pay $60-70k less at the median than jobs that don't mention any framework. The cohort breakdown:

| Category                 | Jobs w/ salary | Median min | Median max |
|--------------------------|----------------|------------|------------|
| Framework-agnostic roles | 173            | $185,000   | $270,000   |
| LangGraph only           | 6              | $200,000   | $275,000   |
| LangChain only           | 13             | $160,000   | $210,000   |
| LangChain + LangGraph    | 8              | $126,250   | $165,000   |

This looks bad for LangChain at first glance. It is not. Framework-agnostic $270k roles skip listing frameworks because they hire architects who evaluate tools, not specialists who implement with one. LangChain-specific listings are implementation roles: build the agent, wire the RAG pipeline, deploy it. Different tier of work, different compensation.

Staff-level LangChain roles confirm the ceiling matches. The three staff positions in our data average $308k at the top end with a $300k median. The gap is about seniority distribution, not a framework penalty.

There is a parallel developer narrative worth acknowledging. LLMs improved faster than frameworks could adapt. Native function calling and expanded context windows reduced the value of abstractions. Harrison Chase noted in October 2025: "The same high-level interfaces in LangChain that made it easy to get started were now getting in the way when people tried to customize them to go to production." Experienced ML engineers are migrating to raw SDK calls, DSPy, or LlamaIndex. The highest-paid roles reflect this: they want people who can pick the right tool, not people locked into one.

## LangChain is Still #1 by a Wide Margin

Despite the framework-fatigue conversation, the hiring data is clear:

| Framework       | Jobs | % of all listings |
|-----------------|------|-------------------|
| LangChain       | 132  | 22.3%             |
| LangGraph       | 89   | 15.1%             |
| LlamaIndex      | 49   | 8.3%              |
| CrewAI          | 47   | 8.0%              |
| AutoGen         | 33   | 5.6%              |
| Semantic Kernel | 11   | 1.9%              |
| n8n             | 10   | 1.7%              |
| Pydantic AI     | 8    | 1.4%              |

The full LangChain ecosystem (LangChain + LangGraph combined) touches 156 jobs — more than 1 in 4 agentic AI engineering positions. Developers might question whether they still need LangChain. Employers are not.

## The Mid-Level Opportunity

LangChain jobs skew mid-level more than the broader agentic market. 42.3% of LangChain ecosystem roles are mid-level vs 31.5% for everything else. Lead and staff roles are proportionally rarer.

| Seniority | LangChain % | Other jobs % |
|-----------|-------------|--------------|
| Junior    | 1.3%        | 0.9%         |
| Mid       | 42.3%       | 31.5%        |
| Senior    | 46.8%       | 50.8%        |
| Lead      | 3.2%        | 7.8%         |
| Staff+    | 6.4%        | 8.9%         |

LangChain made agent-building accessible enough that companies are comfortable hiring mid-level engineers for it. If you are mid-level looking to break into agentic work, LangChain roles are your best entry point. The broader market skews senior. This also explains part of the salary gap — more mid-level roles means a lower median, not a framework penalty.

## LangGraph is Becoming Its Own Category

LangGraph appears in 15.1% of all agentic job listings. That makes it the #2 framework, ahead of LlamaIndex and CrewAI. Most LangGraph jobs (73%) still mention LangChain. But 27% list LangGraph without LangChain, meaning some companies now treat it as a standalone requirement.

CrewAI and AutoGen appear alongside LangGraph more often than alongside LangChain. CrewAI co-occurs with 37% of LangGraph listings vs 30% of LangChain listings. AutoGen: 29% of LangGraph jobs vs 21% of LangChain. Multi-agent orchestration roles cluster around LangGraph specifically, not the broader LangChain ecosystem.

This aligns with LangChain's own trajectory. Deep Agents, launched March 2026, is built on LangGraph. It hit 9.9k GitHub stars within 5 hours. The $1.25B Series B, the NVIDIA partnership, Jensen Huang keynoting their conference: the investment thesis is LangGraph as the production orchestration layer, not LangChain as a convenience wrapper.

## The Companion Stack

94.2% of LangChain ecosystem jobs require Python. What else shows up:

| Technology | Jobs | % of LC ecosystem |
|------------|------|-------------------|
| Python     | 147  | 94.2%             |
| Docker     | 57   | 36.5%             |
| AWS        | 57   | 36.5%             |
| Kubernetes | 43   | 27.6%             |
| FastAPI    | 29   | 18.6%             |
| Pinecone   | 25   | 16.0%             |
| TypeScript | 30   | 19.2%             |
| MCP        | 15   | 9.6%              |

Kubernetes in 27.6% of jobs means LangChain is not just prototypes. These are production infrastructure roles. TypeScript in 19.2% shows real demand for LangChain.js. MCP at 9.6% is early but notable, matching the industry trend (Salesforce found 39% of enterprises already using MCP).

AI tool pairings tell a story. Gemini appears in LangChain jobs at 4.3x the rate of the broader market (9% vs 2.1%). vLLM is 5x more common (7.1% vs 1.4%). LangChain teams are the multi-provider, self-hosted inference crowd. LangSmith (LangChain's own observability tool) appears in only 7.1% of ecosystem jobs. Adoption is still early.

## Who is Hiring

Top employers posting LangChain ecosystem roles:

| Company   | Jobs | Seniority         | Uses LangGraph |
|-----------|------|-------------------|----------------|
| Celonis   | 6    | Senior            | No             |
| Capgemini | 4    | Mid, Lead         | Yes            |
| SAP       | 3    | Mid, Senior       | Yes            |
| Accenture | 3    | Mid, Senior       | Yes            |
| Binance   | 3    | Senior            | Yes            |
| Mastercard| 2    | Senior, Principal | Yes            |
| Citi      | 2    | Senior, Lead      | Yes            |
| Salesforce| 2    | Senior            | No             |
| EY        | 2    | Mid, Senior       | Yes            |
| Cohere    | 2    | Mid               | Yes            |

Enterprise is all-in. Gartner predicts 40% of enterprise apps will feature task-specific AI agents by end of 2026. The data backs that up: SAP, Mastercard, Citi, Accenture, Capgemini, EY. LangGraph adoption skews toward consultancies and fintech, where multi-agent orchestration maps to complex workflows.

Geography: EU accounts for 66.1% of LangChain ecosystem jobs. Hybrid is dominant at 56.4%. Remote-only is 27.6% (slightly below the 32.4% market average). Contract rate is 5.8%, 2.3x higher than the broader market — companies are bringing in LangChain specialists for specific agent-building projects.

## What to Do with This Data

**If you are a developer:** LangChain is still the highest-signal framework to know. The best-paid roles are framework-agnostic. Learn LangChain for employability, add LlamaIndex as a complement (34% co-occurrence), pick up at least one orchestration framework (LangGraph or CrewAI). The combo makes you versatile.

**If you are hiring:** You are competing with SAP, Mastercard, and Accenture. Contract rate is 2.3x higher than the market average, meaning good LangChain engineers have options. Posting salary ranges helps: only 27 of 156 LangChain listings include compensation data.

**If you are in the EU:** Two-thirds of LangChain jobs are here. Visa sponsorship is almost nonexistent at 1.3%, so you are mostly hiring locally.

All figures reproducible against https://agentic-engineering-jobs.com/api/v1/jobs and aggregate dimensions at https://agentic-engineering-jobs.com/api/v1/salaries.


# CrewAI Job Market 2026

72.3% of CrewAI-tagged agentic engineering jobs are in the EU. Only 12.8% are in the US. Of the framework cohorts on agentic-engineering-jobs.com, CrewAI has the starkest regional skew.

The pattern is not what the American framework discourse suggests. In the hiring data, CrewAI looks like a European enterprise framework. Citi, SAP, Capgemini, EY, Accenture, Binance, Booking.com, Nordea, Cohere. Hybrid senior staff. Containerized, multi-cloud, Python-only production stacks. UK, Poland, Spain, Germany at the top of the country list.

## The Geographic Flip

| Region | CrewAI % | LangChain % | All agentic % |
|--------|----------|-------------|---------------|
| EU     | 72.3%    | 65.4%       | 48.5%         |
| US     | 12.8%    | 21.8%       | 42.7%         |
| APAC   | 8.5%     | 8.3%        | 4.7%          |
| Global | 4.3%     | 3.0%        | 3.2%          |
| LatAm  | 2.1%     | 1.5%        | 0.8%          |

LangChain is already Europe-weighted. The overall agentic market splits roughly evenly. CrewAI bends further. US CrewAI listings in absolute terms: 6 jobs. Six.

Two structural reasons this is not noise. CrewAI publishes a Fortune 500 customer list featuring Capgemini, PwC, IBM, and NVIDIA. Capgemini shows up three times in the hiring data. Named customer, named employer, same company. Separately, the EU AI Act's general-purpose and Annex III obligations start enforcement on August 2, 2026. An agent with a declared role, goal, and escalation protocol is auditable by construction in a way that a freeform graph or open-ended conversation is not. European enterprises hiring into that regulatory horizon have a structural reason to prefer a role-based framework.

## The Country Map

Inside Europe, concentration is not where the venture-capital map would predict.

| Country        | CrewAI jobs |
|----------------|-------------|
| United Kingdom | 7           |
| Poland         | 7           |
| Spain          | 6           |
| United States  | 6           |
| Germany        | 4           |
| Hungary        | 3           |
| Estonia        | 3           |
| Brazil         | 3           |
| Sweden         | 3           |
| Singapore      | 1           |

Poland ties the UK. Hungary and Estonia each match or beat Germany. Central and Eastern Europe is earned ground for CrewAI, not a rounding error. If you are an agent engineer in Warsaw, Budapest, or Tallinn, the CrewAI job volume above your zip code is closer to London's than the funding headlines would suggest.

## Enterprise Adoption, Not Startup Hype

A curated list of 34 known large employers (Fortune 500, global consultancies, major banks, major enterprise SaaS) matched against employer names on framework-tagged listings. 29.8% of CrewAI listings match. The LangChain rate is 15.0%.

| Framework cohort | Enterprise hits | Total | Enterprise % |
|------------------|-----------------|-------|--------------|
| CrewAI           | 14              | 47    | 29.8%        |
| LangChain        | 20              | 133   | 15.0%        |

The logos span finance, consulting, enterprise software, and security. Citi has 3 roles including a Senior AI Security Engineer. SAP has 3. Binance has 3. Capgemini plus Capgemini Invent together have 3. Then EY, Accenture, Cohere, Booking.com, Nordea, Tenable, Veriff, Natera, and Eigen Labs (crypto infrastructure, top USD pay in cohort at $253k).

Capgemini is the cross-validation. Three hiring hits in the data, publicly named CrewAI customer on CrewAI's case study list alongside PwC, IBM, and NVIDIA. CrewAI reported Fortune 500 penetration moving from around 40% in October 2024 to around 60% in late 2025. When Capgemini, EY, and Accenture write a specific framework into senior job descriptions, it is because clients are asking for it by name.

## Salary: Top of the Framework Cohort

Average mid-point USD salary for CrewAI roles with disclosed USD pay lands at $178,495. That is above AutoGen, LlamaIndex, and LangChain for the same framework-specialist comparison.

| Framework         | Sample | Avg min   | Avg max   | Avg mid   | Median mid |
|-------------------|--------|-----------|-----------|-----------|------------|
| CrewAI            | 17     | $155,371  | $201,619  | $178,495  | $185,333   |
| AutoGen           | 15     | $148,400  | $200,867  | $174,633  | $185,333   |
| LlamaIndex        | 21     | $137,300  | $196,400  | $166,850  | $161,250   |
| LangChain         | 52     | $136,760  | $191,647  | $164,203  | $175,000   |
| All agentic (USD) | 290    | $185,738  | $270,755  | $228,353  | $230,200   |

Top of the CrewAI cohort: Eigen Labs (senior, $187k-$253k, crypto infrastructure), Varick Agents ($220k-$250k), Tenable ($159k-$212k), Natera ($126k-$157k).

The framework-tagged cohort sits below the $228k all-agentic mid for a structural reason. Un-tagged agentic roles pull in FAANG and unicorn listings paying $300k and up, where JDs describe the outcome ("build agent platform") without naming tools. Framework-specific listings skew mid-market and enterprise. The useful comparison is within that tier, and CrewAI leads it.

## Hybrid, Senior, Full-Time: The Enterprise Shape

| Dimension      | CrewAI | All agentic |
|----------------|--------|-------------|
| Hybrid         | 59.6%  | 49.0%       |
| Remote         | 34.0%  | 31.3%       |
| Onsite         | 6.4%   | 19.8%       |
| Senior         | 53.2%  | 49.7%       |
| Lead+          | 10.6%  | 7.8%        |
| Full-time      | 97.9%  | —           |
| Visa sponsored | 4.3%   | —           |

Senior hires at established employers, in an office some days a week. Almost no onsite-only listings. Almost no contract work. Hybrid CrewAI roles outnumber remote ones. Senior CrewAI roles outnumber every other seniority bracket. This is the European enterprise profile, not the US remote-first startup profile.

## The Production Stack

Every CrewAI job in the dataset requires Python. 51% require Docker. 47% require Kubernetes. Nearly half require AWS. A third require Azure.

| Technology | Jobs | % of CrewAI |
|------------|------|-------------|
| Python     | 47   | 100.0%      |
| Docker     | 24   | 51.1%       |
| Kubernetes | 22   | 46.8%       |
| AWS        | 22   | 46.8%       |
| GCP        | 19   | 40.4%       |
| Azure      | 17   | 36.2%       |
| Pinecone   | 13   | 27.7%       |
| Weaviate   | 12   | 25.5%       |
| TypeScript | 9    | 19.1%       |
| FastAPI    | 8    | 17.0%       |
| Terraform  | 6    | 12.8%       |
| vLLM       | 5    | 10.6%       |

Multi-cloud is the default. AWS 47%, GCP 40%, Azure 36%. Many CrewAI roles tag two or three cloud vendors in the same listing. Pinecone and Weaviate together sit in more than half of CrewAI jobs as the vector store layer. This is not a framework people are asked to run in a notebook.

## CrewAI is Never the Whole Stack

0 of 47 CrewAI jobs list CrewAI alone. Every single one pairs CrewAI with at least one other framework. The average CrewAI listing mentions 3.62 frameworks.

| Co-framework    | Jobs | % of CrewAI |
|-----------------|------|-------------|
| LangChain       | 40   | 85.1%       |
| LangGraph       | 33   | 70.2%       |
| AutoGen         | 28   | 59.6%       |
| LlamaIndex      | 12   | 25.5%       |
| Semantic Kernel | 3    | 6.4%        |

Read the co-occurrences as vocabularies. CrewAI for role-based crews. LangGraph for graph-state orchestration. AutoGen for conversational orchestration. Hiring managers expect an engineer who can speak all three. Microsoft pivoted its strategic focus to Microsoft Agent Framework in late 2025, and AutoGen is now in mostly-bug-fix mode. Two CrewAI jobs already list Microsoft Agent Framework, which tracks with where the wind is blowing.

## The JD Vocabulary is CrewAI's Vocabulary

Pull workflow descriptions on a sample of CrewAI listings and the same words come up across different employers in different countries in different industries:

> "Architect multi-agent orchestration using models like Gemini, Claude, LLaMA, and Mistral. Develop agent roles, memory systems, and inter-agent communication protocols." — Capgemini, Agentic AI Developer

> "Design autonomous AI agents for cybersecurity, architect multi-agent systems with collaboration/delegation/escalation patterns." — Citi, Senior AI Security Engineer

> "Build agent orchestration (single and multi-agent) with planning, tool routing, shared/persistent memory, and inter-agent communication." — Natera, Senior AI/ML Engineer

"Agent roles", "inter-agent communication", "delegation/escalation patterns", "tool routing", "shared memory". That vocabulary comes straight from CrewAI's own documentation. Hiring managers at a French consultancy, a US bank, and a healthcare-genomics company are independently reaching for the same words. That is mindshare on the demand side of the market, not just the supply side.

## Why This Matters Now

Gartner projects 40% of enterprise applications will include task-specific agents by end of 2026, up from less than 5% in 2025. The same release warns that over 40% of agentic AI projects will be canceled by end of 2027. Both are true at once. The hiring numbers are the leading edge of the first part. LinkedIn's 2026 Jobs on the Rise report ranks AI Engineer as the #1 fastest-growing role in the US, with AI-related hiring nearly doubling since 2023.

The European regulatory calendar matters for framework choice. The EU AI Act's general-purpose model obligations have been in effect since August 2025, and the bulk of Annex III high-risk enforcement (employment, credit, law enforcement, essential services) starts August 2, 2026. Member states must have an AI regulatory sandbox live by the same date. For a Citi, a Nordea, or a Capgemini client in a regulated sector, an agent system where each agent declares its role, goal, and handoff behavior is cheaper to audit than a freeform graph or an open-ended conversational stack. That is an inference grounded in the regulation, not a CrewAI marketing claim. It is a structural reason the European hiring concentration is likely to deepen, not reverse.

## What to Do with This

**If you are an engineer looking at CrewAI work.** Look at London, Warsaw, Madrid, Berlin, Budapest, and Tallinn before San Francisco. 72% of CrewAI jobs are in Europe and CEE punches above its weight. Ship CrewAI alongside LangGraph and AutoGen (70% and 60% of CrewAI JDs want both). Learn the production stack employers actually write: Python, Docker, Kubernetes, Pinecone or Weaviate, at least two of AWS / GCP / Azure.

**If you are on the CrewAI team.** Enterprise Europe is already the wedge. Citi, SAP, Capgemini, Binance, EY, Nordea, Cohere, and Booking.com are in the data. Capgemini cross-validates against CrewAI's own public customer list. Hiring-manager JDs use CrewAI's vocabulary ("agent roles", "inter-agent communication", "delegation and escalation") as the way employers describe the work.

Dataset: 592 published listings as of April 14, 2026. Framework tags come from human curation and description parsing. Salary section uses 17 CrewAI roles with USD-denominated pay disclosed. The enterprise cohort is a curated list of 34 named large employers matched by employer name. Every figure is reproducible against https://agentic-engineering-jobs.com/api/v1/jobs and aggregate dimensions via https://agentic-engineering-jobs.com/api/v1/salaries.


# About

agentic-engineering-jobs.com is a job board for engineers who build agentic systems. RAG pipelines, multi-agent orchestration, LLM-powered products, and business process automation. Built and run by Maxim Buz, an agentic AI engineering consultant.

## Why This Board Exists

Search "AI engineer" on LinkedIn. Half the results want a PhD and PyTorch. The other half think AI means calling an API. If you build agentic systems, RAG pipelines, or multi-agent orchestration, good luck finding your role in that mess.

Companies have the same problem from the other side. They want to build agentic products but cannot find engineers who have actually shipped them. No job board treats agentic AI engineering as its own category. So I built one.

## What Makes This Different

- **Filter by agentic stack.** LangGraph, CrewAI, Pydantic AI, RAG, multi-agent, LLM observability, evals. Not just "AI experience."
- **Global coverage.** Roles across the US, Europe, APAC, and remote worldwide. 500+ active listings.
- **Free job posting.** Companies post for free. No paywall to list, no paywall to apply.

## Resources Beyond the Board

**Agentic AI engineering.**
- What is Agentic AI Engineering? — https://agentic-engineering-jobs.com/what-is-agentic-engineering
- Agentic AI Engineer Salaries — https://agentic-engineering-jobs.com/agentic-engineer-salaries
- Agentic AI Engineer Hiring Guide — https://agentic-engineering-jobs.com/hire/agentic-interview-guide
- LangChain Job Market 2026 — https://agentic-engineering-jobs.com/langchain-job-market-2026
- CrewAI Job Market 2026 — https://agentic-engineering-jobs.com/crewai-job-market-2026

**AI-native engineering.**
- What is AI-Native Engineering? — https://agentic-engineering-jobs.com/what-is-ai-native-engineering
- AI-Native Hiring Guide — https://agentic-engineering-jobs.com/hire/ai-native-interview-guide
- AI-Native Resources and Research — https://agentic-engineering-jobs.com/ai-native-resources

## Author

Maxim Buz. Agentic software engineering consultant. I build agentic systems and consult with companies on agentic architecture. Over the past year, the same thing kept happening: companies wanting to build agentic systems but unable to find engineers who had actually done it. So I built this board.

Links: https://maxim-buz.dev, https://linkedin.com/in/maximbuz/, https://github.com/MaximBuz, hello@maxim-buz.dev.


# API & MCP Schema Summary

All endpoints are public, unauthenticated, JSON over HTTPS. Rate limit: 30 requests per 60 seconds per IP.

## REST Endpoints

- `GET https://agentic-engineering-jobs.com/api/v1` — discovery JSON listing all available resources and the OpenAPI spec URL.
- `GET https://agentic-engineering-jobs.com/api/v1/jobs` — paginated active job listings. Filters: `q`, `locationType`, `seniority`, `salaryMin`, `salaryMax`, `aiTools`, `techStack`, `agenticFrameworks`, `geoRegion`, `sort`, `page`.
- `GET https://agentic-engineering-jobs.com/api/v1/jobs/{slug}` — full detail for one job by slug, including `descriptionHtml` and `applyMethods`.
- `POST https://agentic-engineering-jobs.com/api/v1/jobs/by-slugs` — batch fetch by slug list. Body: `{ "slugs": ["a", "b", ...] }`.
- `GET https://agentic-engineering-jobs.com/api/v1/salaries?dimension={d}`. Returns aggregated salary data. `dimension` is one of `country`, `framework`, `seniority`, `tool`, `tech-stack`, `location-type`, `overview`.
- `GET https://agentic-engineering-jobs.com/api/v1/openapi.json` — full OpenAPI 3.1 spec generated from the same Zod schemas the handlers validate against.

Browsable reference: https://agentic-engineering-jobs.com/api-reference

## MCP Server

Streamable HTTP, unauthenticated. Connect at:

https://agentic-engineering-jobs.com/api/mcp

Setup instructions for Claude Desktop, Claude Code, ChatGPT, Cursor, and Windsurf: https://agentic-engineering-jobs.com/mcp

### Tools

- `search_jobs` — filter active job listings by `q`, `location`, `remote`, `seniority`, `salaryMin`, `frameworks`, `tools`, `techStack`. Returns compact job objects (no description HTML).
- `get_job` — fetch one job's full detail (including description HTML and apply methods) by slug.
- `get_salaries`. Returns aggregated salary data by dimension. Same shape as the `/api/v1/salaries` REST endpoint.

Rate limit: 60 requests per 60 seconds per IP per tool.