By 2028, 70 Percent of Enterprises Will Abandon Vendor-Built Agentic AI

On September 29, 2026, Gartner published a prediction: by 2028, 70 percent of enterprises will abandon agentic AI built by vendor forward-deployed engineering, trapped by soaring costs and unable to evolve it on their own. FDE is a delivery model in which vendor engineers work directly with customers to build and deploy solutions. Gartner argues that FDE engagements often fail structurally before they fail technically, and lays out three tenets across three phases: before signing, during the engagement, and at exit. It also predicts that through 2028, less than 20 percent of FDE engagements will turn recurring customer needs into capabilities in the vendor's core product, exposing the risk of 'FDE washing', where consulting services are marketed as forward deployed. Here is what the prediction rests on, and a checklist buyers can use.

1. What FDE Is, and Why It Fails

Pin the concept first. Forward-deployed engineering is a delivery model in which vendor engineers work directly with customers to build and deploy solutions. Gartner's prediction is that by 2028, 70 percent of enterprises will abandon agentic AI built by vendor FDE, trapped by soaring costs and unable to evolve it on their own. The key judgement is that FDE engagements often fail structurally before they fail technically. Structural here means the decisions made before contracting, during delivery and at transition, when software engineering leaders still control scope, incentives, governance and ownership. Code sample 1 expresses the prediction and what it means for a buyer as readable structure.

# Gartner's headline: by 2028, 70% of enterprises will abandon agentic AI
# built by vendor forward-deployed engineering (FDE), trapped by soaring
# costs and unable to evolve it on their own. FDE is a delivery model in
# which vendor engineers work directly with customers to build and deploy.

FDE_OUTCOMES = {
    "abandon_by_2028": 0.70,          # Gartner prediction
    "recurring_needs_to_core_product_by_2028": 0.20,  # less than 20%
}

def read_the_market(engagements):
    return {
        "structural_failure_rate": FDE_OUTCOMES["abandon_by_2028"],
        "note": "Gartner says FDE engagements often fail structurally "
                "before they fail technically",
        "buyer_question": "can my team operate and evolve this without the vendor?",
    }

Before signing, during delivery, at exit

2. Tenet One: Before Signing

The first tenet lives before the contract is signed. Gartner's advice is to use FDE only for problems that genuinely require deep product expertise, rapid adaptation, or close integration between vendor technology and your operating environment, rather than everything with an AI label attached. It stresses two things. Name an executive sponsor who is accountable for business outcomes, not simply the implementation budget. And establish contractual requirements beyond procurement's scope, including deliverables, knowledge transfer, intellectual property rights, and transition or exit responsibilities. Put another way, where the scope is clear, a traditional services or partner model may deliver the same result more cost-effectively and with more predictable results. Code sample 2 turns that into an eligibility function and a contract checklist.

# Phase 1: before signing. Scope the engagement around problems that truly
# need deep product expertise, rapid adaptation, or tight integration between
# vendor tech and your operating environment -- not everything with "AI" in it.

CONTRACT_REQUIREMENTS = [
    "named deliverables with acceptance criteria",
    "knowledge transfer plan with dates and owners",
    "intellectual property rights and ownership of artefacts",
    "transition and exit responsibilities",
    "an executive sponsor accountable for BUSINESS outcomes, not just budget",
]

def fde_only_for(problem) -> bool:
    return any([
        problem.needs_deep_product_expertise,
        problem.needs_rapid_adaptation,
        problem.requires_tight_integration_with_our_env,
    ])
# If none hold, a traditional services or partner model may deliver the same
# result more cost-effectively and with more predictable results.

3. Tenet Two: During the Engagement

The second tenet applies during delivery. Gartner's advice is to embed FDEs with internal domain experts, engineers and end users so that critical knowledge is shared and the solution reflects how work actually gets done. Operationally, establish a cadence of iterative business validation that evaluates not only technical performance but also the operating model required to scale AI responsibly. Use each increment to define decision rights, determine the appropriate balance between autonomy and human oversight, clarify how confidence and exceptions are communicated, and build the governance mechanisms that sustain user trust and accountability. Code sample 3 lays out the questions a single increment review should answer. The core point is that knowledge must stay inside the enterprise, rather than residing in the vendor's delivery team.

# Phase 2: during the engagement. Embed FDEs with your own domain experts,
# engineers and end users so critical knowledge is shared and the solution
# reflects how work actually gets done. Validate against the operating model,
# not just benchmarks, and settle decision rights early.

def validate(increment):
    return {
        "technical_performance": increment.benchmarks,
        "operating_model_ready": increment.can_scale_responsibly(),
        "decision_rights": increment.who_decides(),
        "autonomy_vs_oversight": increment.balance,
        "exception_handling": increment.how_confidence_is_communicated(),
        "governance": increment.trust_and_accountability_mechanisms(),
    }

# Use each increment to define decision rights and the balance between
# autonomy and human oversight before scaling further.

Knowledge transfer separates success from failure

4. Tenet Three: Exit and Prove Independence

The third tenet covers exit, the step most often skipped. Gartner's advice is to execute the exit plan established at the start rather than extending the engagement because internal teams are not ready. The organization must develop the capabilities, governance and operational ownership required to independently sustain and evolve the solution over time. Gartner's definition of success is worth copying verbatim in spirit: success is measured not by implementation completion, but by the enterprise's ability to manage, optimize and scale the technology, including adapting human-AI decision models as business processes, priorities and risk profiles evolve. Code sample 4 breaks independently evolvable down into a checklist.

# Phase 3: exit and prove independence. Execute the exit plan established at
# the start instead of extending because internal teams are not ready.
# Success is measured by the enterprise's ability to manage, optimize and
# scale the technology -- including its human-AI decision models.

EXIT_READINESS = [
    "internal team can run day-to-day operations unassisted",
    "internal team can make changes and ship improvements",
    "internal team owns governance and risk decisions",
    "internal team can adapt human-AI decision models as risk evolves",
]

def success(enterprise):
    return {
        "implementation_complete": enterprise.on_time_and_in_budget,
        "independently_evolvable": all(enterprise.check(e) for e in EXIT_READINESS),
        "true_success": enterprise.independently_evolvable,
    }

5. FDE Washing: Consulting Marketed as Forward Deployed

Gartner also issues a warning. It predicts that through 2028, less than 20 percent of FDE engagements will turn recurring customer needs into capabilities in the vendor's core product, exposing the risk of FDE washing, where consulting services are marketed as FDE. In analyst Mukul Saha's words, many providers now use forward deployed as a label for implementation, professional services, solution engineering or AI consulting, some thoughtfully and others because it sounds more strategic, and some charge premium fees without the delivery depth, program management or change management maturity to justify them. The result is that customers may see faster early progress but fail to build internal capability, ending up paying premium rates for work a traditional services or partner model could potentially deliver more cost-effectively and with more predictable results. Code sample 5 gives a detection function.

# The warning: FDE washing. Gartner predicts that through 2028, less than
# 20% of FDE engagements will turn recurring customer needs into capabilities
# in the vendor's core product, exposing consultants that label themselves
# "forward deployed" without the delivery, program or change-management depth.

def spot_fde_washing(vendor) -> list:
    flags = []
    if vendor.charges_premium and not vendor.has_delivery_depth:
        flags.append("premium fees without delivery depth")
    if vendor.uses_label_for("implementation or professional services"):
        flags.append("label used as marketing, not a distinct model")
    if not vendor.has_program_management_maturity:
        flags.append("no program management maturity")
    return flags     # customers may see fast early progress, then stall

Success is measured by independence to evolve

6. A Checklist for Buyers

Finally, turn the judgements into action. First, ask before signing whether the work truly needs FDE once the scope is clear; if none of the three eligibility conditions holds, go back to a traditional services or partner model, as code sample 2 checks. Second, treat exit as a clause you write on day one rather than a conversation at the end, covering deliverables, knowledge transfer, IP rights, and transition or exit responsibilities. Third, bind the executive sponsor to business outcomes rather than the implementation budget. Fourth, use each increment to settle decision rights, the autonomy-versus-oversight balance and exception handling, as code sample 3 frames. Fifth, accept exit on the basis of whether the enterprise can independently manage, optimize and scale, not merely whether implementation finished on budget, as code sample 4 does. Sixth, stay alert to FDE washing and screen out providers with the label but not the depth using the signal function in code sample 5. Do those six things and you may be among the minority not counted in the 70 percent.