How to Stratify the AI Value Chain: A Deliverable-Based Framework Instead of Technology Layers
AI industry reports often contradict each other not because of a lack of information, but because analysts choose the wrong axis for stratification—usually "technology level." This article argues for a more durable approach: classify the AI value chain by what the customer actually buys, not by how advanced the technology is. It divides the chain into four stable layers—Compute Foundation, Data & Platform, Models & Algorithms, and Applications & Agents—each anchored to a concrete deliverable. It explains why technology-based, popularity-based, and coarse upstream/midstream/downstream approaches all fail, maps the cost structure, customer base, margin profile, and evolution risk of each layer, and gives directional predictions on how each layer will develop. Readers will come away with a practical method for classifying AI companies, a way to reason about capability sinking and value reflow, and a framework that supports more logic-driven, less luck-dependent decisions.
How to Stratify the AI Value Chain: A Deliverable-Based Framework Instead of Technology Layers
Before discussing any industry chain, you have to answer one preliminary question first: by what dimension do you split it? This question looks trivial, but it decides whether every downstream analysis, benchmark, and decision actually holds up. Many AI industry reports contradict each other and resist horizontal comparison—not because information is lacking, but because the coordinate axis for stratification was chosen wrong.
The core argument of this article is a single sentence: Don’t stratify by “technology level”—stratify by “deliverable.” Below, I’ll work through the why, the how, and where each layer is heading.
1. Why Stratifying by “Technology Level” Almost Always Fails
Technology stratification—for example, “chip → framework → model → application”—is intuitively clean and matches most people’s naive mental model of the tech stack. But it has a fatal flaw: technology is fluid, while industry boundaries are not.
A capability that lives in the application layer today may be abstracted into a built-in model feature six months later, and a year after that hardwired into a chip’s instruction set. Take “text correction” as an example: early on it was a standalone product module in the application layer; then it was absorbed into the output capability of general-purpose large models; and further out, it may enter hardware in the form of a dedicated acceleration unit. If your industry map is drawn by “the height of the technology,” then every time this capability sinks down one layer, you have to redraw the map.
Put differently, stratifying by technology gives you a dynamic snapshot that needs constant maintenance, not a stable, reusable map. For anyone doing long-term tracking, this is close to the worst possible axis.
2. Why the Three Common Approaches Fail
Before switching to a deliverable-based axis, it’s worth laying out the three common wrong approaches, because they fail in different ways but with the same consequence.
2.1 Stratifying by Tech Stack: Stuffing Non-Commercial Entities Into the Chain
The problem with tech-stack stratification (chip → framework → model → application) is that the framework layer isn’t really an “industry.” Deep learning frameworks and distributed training libraries are mostly open source. They have no independent, well-defined revenue structure, and their value is realized indirectly through other layers. The moment you force this layer into the industry chain, its “representative companies” become a pile of foundations, open-source communities, and labs.
Once you mix non-commercial entities into the stratification, the basic assumption of industry-chain analysis—“every layer has a comparable revenue and profit structure”—collapses. Every subsequent horizontal comparison involving scale, gross margin, and growth rate loses its meaning.
2.2 Stratifying by Popularity: You Get a Heat Ranking, Not an Industry Chain
The second common approach is to “place companies with the most funding, the most launches, and the highest buzz at the center of the map.” What you draw is essentially a heat ranking, not an industry-relationship map.
The biggest problem with a heat ranking is non-unique attribution: the same name can show up in three segments at once. A company that rents out compute, builds models, and ships end-user applications will be labeled repeatedly across the ranking, which drains the concept of a “segment” of any discriminating power.
2.3 Stratifying by Upstream/Midstream/Downstream: Too Coarse to Be Useful
“Upstream hardware, midstream platform, downstream application” isn’t wrong, but it’s too coarse. In the “midstream” box alone you might lump together: sellers of corpus and annotation data, sellers of compute-rental resources, and sellers of model-invocation capabilities. These three businesses have completely different margin, customer, and cost structures. Putting them in one box throws away the point of classification.
The three approaches look different, but their shared outcome is identical: the same company gets placed in different segments across different reports, and the basis for comparison disappears. Two companies that both appear to “do compute” may actually sit at completely different points in the chain, with utterly different investment logic and competitive logic. This kind of judgment is hard to piece together from headlines.
3. The Stable Axis: Anchor on the “Deliverable”
The conclusion follows: use “what the customer actually buys” as the single basis for stratification.
The deliverable dimension is stable because it’s anchored on real transaction relationships, not on technology form or market buzz. A customer’s purchasing decision won’t change just because a capability hides in the application layer today and sinks into the model layer tomorrow—what they pay for is fixed. So the “what is being sold” axis doesn’t drift as technology evolves.
Along this main thread, the AI value chain splits cleanly into four layers. The earlier the position, the closer to hardware and infrastructure; the later, the closer to concrete business scenarios:
Compute Foundation → Data & Platform → Models & Algorithms → Applications & Agents
4. The Four Layers and Their Deliverables
4.1 Compute Foundation: The Customer Buys a “Hardware Entity”
Deliverable: boards/cards, integrated servers, optical modules, networking equipment, data centers and data-center resources.
The criterion here is direct—the customer ultimately receives a piece of hardware or a physical resource they can touch. It sits at the far upstream, characterized by heavy assets, strong capital expenditure, and clear constraints from capacity and supply chains. Its cost structure is dominated by hardware materials, power, facilities, and depreciation, and its gross margin swings hard with supply-demand cycles.
In cloud scenarios, the compute foundation is usually offered as generic product categories—bare metal servers, GPU cloud hosts, elastic compute instances, and so on. But whatever the packaging, the essence of the deliverable remains “physical or virtual compute resources.”
4.2 Data & Platform: The Customer Buys the “Right to Use a Resource”
Deliverable: corpus data, data annotation services, compute rental, and data-processing and training-platform capabilities.
The key criterion for this layer is “usage right”—the customer doesn’t own the hardware; they buy ongoing access to, or the right to use, some resource. It splits into two categories:
- Data side: high-quality corpus supply, cleaning, annotation, synthetic data, and so on—essentially “the raw material fed to the model”;
- Platform side: data pipelines, feature stores, compute scheduling, and training/inference orchestration platform capabilities.
Its cost structure varies enormously. Pure data services are dominated by labor and collection costs, with margins depending on data scarcity and compliance barriers; the platform side centers on resource-scheduling efficiency and operational cost, with clear economies of scale. In cloud environments these capabilities typically surface as combinations of generic categories—object storage, message queues, container platforms, logging services, monitoring and alerting, and similar building blocks.
4.3 Models & Algorithms: The Customer Buys the “Right to Invoke a Capability”
Deliverable: model APIs, model licensing, inference services, and fine-tuning/training services.
The hallmark here is “invocation right”—the customer doesn’t care which card the model runs on or where the data came from; they just need a stable, meterable, pay-as-you-go or license-based capability interface. This is the fastest-changing and most easily misjudged layer in the modern AI value chain, because its capability boundary keeps expanding.
Its cost structure is dominated by compute consumption (especially the ongoing compute in the inference phase) plus R&D investment. The ability to amortize inference costs at scale often decides the survival space of a company here. When assigning attribution, watch one thing carefully: if a company’s core revenue comes from selling capability interfaces rather than selling hardware or selling finished applications, it belongs to this layer—not to the compute foundation or the application layer.
4.4 Applications & Agents: The Customer Buys a “Finished Product That Does the Work”
Deliverable: software ready for immediate use, scenario-specific agents, and end-to-end solutions.
The criterion here is that the customer buys not raw material, not a usage right, not a capability interface, but a finished product that directly completes a business task—for example, an intelligent response system for customer service, an assistant for office work, or an agent application for a vertical industry.
This layer sits closest to scenarios and delivers value most directly, but it’s also the most easily eroded by upstream “capability sinking”: once a feature is internalized by a general model as a standard capability, the standalone application point can vanish. So its moat usually isn’t the technology itself, but scenario understanding, data closed-loops, workflow embedding, and delivery capability.
5. Commercial Profiles of the Four Layers
Put side by side, the differences are obvious:
| Layer | Deliverable Essence | Customer Base | Main Cost | Margin Profile | Evolution Risk |
|---|---|---|---|---|---|
| Compute Foundation | Hardware entity | Large, concentrated customers | Materials / power / depreciation | Swings hard with supply-demand cycles | Capacity and supply-chain constraints |
| Data & Platform | Resource usage right | Developers, enterprises | Labor / collection / scheduling ops | Good after platform scaling | Data compliance and scarcity |
| Models & Algorithms | Capability invocation right | Developers, enterprises | Compute + R&D | Inference amortization decides survival | Capability being internalized |
| Applications & Agents | Finished product | End enterprises / individuals | Scenario + delivery + data closed-loop | High but easily eroded | Features absorbed by upstream |
The point of this table: once you confirm a target company’s “deliverable” position, its cost structure, margin logic, and risk profile are essentially set—no need to guess from buzz or marketing language.
6. Where Each Layer Is Heading
Understanding the stratification is only the first step; more important is judging where each layer is going. Based on the stable deliverable axis, here are a few directional calls:
1. Compute Foundation: from selling resources to selling efficiency. The marginal return of simply stacking hardware is diminishing. Future competition hinges on output efficiency per unit of compute, unified scheduling of heterogeneous compute, and fine-grained management of power and cooling. The deliverable will evolve from “bare resources” toward “efficient, elastic, green” resource services.
2. Data & Platform: from selling data to selling a data closed-loop. The space for selling corpus one time will narrow; the real moat is a data closed-loop (collection → annotation → synthesis → evaluation) that keeps producing high-value, compliant, feedback-rich data. The platform side will lean harder into integrated orchestration of training and inference.
3. Models & Algorithms: capability keeps expanding, but value sinks toward inference. The model’s boundary will keep swallowing features that once belonged to the application layer, while real cost and differentiation concentrate on inference-side efficiency, stability, and cost. Whoever can push inference cost lower at the same capability level holds the initiative.
4. Applications & Agents: from single-point tools to workflow embedding. Standalone functional apps are easy for upstream to absorb. What survives is the agent that embeds deeply in business processes, builds scenario data closed-loops, and delivers end to end. Its moat is scenario and delivery—not the model itself.
One big trend runs through all four layers: capability keeps flowing forward, and value keeps flowing back. Upstream turns capabilities into standardized products that sink toward scenarios; downstream competes for differentiated value back up through scenarios and data. Understanding this two-way flow matters more than memorizing any static product list.
7. Practical Advice for Practitioners
To put this methodology into daily work, keep three points in mind:
- Ask “what did the customer buy” before “what technology does it use.” The deliverable decides attribution; the technology only decides implementation. Don’t conflate the two.
- Allow a company to span multiple layers, but anchor on one deliverable per analysis. Spanning is a normal business reality; break it apart and evaluate by specific deliverable, avoiding the crude “one company = one segment” mapping.
- Treat the stratification map as a “stable map” and the technology list as a “periodic snapshot.” The map is for long-term tracking and horizontal benchmarking; the snapshot is for short-term product observation. Their uses differ—don’t let one replace the other.
A simplified classification routine captures the whole method:
def classify_ai_company(primary_revenue: str) -> str:"""Use "primary revenue source / deliverable" as the sole basis for stratification.Note: classify by deliverable, not by tech stack or popularity."""if primary_revenue.kind == "hardware": # boards / integrated servers / optical modules / data centersreturn "Compute Foundation"if primary_revenue.kind == "resource_access": # corpus / annotation / compute rental / platformreturn "Data & Platform"if primary_revenue.kind == "capability_api": # model API / licensing / inference servicereturn "Models & Algorithms"if primary_revenue.kind == "finished_product": # ready-to-use finished product / agentreturn "Applications & Agents"raise ValueError("Deliverable cannot be classified; a further breakdown of revenue structure is required")
The code looks simple, but it distills the core discipline: the classification function takes only a “deliverable”—never “technology level” or “buzz.” As long as the input is a deliverable, the output is stable; the moment the input switches to technology form, the map starts failing again as capability flows.
8. Conclusion
The complexity of the AI value chain isn’t that it has too many segments—it’s that most people use the wrong axis to stratify it. Stratify by technology and you redraw the map every year; stratify by popularity and you get a heat ranking; stratify by upstream/midstream/downstream and your granularity is too coarse to compare.
But stratify by deliverable—compute foundation, data & platform, models & algorithms, applications & agents—and you get a stable map anchored on real transactions that won’t drift as technology flows. Hold this main axis, and you can not only see where each company sits in the chain today, but also anticipate where capability sinks and value flows back—making decisions in a fast-moving field that lean less on luck and more on logic.
