Nobody sets out to build on a product that gets sunset in eighteen months. It happens anyway, and not because engineers are careless. It happens because the AI stack is still being sorted into layers, and sorting is a violent process. Products that looked like infrastructure in 2023 turned out to be features. Products that looked like features turned out to be infrastructure.
A running list of dead AI projects is easy to read as gossip. Read it as a procurement document instead. Each entry tells you something about durability: which layers of the stack are commoditising, which are load-bearing, and which were never really products at all. Below is a roundup of the layers most teams actually buy in, with notes on when each is worth the dependency, when it is not, and where the pricing will bite you long after the launch blog post is forgotten.
What the graveyard actually teaches buyers

Figure: Editorial context image from the source page (preview only; rights remain with the publisher) · Credit / further reading: techcrunch.com
Three patterns recur in almost every post-mortem, and all three are checkable before you sign.
The wrapper problem. If a product's entire value is a prompt, a UI, and an API key, its margin is a rounding error away from zero. Model providers keep absorbing the layer above them — retrieval, structured output, tool calling, memory, file handling. Anything a provider ships as a first-class feature is a bad place to build a business, and a risky place to build a dependency.
The demo-to-production gap. Assistants that impress in a five-minute video often collapse on the fourteenth edge case. The failure is rarely the model. It is the absence of evals, the absence of fallbacks, and no plan for what happens when the confident wrong answer reaches a customer.
The distribution tax. Plenty of technically fine projects died because they were a destination rather than a component. A tool that requires users to remember to visit it loses to a tool embedded in a surface they already open. That is not a product flaw you can patch with a better model.
Layer 1: The model layer — rent aggressively, marry never
For most teams, the right posture toward frontier model APIs is promiscuity. Route by task, keep at least two providers wired up behind your own thin abstraction, and treat any single-provider dependency as a business continuity risk rather than a technical preference.
When to use it: nearly always, unless you have a hard data-residency requirement, a latency budget that only a self-hosted small model can meet, or unit economics where per-token cost dominates your gross margin.
When not to: do not fine-tune on day one. Do not build a bespoke inference stack because a benchmark chart looked good. Do not let a provider's proprietary assistant format become your internal API contract.
Pricing caveat: the sticker price per million tokens is the least stable number in your cost model. Compare effective cost after retries, re-ranking, tool-call round trips, and the long-context usage that creeps in once users discover they can paste whole documents. Watch for pricing tiers that shift with volume in ways that punish growth, and for deprecated model snapshots with short notice windows — a forced migration is a cost even when the tokens are free.
Layer 2: Orchestration and agent frameworks
Frameworks that wire prompts, tools, and state together are genuinely useful. They are also the layer most likely to be re-absorbed.
When to use: when you have three or more distinct tool-calling flows, multiple developers touching the same prompts, and a real need for tracing and replay. A framework earns its weight when it replaces bespoke glue you would otherwise maintain badly.
When not to: if your workflow is a single prompt with one function call, plain code is clearer, faster, and will not be abandoned by a maintainer. Teams routinely adopt a heavyweight graph framework for a two-step pipeline and then spend a quarter working around it.
Pricing caveat: many orchestration layers are open source with a paid control plane. Understand precisely what breaks when the paid tier lapses — tracing history, hosted evaluations, guardrail services, SSO. If the answer is "production stops," you have bought a managed service with an open-source mascot, not an open-source library.
Layer 3: Retrieval and vector storage
This is the most commoditised layer in the stack, which is good news: it is also the easiest to keep swappable.
When to use a dedicated vector database: when you are past roughly a few million chunks, when you need filtered search at low latency, or when multiple services need shared access to the same index with proper access control. Managed offerings are worth it when operational simplicity is the actual bottleneck.
When not to: early-stage products are usually better served by vector search bolted onto the relational database they already run, or by a hosted search product the team already knows. Adding a specialised store before you have a retrieval quality problem means you have added a failure mode without adding capability.
Pricing caveat: vector stores price on dimensions, replicas, queries, or some blend, and the blend changes. The expensive surprises are almost never storage — they are query volume, cross-region replication, and the cost of re-embedding an entire corpus when you change embedding models. Budget for re-indexing as a recurring operation, not a one-time migration.
Layer 4: Evals and observability
This is the layer teams cut first and regret longest. It is also, per the graveyard, the layer where the survivors cluster.
When to use: before your first production prompt. Even a spreadsheet of twenty graded examples beats vibes. Buy a hosted platform when you need trace storage, annotation queues for non-engineers, and regression dashboards that survive staff turnover.
When not to: if your product has a single narrow task with an objective pass/fail check, a scripted test suite is enough. Do not pay per-seat for a dashboard nobody opens.
Pricing caveat: eval tooling prices on traces ingested, seats, or both. Trace volume grows with success, which means your observability bill can outrun your revenue in a good month. Set sampling policies and retention limits at the start — retrofitting them after the invoice arrives is politically painful.
Layer 5: The packaged assistant temptation

Figure: HEXOPS original illustration inspired by the topic (not a copy of the source article imagery) · Credit / further reading: techcrunch.com
Every cycle produces a wave of ready-made assistants and "super app" bundles promising to collapse your roadmap into a subscription. Some are genuinely good leverage. The failure mode is buying one for a workflow that is core to your differentiation.
When to use: back-office, internal knowledge lookup, ticket triage, draft generation, meeting notes — anywhere the output is reviewed by a human and the workflow is not what customers pay you for. The bar is simple: could you replace it in a quarter without telling your customers?
When not to: anything customer-facing where tone, latency, control over tool use, or data handling is part of the product. If the vendor's roadmap determines your feature availability, you are a reseller with extra steps.
Pricing caveat: seat-based assistants scale with headcount, not value, and employee counts fluctuate. Watch for per-seat minimums, annual prepay discounts that lock you in ahead of a roadmap you have not seen, and data-processing clauses that quietly permit training on your content unless you negotiate out.
A swap-readiness checklist
Before adopting any layer, write down four things: the abstraction boundary you will code against, the migration estimated in engineer-days, the data you would need to export and in what format, and the specific signal that would trigger the exit. If any of the four is blank, you are not buying a tool — you are buying a surprise.
Also ask what the vendor's last two releases changed about pricing or packaging. Packaging changes are the leading indicator of a business model under pressure, and they usually precede the notice email by a year.
Key takeaways
- A shutdown list is a durability map: commoditised layers are safe to rent, differentiated layers are dangerous to rent.
- Route across at least two model providers behind your own thin abstraction; treat single-provider dependency as continuity risk.
- Adopt orchestration frameworks only when they replace glue you would otherwise maintain badly.
- Keep retrieval swappable and budget for re-embedding as a recurring cost, not a migration.
- Buy evals early, but cap trace volume and retention before the invoice teaches you.
- The real test for any packaged assistant: could you remove it in a quarter without customers noticing?
Next steps
- Inventory every AI dependency you have, and label each as commodity, differentiator, or unknown.
- For each "differentiator" dependency, write the exit trigger and the estimated migration cost in engineer-days.
- Add a second model provider to your routing layer this month — even at 5% of traffic.
- Cap observability sampling and retention in writing before your next renewal.
- Put a 30-minute vendor-risk review on the calendar each quarter. Graveyards fill quietly.



