From DevOps Engineer to Forward Deployed Engineer: the Career Path AgenticOps Just Created

AI agents are absorbing the execution half of DevOps. At the same time, the fastest-growing engineering role of the AI era is the Forward Deployed Engineer: an engineer embedded with the business, judged on outcomes, whose job is to deploy and govern agentic systems against real problems. This post argues the two trends are the same trend, and maps the move for the people best positioned to make it.

Two job descriptions, six years apart

Here's a DevOps engineer job description from 2020, compressed to its verbs: maintain CI/CD pipelines, manage Terraform modules, respond to incidents, keep the dashboards green, participate in the on-call rotation. The deliverable is uptime. The customer is a ticket queue.

Here's Anthropic's Forward Deployed Engineer posting from March 2026: "you will be a Forward Deployed Engineer (FDE) who embeds directly with our most strategic customers to drive transformational AI adoption." Posted range: $200,000 to $300,000, about 25% travel. OpenAI's equivalent listings run $162K to $325K plus equity, and there were 39 of them live at once on OpenAI's careers board in July 2026. The deliverable is a deployed AI system and the business outcome it moves. The customer is a person with a P&L.

Same engineering fundamentals. Same production instincts. A different definition of done, and a different market. This post is about the path from the first job description to the second, and why the engineers who spent the last decade on call are the best-positioned people in the industry to walk it.

What a Forward Deployed Engineer actually is

The role was pioneered at Palantir in its early years, internally codenamed "Delta", and described in public in the company's 2020 S-1 filing: "Our software is on the front lines, sometimes literally, and that means so are we. Our forward deployed engineers ('FDEs') have travelled to bases in Afghanistan and factories in the industrial Midwest to deploy our platforms." Palantir's own definition is the cleanest one written: a traditional software engineer "focuses on creating a single capability that can be used for many customers", while an FDE "focuses on enabling many capabilities for a single customer." For years the model was treated as a curiosity. Palantir's own commercial lead wrote that the company was "criticized for a very long time" for it.

Then the AI wave hit, and the criticism inverted. Nabeel Qureshi's "Reflections on Palantir", an insider account of eight years in the role, went viral in late 2024. By June 2025, a16z was calling the FDE "the hottest job in startups". By August 2025, The Pragmatic Engineer reported that OpenAI had grown its FDE team from two engineers to more than ten across eight cities on three continents, engineers who "write code directly on customer infrastructure and use customer tooling."

Then the money arrived. In May 2026, OpenAI spun up a standalone FDE business, the Deployment Company, with roughly $4 billion in backing. Anthropic launched an FDE joint venture valued at $1.5 billion. In a single week of summer 2026, Amazon committed $1 billion to a new internal FDE organization and Microsoft launched "Microsoft Frontier Company" with a $2.5 billion commitment and a plan for 6,000 experts. Databricks is hiring FDEs on every continent. Even Palantir, where it started, has ~60 open forward-deployed requisitions.

01Indeed postings

5,230%

FDE postings in April 2026 versus January 2025 levels.

02LinkedIn positions

42×

FDE role growth from 2023 to 2025, versus 13× for AI engineer roles.

03Committed in 8 weeks

$8.5B+

OpenAI ($4B), Microsoft ($2.5B), Anthropic ($1.5B) and Amazon ($1B), May to July 2026.

04Median salary

$173,816

Across ~1,000 FDE postings. 70% mention equity, none carry a sales quota.

Sources are linked in the paragraph below.

The demand data behind those numbers: Indeed postings for FDEs were 5,230% above January 2025 levels by April 2026 per Business Insider; LinkedIn positions grew 42× from 2023 to 2025, three times the growth rate of "AI engineer" roles; and an analysis of ~1,000 FDE postings found a median advertised salary of $173,816, with 70% offering equity and exactly zero carrying a sales quota.

That last number matters, because it kills the lazy reading of the role. An FDE isn't a consultant with a new business card, and isn't a sales engineer running demos. The defining property is outcome ownership: you sit inside the customer's context, you build against their real systems, and you're measured on whether the thing you deployed changed a number the business cares about. As Box CEO Aaron Levie put it: "Forward-deployed engineers, or roles that do the equivalent motion, are about to become one of the most in-demand jobs in tech."

Why the execution half of DevOps is going to agents

Now look at what's happening to the job most infrastructure engineers actually hold.

Gartner predicts that by 2029, 70% of enterprises will use agentic AI to operate IT infrastructure, up from less than 5% today. The adoption curve already shows in the telemetry: Datadog's State of AI Engineering shows agentic AI framework adoption nearly doubling in a year, from ~9% of organizations in early 2025 to ~18% at the start of 2026. PagerDuty found 51% of companies already using AI agents and 86% expecting operational agents by 2027. Even DORA, the research program that defined how the industry measures DevOps, renamed its 2025 report "State of AI-assisted Software Development", with 90% of respondents using AI at work. The name change is the tell.

The reason is structural. The 2020 job description is mostly procedures: a cost right-sizing run, a patch cycle, drift reconciliation, first-response triage, a health and cost report. Each one is a sequence of reads, a judgment against known thresholds, and a small set of writes. That's exactly the shape an agent with read access, encoded runbooks and an approval gate can execute, and it doesn't get tired at 3 a.m. On the development side, Claude Code, Codex and Cursor own the intent-to-diff loop. On the operations side, CloudThinker's Frontier Investigation Agents run the cost optimization, the incident response and the routine runbooks that used to be a human's Tuesday.

01The 2020 job

Executed by hand

Monitor and alertDashboards, thresholds
Triage and RCALogs, metrics, the 3 a.m. page
Fix, deploy, roll backRunbooks run from memory
Cost, security, healthMonthly reviews, patch cycles
Reporting and maintenanceThe recurring Tuesday

Toil that scales with the estate

02The agent layer

CloudThinker

ReasoningInvestigates from evidence
Runbooks as skillsYour procedures, encoded
GuardrailsScoped credentials, policy
Human approvalManual until you say Auto

Runs the execution

03The engineer

One layer up

EncodeWhat the team knows
GovernWhat the agent may do
ApproveWhat it proposes
Own the outcomeThe number it moved

The forward-deployed work

Agents take the execution half of DevOps. The judgment moves to the engineer who directs them.

We run this model on our own infrastructure (our on-call is an agentic team with humans in the approval loop), and we operate it as a managed service for customers like HBLab. This is a production reality, not a roadmap.

Gartner states the consequence for the role in one sentence: "As agentic AI automates more complex tasks, the role of IT operators will shift from 'doers' to supervisors and orchestrators. The need for manual operators will diminish, while demand for AI strategists, engineers and governance specialists will rise."

The hiring market already reflects it. US tech postings on Indeed sat 36% below their February 2020 level as of mid-2025, with software engineering postings down 49% from early 2020. On LinkedIn's 25 fastest-growing US roles for 2026, AI Engineer is #1, and neither "DevOps engineer" nor "SRE" appears on the list.

Here's the twist the doom headlines miss: the market isn't deleting engineers, it's repricing what kind of engineer it wants. Indeed's own economists found that US software development postings grew almost 15% after agentic coding tools launched in early 2025, and that 71% of that increase came from senior roles. The demand didn't vanish. It moved up a layer, from executing operations to directing the systems that execute them. That's the FDE's job.

The same person, one layer up

Put the two roles side by side and the transition stops looking like a career change and starts looking like a promotion:

	DevOps Engineer (2020)	Forward Deployed Engineer (2026)
Where you sit	In the platform team, behind a ticket queue	Embedded with the customer or business unit
Primary deliverable	Pipelines, dashboards, uptime	A deployed agentic system and the outcome it moves
Definition of done	Ticket closed, alert resolved	Business metric moved, owner signed off
Relationship to runbooks	Executes them by hand, again and again	Encodes them once as skills an agent runs
On-call	The pager wakes you at 3 a.m.	You supervise the agent that got paged
Core toolchain	Terraform, CI/CD, kubectl, shell	Agent platform: skills, guardrails, approval policy
Measured by	MTTR, availability, tickets per week	Time to value, adoption, trust level reached

Read the right-hand column again. Every row is something a strong DevOps engineer already half-does today, informally, without the title and usually without the credit. The FDE role makes it the whole job: the runbook knowledge becomes encoded skills, the on-call instinct becomes agent supervision policy, and the "why was the bill high this month" Slack thread becomes a business outcome you own by name.

Why DevOps engineers are best positioned for this move

The obvious candidates for FDE roles, ML engineers and fresh AI-track graduates, are missing the asset that matters most. The FDE's daily work is deploying agentic systems against production infrastructure that predates them: half-documented VPCs, a Kubernetes cluster with tribal-knowledge taints, a billing anomaly that only makes sense if you know what the org looked like two re-orgs ago. That isn't a modeling problem. It's an operations problem.

Years of on-call build exactly the scarce assets the role demands:

Systems intuition. You've seen how failures actually propagate, not how the architecture diagram says they should.
Blast-radius instinct. You know which commands are safe at 2 p.m. and which are career-limiting at 2 a.m., which is precisely the judgment needed to decide what an agent may do on its own and what needs approval.
Runbook fluency. You've written the procedures. Encoding them as skills an agent executes is a translation task, and you're the native speaker.
Translation practice. Every post-incident review you wrote for a VP was training for the FDE's core motion: converting technical reality into business language, in both directions.

There's a useful counterpoint to the Palantir mythology here. Bessemer notes the forward-deployed model was pioneered by IT services firms long before it had a glamorous name. The role isn't a pedigree. It's a delivery discipline: embed, understand the real system, ship against it, own the outcome. Operations people have been living the unglamorous version of that discipline for twenty years.

The transition map: stop, keep, start

01Stop

Being the cron job

Every task you repeat by hand is a task an agent should run under your policy.

02Keep

On-call judgment

Systems intuition, blast-radius instinct and the reflex to distrust a too-easy fix.

03Start

Encode and govern

Runbooks as skills, approval policy, Manual to Auto one task at a time, outcomes as the deliverable.

The transition map. The scarce asset is what you keep: agents have none of it until you give it to them.

The "start" column deserves expansion, because it's the actual curriculum:

Encode, don't execute. Take the runbook you know best and turn it into a Workspace Skill: the queries, the thresholds, the rollback step. The test of good encoding is that the agent handles the next occurrence without you. The craft is covered in How to Build AI Skills That Actually Work for Your Business.
Design the trust ladder. Decide, per environment and per task, whether the agent runs in Manual or Auto. In Manual the agent proposes and a named person approves every write. In Auto, actions your runbooks and policies cover run on their own and everything else escalates. Then define what evidence promotes a task from one to the other. This is a new engineering artifact, and writing it well is a differentiating skill.
Own the guardrails. Scoped credentials, approval gates, audit trails, safe production connectivity: the security instincts you already have, promoted from habits to policy.
Speak in outcomes. "Reduced the AWS bill 18% without a performance regression" is an FDE sentence. "Closed 40 tickets" isn't. Practice the first kind until it's your default register.

What the move looks like in practice

Here's a week in the life of an operations engineer working the forward-deployed way on CloudThinker.

Monday. A cost review is due. Instead of running it by hand, you encode the procedure once:

"Create a skill that reviews our production AWS accounts for idle capacity every Monday: flag anything under 10% utilization for two weeks, check each candidate against the change-freeze calendar, and draft the right-sizing plan for my approval."

Wednesday. The agent has found a fleet of over-provisioned Aurora instances and opened a scoped change plan. You review the diff in the approval queue, notice it touches a cluster with a compliance constraint the agent couldn't have known about, and tighten the guardrail:

"Never propose instance changes on resources tagged compliance:pci. Route those to me with a summary instead."

The correction is now policy, not tribal knowledge. Every future run inherits it.

Friday. You walk the platform owner through the outcome: what changed, what was saved, which tasks now run in Auto and which still come to a human. The runbook that consumed your Mondays runs without you, and your name is on the number it moved.

Notice what changed in the job. The engineer executed nothing by hand all week, and still made every decision that mattered: what to encode, what to trust, where the line sits, and how the outcome lands with the business. That's forward-deployed work, done from inside the team. The title on the badge can catch up later.

The uncomfortable middle: what happens if you don't move

The execution layer of operations work is commoditizing on a public schedule. Gartner's own phrasing is that "the need for manual operators will diminish", and its prediction that at least 15% of day-to-day work decisions will be made autonomously by 2028 (up from 0% in 2024) tells you where the floor is heading. The hiring data agrees: the postings recovery is happening at the senior, direction-setting end of the market, not the runbook-execution end.

The same research contains the opportunity. Gartner also predicts over 40% of agentic AI projects will be canceled by the end of 2027, and New Relic finds engineers still burning a third of their time on firefighting. Agentic deployments fail for operations reasons: nobody encoded the real runbooks, nobody designed the trust ladder, nobody knew the production context the agent was missing. The gap between "we bought agents" and "agents run our operations safely" is exactly the gap a forward-deployed operations engineer closes. That failure rate isn't a threat to your career. It is your career, waiting for someone qualified to claim it.

The squeeze is real, and it has a direction. It squeezes out the people who insist the job is executing runbooks by hand. It promotes the people who make the agents work.

Getting started

01Encode

One runbook

The task you executed twice last month, written as a skill.

02Manual

Agent proposes

You approve every write and compare its calls with yours.

03Auto

Per action

Actions your policy covers run on their own. The rest escalate.

04Report

The outcome

Two sentences a business owner cares about, with your name on them.

Trust is promoted per action and per environment, on evidence, and it's reversible.

You don't need a new title to start working this way. You need one runbook and three weeks.

Pick the task you executed twice last month. The boring one: the cost review, the certificate rotation, the disk-pressure triage. Encode it as a skill, in plain language:

"Here's how we handle disk-pressure alerts on the data cluster: check the retention job first, then the two known log-growth offenders, and only page a human if free space stays under 15% after cleanup. Turn this into a skill."
Run it in Manual. Let the agent propose while you keep approving every action. Compare its calls against yours for a couple of weeks. Every divergence is either a fix to the skill or a lesson for you, and both compound.
Promote it, and say so in outcome language. When the evidence supports it, move the specific actions you trust (clearing the retention job, rotating the log) to Auto, and leave everything else in Manual. Then write the two-sentence summary a business owner would care about, and send it. That sentence is your first forward-deployed deliverable.

Repeat until the toil is encoded and your calendar is full of the work that was always the valuable part.

The same move, one layer up

This has happened before. When cloud infrastructure commoditized the sysadmin's execution work, the sysadmins who moved up the stack became DevOps engineers (better paid, more leveraged, closer to the business), and the ones who defended the server room didn't. Nobody mourns racking and stacking. The judgment moved up a layer and got more valuable.

AgenticOps is the same move in a new cycle. The agents take the execution: the cost runs, the patch cycles, the 3 a.m. triage. The engineer takes the layer above: encoding the knowledge, designing the trust, governing the actions, owning the outcome. One of those layers is commoditizing while postings for the other have grown 5,230%.

The forward deployed engineer isn't a job you apply for. It's a way of working you can start practicing this month, on the infrastructure you already run, with the runbooks already in your head. CloudThinker is the platform we built for that practice: skills to encode what you know, Auto Mode to promote trust at your pace, and guardrails so the agents earn production access instead of assuming it.

If you want to see what your first encoded runbook looks like, talk to us. Bring the task you executed twice last month.

And if you read this whole post nodding: we practice what it preaches. CloudThinker is hiring Forward Deployed Engineers for AgenticOps: embed with our customers, encode their runbooks into skills, design the trust ladders and own the outcomes. The job description is this article with a salary attached.