As of 2026-05-23

As of 2026-05-23

There is a recurring pattern in the LLM tooling market. A category of third-party tools emerges to solve a problem the foundation model APIs do not yet solve. The category gets healthy. Then, somewhere between six and twenty-four months later, one of the major providers ships native functionality that does the same thing well enough for most use cases. The category does not disappear, but it shrinks dramatically — and the teams that built their stack around it spend the next year refactoring.

This has happened enough times to be predictable. It is worth naming.

The pattern, in three acts

Act 1 — third-party fills a gap. Function calling existed as an ad-hoc JSON-prompting practice with frameworks like LangChain providing the schemas and dispatch. Vector retrieval existed as Pinecone + Weaviate + custom chunking. OCR existed as Textract + Tesseract pipelines. Transcription existed as Whisper-as-a-service offerings. Content moderation existed as Perspective and Hive. All of these were defensible product categories before the major LLM providers had a native answer.

Act 2 — the platform absorbs the easy 80%. OpenAI shipped function calling in June 2023, generalized it into tools and Assistants in late 2023, and has continued to consolidate. Anthropic shipped tool use, then native PDF support, then computer use, then web search, then MCP. Google shipped grounded retrieval, native multimodal, and Live API for audio. Each of these absorptions did not kill the corresponding third-party category, but it ate the broadest, lowest-friction segment of the market and left the rest fighting for the harder cases.

Act 3 — the category survives where the platforms cannot or will not go. Pinecone et al. did not die when OpenAI shipped file search; they kept the customers with serious scale, multi-model needs, hybrid retrieval, and governance requirements. LangChain did not die when function calling went native; it kept the customers with multi-provider needs, complex orchestration, and team-wide opinionation. The third-party survives by serving the cases the platform refuses to handle well, but the addressable market shrinks.

This three-act pattern is what makes recognizing "patterns under pressure" worth doing. You are not betting on whether a tool survives — many do. You are betting on how much of your architecture sits in the absorbable layer.

Why this is structural

The absorption pattern is not an accident or a marketing aggression. It is the predictable consequence of three things:

Commoditize-your-complement economics (Spolsky, Strategy Letter V). If you sell X, make Y (the complement) cheap or free so more X gets bought. Foundation model providers sell tokens. Anything that makes it easier to use their tokens — better tool calling, better RAG, better multimodal — sells more of their tokens. The economic incentive to absorb adjacent layers is permanent.

Information advantage. The provider knows what their model is good at and what is coming next. They can tune RAG, function calling, agent loops, and tool selection to the model in ways a third party building on top has to discover by experimentation.

Distribution. When OpenAI ships file search in the platform, every existing OpenAI customer can try it with one config line. When Pinecone ships a feature, customers have to integrate. The asymmetry is large.

These three forces combined mean that any LLM tooling category whose value is mostly "we make using the foundation model easier" is permanently under pressure.

What is genuinely durable

Not everything is absorbable. The categories that survive multiple model generations tend to share one of these properties:

  • Multi-provider, multi-model orchestration. Tools that genuinely make it easier to switch between providers (Aider, OpenRouter, some of LangChain's value) survive because providers do not commoditize their own competition.
  • Infrastructure that is not just API glue. Real vector databases (Pinecone, Weaviate, Qdrant) survive because they handle scale, filtering, hybrid retrieval, governance, and operational concerns the API providers do not. The "wrap an embedding endpoint" category dies; the "operate a serious vector store" category does not.
  • Domain depth beyond LLM tokens. Tools that combine LLMs with deep domain models (medical imaging, legal contract analysis, code static analysis) are insulated because the LLM is only one component.
  • Workflow and observability across many models. Eval frameworks, prompt management, trace storage, multi-model A/B testing — these benefit from being model-agnostic by design.
  • Governance and compliance. Auditability, SOC 2, region-locked inference, BYO-key controls. The platforms ship some of this but enterprise needs run ahead of what comes native.

The map, for now

The current 2026 layer map, organized by pressure:

High pressure (likely absorbed by 2027):

  • Basic function-calling / tool-use wrappers
  • Single-purpose RAG frameworks that just wrap embeddings + retrieval
  • Standalone OCR services for clean documents
  • Basic batch transcription
  • Generic content classifiers
  • "Easy RAG as a product" startups

Medium pressure (will narrow but survive):

  • Multi-modal RAG with specialized chunking (will narrow to niche)
  • Embedding services (will narrow to specialized embeddings)
  • Visual agent builders (will narrow to business-user prototyping)
  • Prompt-engineering-as-a-discipline (already mostly absorbed by context engineering)

Lower pressure (durable for the foreseeable future):

  • Vector databases at scale, with governance
  • Multi-provider orchestration tools (LangChain at its best, Aider, OpenRouter)
  • Evaluation and observability frameworks
  • Domain-specialized AI products
  • Compliance, governance, audit tooling

This is a snapshot. The categories shift; the framework for thinking about them does not.

How to use this cluster

The three companion articles drill in:

The right read is not "everything in AI is doomed" — most of these tools genuinely help right now. The right read is "where am I building durable infrastructure vs where am I building wrappers." If you can answer that for your own stack, you are ahead of most teams.