Why Anthropic, OpenAI, and Accenture all bet on Forward Deployed Engineers — and what it means for everyone else

In May 2026, OpenAI stood up its Deployment Company with more than $4 billion in committed capital and a planned acquisition of Tomoro, a forward-deployed engineering firm of roughly 150 people. A few weeks earlier, Anthropic, Blackstone, Hellman & Friedman, and Goldman Sachs announced an AI-native enterprise services firm built around embedded engineering teams — explicitly targeting mid-sized companies and redesigning workflows around agents. Accenture launched a dedicated Forward Deployed Engineer (FDE) practice with Microsoft. Bob McGrew's lecture series at YC and Lightcone has been hammering the same point for months: AI rollout is a "gravel road" — you solve manually for the first ten customers, then productize.

If you spent 2024 and 2025 wondering when AI was going to actually land inside real businesses, this is the answer. It's landing now, and it's landing through Forward Deployed Engineers.

This post is about why FDE has become the critical job in enterprise AI rollouts, why most firms can't solve it by hiring or by buying SaaS, and what changes when the FDE motion ships as software.

Agentic integration is a program, not a project

Most organizations are already somewhere in an early form of agentic integration. A few automations live in production. Claude is in the building. Someone on the ops team has been quietly running an agent against inbound for two months. It's working — until it isn't.

What almost none of them have figured out is that this is not a one-time install. Agentic integration is a continuous effort that has to stay aligned with how teams actually work. The ICP shifts. A new tool replaces an old one. A compliance rule lands. The model gets deprecated. The "automation that used to work" quietly drifts and nobody catches it until the outputs stop matching what an experienced operator would have produced.

That is the real reason the FDE role is exploding. Someone has to own that loop — make it process-driven, keep it moving, and prevent every new use case from being a fresh greenfield project that forgets everything the last one learned.

What an FDE actually does

The label comes from Palantir. The job, in plain language: an engineer embedded with a customer who owns the integration end to end — from understanding the business process well enough to encode it, to wiring the technology into the customer's data and tools, to running it against real outcomes and tuning until it works.

The reason the role exists is that there is no shrink-wrapped version of "make AI work for your business." Every customer's data lives somewhere different, every approval chain has its own rules, every team's definition of "good output" comes from tacit knowledge that nobody wrote down. Software that pretends otherwise ships a demo and dies in pilot.

FDEs solve this by treating the deployment itself as the product. The first version is built by hand for one customer, against their actual systems, until it produces outcomes that customer is willing to pay for. Then the patterns that worked get pulled back into reusable tooling.

This used to be a Fortune 500 luxury — six-month engagements, six-figure budgets, dedicated machine learning teams. It is now becoming the default delivery model for AI at every tier of the market.

Why deploying agents is not like deploying software

Software usually runs a deterministic process. You ship the binary, the binary runs the same code every time, you monitor uptime and errors.

Agents are different. An agent doesn't run a process — it performs work inside a business. That means deployment has six discovery surfaces that traditional software shipping doesn't:

Process discovery. What does this team actually do, in what order, with what exceptions? What's documented vs. what lives in someone's head?
Model selection. Which model for which step? Latency budget? Cost ceiling? Open vs. frontier?
Data setup. What systems hold the source of truth? Where does enriched output go back? What's the dedup key per record?
Evals. What does "good output" mean for this team, in terms specific enough to test? You can't ship without this and you can't write it without doing the work.
Change management and approvals. Who reviews outputs before they go to a customer? When does it auto-send vs. when does it queue for human review?
Continuous tuning. The first run is never the last. Real prospects, real edge cases, real escalations come back as feedback. Someone has to close the loop.

None of these surfaces are addressable by "give the customer an API key and a docs page." All of them are addressable by an FDE who can sit with the team, run the deployment, and own the outcome.

What's actually happening in the market

Walk through the announcements together and a pattern shows up:

OpenAI Deployment Company. $4B+, Tomoro acquisition, a stated mission of putting GPT-class agents into Fortune 500 workflows. Build engagements first, productize what works.
Anthropic + Blackstone + Hellman & Friedman + Goldman. An AI-native enterprise services firm with senior engineers embedded with customers, with Anthropic's model layer underneath — and an explicit mid-sized-company target. Even Anthropic's own venture isn't pointing at the Fortune 500 alone.
Accenture FDE practice with Microsoft. The system integrator that already runs Fortune 500 transformations is staffing a dedicated FDE team under the Microsoft umbrella.
YC and Lightcone "gravel road" playbook. McGrew's framing has become the template for early-stage AI companies: don't try to productize before you've done the work by hand for ten customers.

Same bet from every angle: AI integration depth — the kind that produces real ROI — comes from senior humans owning the deployment, not from self-serve sign-ups. The market is large enough that you can build a real business around that delivery model, then productize the recurring patterns over time.

The bet is correct. The question is who gets served by it.

The gap: firms won't hire the headcount, and SaaS can't learn their context

If you're running a mid-market or small business — call it 30 to 500 people — and you've watched the OpenAI and Anthropic announcements, you've probably had two thoughts in quick succession.

Thought one: we need this. Process discovery, build, validate, deploy, monitor, iterate — that's the loop, that's what produces the ROI, and we don't have anyone on the team owning it.

Thought two: we are not hiring a Forward Deployed Engineer. Adding a permanent technical headcount for "AI integration" doesn't survive contact with the budget. Neither does a 20-week Accenture engagement.

The reflex is to fall back to off-the-shelf automation tooling. The reflex doesn't work either — not because the tools are bad, but because they cannot learn your context. Generic automation starts every workflow from zero. It does not know your ICP. It does not know which accounts you've paused. It does not know that your scoring rubric was updated last month or that the last three outbound campaigns to fintech CTOs underperformed because the message was too long.

The gap is real, and it's structural. The work needs a dedicated function. Firms won't hire for it. SaaS can't replace it. Something has to give.

Your team's FDE function — built on agents you supervise

Every previous wave of expensive expertise got solved the same way: take the expert function, find the parts that repeat, and turn those into software the expert runs.

For forward-deployed engineering, the part that repeats is the loop: find what's worth building next, integrate it, validate it against your team's bar for good output, deploy with approval gates, watch the outcomes, and iterate until the ROI is real — then carry the context and learnings into the next cycle instead of starting over.

That loop is what AgentLed runs. Where you start depends on where your team already is:

You're already using AI agents. Connect them to AgentLed and use it to drive the loop — discovery, deployment, monitoring, and the memory that carries each cycle's learnings into the next.
You're not there yet. We integrate it into your workflow and show your team how to run the loop with agents, then hand it over once it's routine.

Either way, the agents do the execution under your team's supervision, and the workspace remembers what every cycle learned — so your own people become your FDE function instead of you hiring for one.

The moat is compounding context

This matters more than any single workflow, integration, or deployment.

When the loop runs on a workspace that retains context, every cycle makes the next one cheaper and sharper. Your ICP, scoring rubric, paused accounts, approval rules, and outcome data stop being scattered knowledge and become an asset. The second deployment starts where the first ended; the fifth inherits everything the first four learned.

That's the real ROI: a compounding capability. Each integration raises your team's baseline ability to do the next. After a year you're not running ten isolated automations; you're operating from a workspace that knows your business better than a new hire would.

It also means model progress works for you instead of against you. As the agents underneath get better — Claude, Codex, and whatever ships next — your integrations get faster and sharper automatically, because the hard part is already done: the workspace already knows your business. Better models drop straight into context that's been accumulating the whole time. The more the frontier moves, the more that retained context is worth.

The substrate underneath

We can run the loop at this price because the hard infrastructure is already built. The toolkit isn't the pitch — it's the proof the machine exists — but it's worth naming so it doesn't stay abstract:

A dedicated workspace per customer that holds your credentials, integrations, decisions, and accumulated context in one place — so nothing about your setup lives in someone's head.
A knowledge graph that remembers your ICP, scoring rubrics, approval rules, and paused accounts across every workflow, so each new deployment inherits what the last ones learned.
Connectors for the systems you actually run on, behind one credit system instead of a stack of separate API subscriptions to manage and reconcile.
An automation engine with retries, caching, and human-in-the-loop approval built in — so agents fail safe and nothing reaches a customer without the review you set.
Agents that live where your team works: each with its own email address, deep Slack presence, and the ability to ingest meetings and threads — so they act inside your workflow, not in a separate tab.
A UI the agents build on themselves: custom forms, pages, and menus generated for each engagement, plus POC and client tracking that shows who owns what — so a deployment is something your team runs, not a black box.
Monitoring and a token-management view, so cost and ROI are dashboards you watch, not surprises you discover.

These are the backbone, not the boundary. Each one is a starting point the agents build deeper integrations on — the more your business runs through it, the more the agents can do. None of it is what you're buying, though. What you're buying is a supervised loop that compounds — this is what makes it cheap to run.

Why this matters past 2026

The FDE wave is not a temporary scaffold. It is how AI integration gets done for the rest of the decade, because the underlying problem — agents performing work inside a business, against tacit knowledge, with real consequences — does not have a self-serve answer yet. Maybe ever.

But the shape of the work compounds, and that is the part most firms underestimate. Every cycle makes the next one easier. Every retained piece of context makes the next deployment shorter. Over time, what starts as human-led delivery becomes AI-assisted delivery, and eventually AI-led delivery for the workflows that have been running long enough to know their own edge cases.

The companies building this infrastructure now — OpenAI's Deployment Company, Anthropic's services firm, Accenture's FDE practices, and platforms like AgentLed serving the long tail — are not betting on a temporary services business. They are betting that the path from where AI is today to where it has to go runs through deployment software, not through better models alone.

If you're a mid-market or small business looking at the OpenAI and Anthropic announcements and wondering whether AI is finally for you, the short answer is yes. The longer answer is that you don't need a $4 billion deployment company to get there, and you don't need a permanent headcount either. You need the FDE function as software, running a supervised loop, on a workspace that compounds.

That's the work. That's what we're building for.

Try it

If you want to see the substrate in action, paste this into your coding agent:

use https://cli.agentled.ai/install.md to install AgentLed

If you want the supervised loop run for you — yours or your clients' — and you'd rather have it as software than a six-month contract: reach out.