This article details the 15 physical and logical steps that one AI token experiences as it passes through the data center as of 2026. It covers how the inference process, which is the core of AI products, works, and the cost and optimization techniques incurred in this process. In particular, as inferences account for the majority of AI computing, we are digging in-depth in how various technical efforts are made to reduce costs per token and minimize latency.

1. The importance of AI inference rises and token economy 📈

In 2026, all AI products we use are essentially token generator. All AI services such as chatbots, coding agents, search summary, image captions, etc., work in such a way that the trained model predicts the next token and predicts the next token, which is called inference. In 2026, this reasoning went beyond model training and became the key to AI computing. 📊

Google said in May 2026 that it had dealt with tokens** of **Month 3.2, which is a sevenfold increase from 480 trillion won a year ago, in 2024. This is a huge growth compared to the 9.7 trillion dogs in the first place. All of this is not training, but the cost of answering user questions. The inference still feels like a black box of 'Enter prompt -> output answer -> GPU works, but this article looks inside. It describes in detail how one prompt goes through the 15 physical and logical points within the data center, and through this process, "AI infrastructure" is not an abstract concept, but as a specific object that can calculate the latency, cost per token, and investment value. Shows change.

Behind this one journey is the largest capital redistribution in computing history. In 2026, the inference accounts for about two-thirds of the total AI computing, which is one-third of 2023 and half of 2025. The top 4 hyperscalers are expected to invest $725 billion in 2026, a 77% increase over the previous year, of which more than 60% of them are not chips, power, cooling, and buildings. It will be invested. The inference-only silicon market alone will reach $50 billion in 2026. The unit that connects all of this economy is token, and token prices drop by about 200 times per year, while usage is 7 times per year. The synergy between such a drop in price and an increase in usage is the key driving the token economy.

2. Core Principles and Economic Meaning of AI Inference ✨

The discussion of AI inference can be summed up into five key points.

1. Inference accounts for more than 2/3 of AI computing, and 80-90% of the model's lifetime cost. Now, not a model, but tokens are the unit of economic output. 2. Two steps, two bottlenecks:** Prefill is compute-intensive, and ** determines the time-to-first-token (Ttft). *decode is memory bandwidth intensive, and determines the speed and cost. Almost all optimizations aim for one of these two things. 3. Unit costs drop by about 200 times per year*, while Use will increase by about 7 times per year. It's not just deflation, it's more like Jeburns' paradox. In other words, "great scale" and "high margin" are different stories. 4. Continuous value lies at physical bottlenecks. Memory bandwidth, scale-up interconnect, optical components, and power. The reasoning software class is important, but it is a highly competitive field. 5. Inference purchases are weighted tradeoffs. Latency (TTFT + speed + P99), mixing cost, stability (including functional gaps), security, distribution, model coverage, portability, and more, you need to evaluate your workload**.

The reason why you should pay attention to these details is because of economic. Model training is a one-time capital expenditure that generates fixed assets, while inference is the cost of sales** that occurs in each query and increases in proportion to usage. The industry believes that inference is ultimately the 80-90% of the total computing cost of a distributed model. Therefore, the proportion of inference, which increased from one-third of computing in 2023 to two-thirds in 2026, is not a temporary fad, but in a stable state where most accelerators spend their time on **providing services**, not learning. It means you have reached it.

There are two factors that will be the main infrastructure market for this decade. First, advances in AI technology shifted from ** larger models to 'long-thinked' models**. In other words, the inference and agent system uses 10 to 100 times more token per query. DeepSeek-R1 created 10 times more tokens per answer while showing performance similar to OpenAI's O1. It is 5 to 25 times more expensive per work. Second, there is an unprecedented price drop in modern history. The cost of providing a fixed quality level has declined by about 200 times** per year since early 2024. Inexpensive tokens don't cut your spending, they enable new workloads faster than a price drop. This is **Jeburns' paradox**.

3. The Journey of Tokens Internal Data Center: 15 detailed analysis 🗺️

Let's take a closer look at the process through which one prompt passes through the data center in 15 steps. This process helps you find out how the cost and latency per token is determined.

3.1. Step 1: Tokenizer 🔡 Journey begins before you arrive at the data center. When the user presses the Enter key, the client sends the text over HTTPS, but the model does not see the text directly. Instead, look at integer (Integer). Tokenizer (byte-level byte-pair encoder) divides the string by Subword token, and each token is taken from a vocabulary of about 100,000 to 200,000 items. Mapping. For example, a 12,000 token request for a RFP (request for proposal) and a question becomes the 12,022 integer id sequence. Tokenization is deterministic, on the CPU side, and virtually free, but determines the charge fee. There is a fee for both input token and output token, and the model's context window (the latest model in 2026 is between 200,000 and 1 million tokens) means strict restrictions on the amount of RFP that can be entered.

3.2. Step 2: The API Gateway 🚪 The request (the HTTPS body still with ID) arrives at API Gateway, the front door of the data center. Here, we close TLS, parse and validate requests according to our schema, apply API versioning, apply approximate rate restrictions, attach a tracking ID, and fire the first weighing event. This gateway is intentionally simple and very fast. Without model logic, it handles millions of requests per second through Envoy or Nginx-class proxies (protected by web application firewalls) and only handles entry and records. The delay budget is less than 1 millisecond. This gateway's role is to block 5% of the quota that is abnormal, exceeded, or malicious, before using expensive resources.

3.3. Step 3: Authentication & Billing 💰 Before using the GPU, requests must be given attribute. The authentication process checks the API key or the OAuth token by organization, checks the ratio of the organization's ratio limits and expenditures, and determines the Charging method. This includes pricing per token, cached input discount (50-90% discount), priority processing, and low batch prices. It is also a security boundary for data isolation and prevention of misuse in organizational units. At this stage, the request is measured in anonymous bytes, priced, and transforms into isolated unit of work.

3.4. Step 4: Load Balancing ⚖️ Now the work has to be assigned to hardware. A typical load balancer uses health checks and real-time load signals to distribute requests across the same model replica. However, for large-scale language models (LLM) services, the simple round-robin method is inefficient. Two requests sharing the same long prefix (such as the same system prompt, pasted RFP) are sent to same replica, making it ideal for reuse of expensive prefix calculations in the cache. Therefore, the latest AI load balancing is evolving in the Cache Awareness method, which is also the reason why the next step in the inference router is overlapping. Load balancers also force backpressure. In other words, it is a component that determines whether a request is queued or a '429' error when the service is saturated.

3.5. Step 5: Inference Router & Compiler 🧠 The router is the point at which reasoning becomes interesting, and a significant total margin is determined. In a few milliseconds, you need to answer 3 questions. 1. Which model will you use? The choices depend on which of the latest 70B models, compressed 8B models, inference variants, or guessed draft + target models meets your service level goals. Processing queries with the 70B model can lead to marginal loss of margins. 2. **Which silicone to use? Compute-intensive prefiels want pure flops, and memory bandwidth-intensive decodes want high bandwidth (HBM) bandwidth, so "correct" GPUs can be different even within a single request. 3. **Cache Aware Routing sends a request to the instance that already has the KV cache of this prefix, and 12,000 token prefictions are almost free of charge Cash hit to convert.

This step is also home to the Compier/Auto Tuner Tier. These systems compile and tune the correct GPU kernel for the model, shape, and chip given in advance, and choose the cheapest execution plan at run time. This is not an academic problem, it is Business. Together AI, Fireworks, Baseten, and Modular are mostly built on this layer, and make products of "what kind of precision and which kernel to use" and generate revenue through their own inference infrastructure. This model and its valuation will be addressed again at the end of the journey.

3.6. Step 6: Scheduler & Continuous Batching 🔄 GPU If there is a single component that operates economics, it is Scheduler. The single decode step is lethal inefficient use of the GPU. When the batch size is 1, the H100 has a streaming multiprocessor utilization rate of only about 30~40% due to lack of memory. The scheduler's answer is Continuous (iteration-level) batching. Instead of a fixed placement, cross multiple sequences, allow new arrival requests from All forward pass, and remove completed requests to keep the GPU saturated with each pass. This core technology is at the heart of VLLM, and provides 3 to 5 times higher traffic than the simple PyTorch loop in the same H100 as 2 to 4 times higher throughput than the previous service system.

3.7. Step 7: KV Cache and PageDattention 🧠 Now the request has reached the GPU, and meets the most important data structure in reasoning. Inside all Attention layers, each token generates a key and value vector. To generate the n+1st token, the model must tilt the Attention to all previous tokens' K and V. So, recalculating it in each step, O(N²) costs are incurred, which is very inefficient in the context of 12,000 tokens. Instead, they are cached. This is the KV cache. The prefiction calculates and stores the K/V of 12,022 positions once, and each decode step that follows adds the K/V of one token and reads the rest. The KV cache is the biggest and most dynamic consumer of GPU memory among services, and managing it well is a key feature of the latest inference engines.

The difficult part is Fragmentation. Sequences increase to unpredictable length, and the classic continuous allocation method wastes 60-80% of memory. PageDattention of VLLM borrowed the operating system's virtual memory technique. It divides the KV cache into a fixed-sized block ("page"), allocates it when needed, and maps it through the page table. Therefore, the physical blocks do not need to be contiguous, and the completed sequence immediately releases the page. This is the mechanism by which VLLM provides 2 to 4 times higher throughput, allowing many users to securely share a single GPU.

3.8. Step 8: Prompt/Prefix Caching 💾 These sharings are not just memory optimization, but also to price. If many requests have the same prefix (system prompt, few few shot prompts, pasted RFPs), the KV cache of that prefix can be computed once and can be reused over multiple calls. Providers sell it directly under the name of Prompt/Prefix Caching. Anthropic charges 0.1 times the input token ($0.30 vs. $3.00 per 1 million token), and OpenAI's GPT-5.x line for the cached input. Price is set at $0.50 and $5.00. In both cases, 90% discount is applied, and at long prompts, Approximately 85% lower latency is provided. In our example, caching the RFP leads to a 12,022 token prefile that is almost free of charge for all subsequent questions.

3.9. Step 9: Quantization 📉 The on-package memory of the service GPU stores three at the same time. _ Model Weights: is fixed. **KV Cache (KV Cache): ** Increases with the number and length of concurrent sequences. _ Activations and Workspace: Temporary data.

Weights take up a minimum of space, and the rest are used in the KV budget. This KV budget (not compute) typically limits simultaneous throughput. The 70B model occupies about 140 GB on the FP16, and two 80 GB H100s are required to load. At about 70 GB in FP8, you can enter with space for KV cache in one GPU. This is the first point where quantization shines. All gigabytes saved in weights will be KV free space, and the KV free space means the number of users** who can serve at the same time.

3.10. Step 10: Prefill vs. Decode and NVFP4 ⚔️ This is an intuitive key to the whole system. Prefills and decodes use completely different resources. * Prefill handles all 12,022 input tokens in parallel. This is a huge matrix multiplication that saturates the tensor core. That is, Compute-bound, which determines the first token creation time (TTFT). *decode is the opposite. To generate each of the following tokens, the GPU must stream the model's full weighted tensors (and growing KV cache) once every token in high bandwidth memory (HBM). This reading time is fixed by memory bandwidth, not math. The arithmetic intensity of the decode at batch size 1 is about 1 flop*_ per byte, which is much higher for the Roofline's ridge point of 410 to 590 flop_. It doesn't work out. So the Tensor Core is almost completely idle, waiting for the memory.

So the industry is going down the precision ladder. FP16 → FP8 → FP4. If the number of bits per weight is small, the number of bytes to be read per token decreases, which can directly increase the upper limit of decodes tied to the memory bandwidth. NVIDIA's NVFP4 (a 4-bit floating point format built into the 5th generation tensor core of the Blackwell) raises the arithmetic throughput by about 2-3 times** and memory. Contributes to the speed of end-to-end inference speed of up to **5 times compared to the hopper by keeping the usage by about 1.8 times and keeping it within about 1% of the standard accuracy. With every fewer bits, bandwidth is secured and token costs become cheaper. This is the most powerful means of direct impact on the cost of products sold in buildings.

Prefills are compute-intensive and determine the first token creation time. Decodes are memory bandwidth intensive and determine speed and cost. Almost all of the techniques of inference are to attack this decode memory barrier. Examples include larger layouts, smaller quantizations, and predictions through predictions.

3.11. Step 11: Kernel Fusion Convergence 🧪 The execution plan is now mathematics, and the GPU's math is run as kernel. The kernel is a small program that runs on thousands of cores. The simplest way to run a transformer is to run hundreds of separate kernels, each kernel reads, calculates, and rewrites the result from HBM. In bandwidth-intensive workloads, these reciprocating tasks are fatal. So the whole technology is Kernel Fusion. Integrate multiple tasks into one kernel, keeping the intermediate data on the fast on-chip SRAM and accessing the slow HBM as little as possible. A typical example is FlashAttention. FLASHATENTITION uses online SoftMax to perform attenuation calculations in a tile manner, providing 2 to 4 times faster speed improvement by reducing the square of the sequence length from the square of the sequence length. The Flashattention-3 leverages Hopper's asynchronous engine and FP8 to reach 840 tflops from the H100, which is about 85% of the highest performance.

3.12. Step 12: Speculative Decoding 🔮 One kernel-level technology deserves separate attention. This is because it is an optimization that boasts the highest return on investment (ROI)** in a single stream service. It's speculative decoding. Because the decode is memory intensive (the GPU reads all weights at every step), you can check multiple candidate tokens at almost the same cost as creating a token. Small and inexpensive Draft model proposes the following K tokens, and the Massive Target Model checks all of them with a single parallel pass and accepts the longest correct prefix. This output is 2 to 4 times faster than normal decoding **Mathematically. Latest methods such as Eagle-3 have increased draft acceptance rates to 75% or higher.

3.13. Step 13: Scale-Up Networking (NVLink) 🔗 Our 70B model fits into a single GPU, but the latest model (a model with trillions of parameters, a mix-of-experts) model Several GPUs are ** sharded**. This means that the GPUs must communicate** with each layer, every layer. What people overlook is that networking exists directly inside the decode loop. The first fabric is Scale-up, or NVLink. It is a super fast interconnect that binds several GPUs inside the rack into one logical accelerator. NVLink 5 transmits 1.8TB/s** per GPU, which is about 14 times the PCIe Gen5 link. The GB200 NVL72 connects 72 Blackwell GPUs and 36 Grace CPUs into a single NVLink domain, providing a total of 130TB/s bandwidth and 13.4TB of integrated memory. This one rack acts like a single machine, and at the same time delivers up to 30 times more inference throughput on models with trillions of parameters than the H100 cluster, while consuming about 120kW of power.

Why do we need such extreme bandwidth? Because parallel processing itself causes traffic. Tensor Parallelism divides each layer's matrix multiplication to multiple GPUs, and after each multiplication, the partial result must be summed through the All-Reduce aggregation. This happens multiple times per token. Worse, the model **MOE(Mixture-Of-Experts) routes each token to several experts scattered across the GPU, which induces **all-to-all** communication, leading to often dominant inference bottlenecks. It will. DeepSeek's production stack uses 8 400Gbps NICs and a custom library (Deepep) per node to nest this communication with computation to keep the GPU from hanging.

3.14. Step 14: Ethernet & Optics 🌐 The fabric requires a switch. nvswitch acts as a crossbar within the scale-up domain. It has 144 NVLink ports and a non-blocking switching** of **14.4TB/s, allowing 72 GPUs to communicate at the top speed at the same time. Scaleout networks beyond the rack are their own switches: NVIDIA's Quantum-X800 (InfiniBand) and Spectrum-X800 (Ethernet) or Broadcom's Tomahawk 6 (102.4Tbps, 64 x 1.6T port)) The AI switch has two features that are different from cloud switches. Firstly, it's rail-optimized topology. The GPU is cabling so that the nth GPU of all servers is connected to the same "rail" switch, minimizing the number of hops for collectives. Second, In-Network Computing and Congestion Control. Switches can perform reductions within the fabric (Sharp), and must absorb the synchronized "Incast" that occurs when thousands of GPUs complete one step at the same time. Adaptive routing is essential because one congested link stops the whole aggregate (tail-latency problem).

Packets from GPU to other racks pass through Network Interface Card (NIC). In 2026, almost always Smartnic or DPU (Nvidia Bluefield and similar products) is used. The key feature is RDMA over Converged Ethernet (Roce) or InfiniBand Verbs. This allows remote GPUs to directly read the memory of this GPU, bypassing the CPU and now 400GB/s and 800GB/s is the standard. However, DPU is a fully programmable computer on the NIC. Offload congestion control, encryption, storage virtualization, multi-tenant isolation, and more from the host CPU. In rail optimization clusters, each GPU often owns a dedicated NIC. DeepSeek pairs 8 GPUs with 8 400Gb/s NICs so that the accelerator does not share on-ramps. This is the point where the "network" is physically initiated against bytes, and the boundary in which our data-gravity subject is literally applied.

Historically, the AI cluster has been run in infiniband, which provides about 1-2 µs of latency and lossless fabrics. Ethernet using Rocev2 had a delay of about 5-10 µs and was treated as level 2 for training. However, these hierarchies are reversed. Ultra Ethernet Consortium (UEC) released UEC 1.0 in June 2025. This is more than 560 pages of rebuilding Ethernet stacks for AI, reducing the latency and stability gaps. Dell'Oro expects Ethernet to overtake InfiniBand on AI backend networks by 2027. The 800G is already the default port speed, and Broadcom's Tomahawk 6 boasts 102.4Tbps. In particular, in the case of inference (cost-sensitive, multi-tenant, and enterprise), the economic and open ecosystem of Ethernet are decisive.

Below this fabric is the least discussed cost center Optics. Optical transceivers account for about 60**% of networking costs and 45% of networking power. Considering that networking accounts for about 15-18% of the total cluster cost, even optical components alone account for nearly 10% of the total cost. A single 800G pluggable transceiver can consume more than 500W on a switch, which is more than the Switch ASIC itself. The AI optical transceiver market is expected to grow from about $16.5 billion** in 2025 to about $26 billion in 2026**. The structural solution is Co-packaged Optics (CPO). This is to reduce the power consumption of the **1.6T link directly over the switch package, from about 30W to 9W**. NVIDIA claims 5x power efficiency and 10x resilience for the Photonics Switch, which will be released in the second half of 2026.

For all models that are too large for a single GPU, the network exists inside the decode loop. All layers, run on all tokens. The key is to manage the difference between about 20 to 40 times the bandwidth between the scale-up (NVLink) and the Scale-Out (Ethernet).

3.15. Step 15: DeTokenization and Billing Closing 🧾 Once the last token is created, the journey proceeds in reverse order. detokenization maps integer ids back to text, and answers the user token-by-token via NIC, switch, load balancer, and gateway. They appear as soon as the token is created, as it is usually done through server-sent events. This is the reason why the first token creation time (TTFT) dominates the speed perceived. Users start reading in about 0.3 seconds, even if the full answer takes a few seconds. The final step is to close the billing. Input tokens (which may have been cached), and output tokens (expensive tokens) are priced at the level assigned by authentication in level 3. One answer is completed through 15 steps.

4. The core of inference optimization: scheduling heterogeneous workloads 🧑‍💻 Looking back at 15 steps, all the difficult problems (batch, KV paging, prefill vs decode, hardware selection, aggregation communication) are all Ultimately, it leads to one problem. That is, scheduling heterogeneous workloads across memory and network hierarchies to keep expensive silicones saturated**. The answer for 2026 is disaggregated service. It is a method of splitting compute-intensive prefiles and memory-intensive decodes into **separate GPU pools, each independently scaled and tuned, and streaming the KV cache between them. It is currently becoming the standard for NVIDIA Dynamo, VLLM, SGLANG, LLM-D, Mooncake and more.

The most interesting companies in this field are in the 5th and 10th stages (compiler, kernel, auto tuner tier). They all found the same fact. In other words, the way to make a profit with a better kernel is not to license it, but to run it directly**. They own the inference infrastructure, sell tokens, and take the difference in efficiency to the gross margin. This logic is perfect. Each time you achieve 2 times more efficiency in kernel, placement, quantization, or guess decoding, you can process 2 times more tokens per GPU, and if you run your own GPU, it leads to a much greater margin than announcing a benchmark. The automatic tuner compiling the cheapest kernel for all models × shapes × chips is virtually like a money-making machine** attached to a **fleet.

These performance indicators are at the heart of this argument. Baseten's annual sales increased from about $200 million in December 2025 to about $600 million** in March 2026, which is about 1,900**% of growth per year. The company was valued from $5 billion to $11 billion to $13 billion** five months ago, attracting $1.5 billion in investment. And it is the clearest sign that Modular was acquired by Qualcomm for about $3.9 billion. This means that chip manufacturers have acquired a hardware-independent compiler company to attack the weakest part of NVIDIA.

5. Take a closer look at your considerations when purchasing inference services The most common mistake is to optimize for headline prices** per million tokens. There are no "best providers" abstractly, only **the only one that best suits the workload form** exists. Real-time voice agents, night placement summary, multi-level autonomous agents, and enterprise apps that comply with HIPAA regulations evaluate the same criteria completely differently. The following frameworks are a tested basis in production environments.

• The latency consists of two numbers. **First token creation time (time-to-first-token, ttft) determines how quickly starts the answer is. * Inter-token latency or the output speed determines how quickly completed the answer will be. Some providers can do one well and the other can't do the other, and what's important to the user experience is p99 tail, not a median. The P50 is great, but if the P99 is not good, a noticeable pause occurs. A typical GPU inference produces the first token within about 400 to 600 ms, but the fast silicone cloud, such as GroQ and Cerebras, compresses TTFT to less than 100 to 150 ms, and in the LLAMA-70B class model. Provides output speed of 1,600~2,100+ token per second. This is about 4 to 6 times faster than a typical GPU stack.

*Cost is a mixed price, not a given price. * The normal price consists of two numbers per million token input and output, and the output cost is 4 to 5 times the input cost, which is generally more dominant. The actual unit cost depends on input:output ratio, cache hit rate (prompt caching saves inputs 50-90% and can use the placement layer for work (often 50% cheaper). Mid 2026 public rates are only about $0.04 to $0.20** per million tokens in an optimized open model endpoint (DeepInfra; Groq's $0.15/$0.60) On the other hand, for high-tech models, they reach several dollars per million tokens. So, even two providers with the same headline price can have 3 times the difference in real traffic**.

*Reliability is more than the uptime ratio. * The official SLA (Azure OpenAI presents 99.9% for token creation, companies are 200ms for 99.99% of calls). Requires delay time sla, such as less than TTFT, is essential, but not enough. In fact, the fault mode that breaks down the product is outside the SLA. It's just a rejection of rejection, a quiet model version that degrades rating indicators, and a quota-based limit on load., etc. Even if vendors comply with 99.95% uptime, these problems can lead to degradation of applications. So, the mature answer is to fix the model version, negotiate the capacity, and directly monitor the functional availability.

In addition to latency, cost, and reliability, 7 criteria determine the suitability of the production environment. *Throughput & Rate Limits: Tokens per minute and burst free space limits agent expansion and size. *Security & Compliance: SoC 2 Type II, HIPAA, ISO 27001, GDPR is essential in the regulation industry and is difficult to apply late. *Data Residence & Private Deployment: Zero retention guarantee, VPC/BYOC, and on-premises distribution are essential conditions for corporate procurement. Most consumer-grade endpoints are quietly disqualified as their conservation policies are ambiguous and do not provide private channels. *Determine and Version Control: Fixed seed, fixed checkpoint prevents the evaluation suite from drifting quietly. * Model Coverage & Freshness: Model diversity, early support for new open weights, fine tuning/LoRa hosting determines how quickly you can introduce the latest technology. * Deployment Flexibility: Serverless vs Dedicated VS Self Hosting determines the cost/control tradeoff. Portability: OpenAI compatible APIs and neat multi-supplier routing are insurance when all of the above problems arise.

Choose a workload type first, then shop. Input: The price of the headline per million token is almost meaningless without the latency SLA that includes the input: output ratio, cache hit rate, and P99 tail.

Reliability traps that most teams learn hard 99.95% uptime of suppliers does not cover the failures that cause real problems. For example, a quiet model change that crashes ratings, a surge in rejection rates after a safety update, or quota limits when traffic is at its peak. You should use SLA as the lowest standard, fix the model version, and monitor the Functional Availability yourself.

6. Conclusion: The Future Prospects of the AI Infrastructure Market 🔮 Three conclusions can be drawn. First, physical bottlenecks are complex. The HBM bandwidth sets the upper limit of decode, and the NVLink scale-up domain is truly exclusive, optical and power-free resources. More than 60% of the $725 billion capital expenditure is already being used for electricity and buildings, which means that token** per wattage is the ultimate indicator. Second, network is being divided. Scale-ups remain closed and defensive, while Scaleout is open (Ethernet/UEC) and is being commercialized. Thus, the competitive advantage lies in the scale-up domain, optical/CPO, and congested IP, and there is no switching in the product. Third, **Inference software layer is real, but competition is fierce**. Margins are equal to Efficiency Difference × Utilization × Scale, and only sustainable when the player switches speed to distribution and conversion costs before pure performance becomes the underlying condition.

By 2027, you should invest in Bottleneck. In other words, for memory and bandwidth, scale-up interconnect, optical and power. And invest in a reasoning platform** that has already created the lock effect through **efficiency. All arguments that only advocate pure speed should be skeptical. Because pure speed is the very part of the compiler layer and the free tools of NVIDIA. The token economy is going to be huge. The increase in Google tokens from 9.7 trillion per month to 3.2 in two years is an irreversible trend. However, 'great scale' and 'high margin' are two different stories, and the 15-step journey determines the difference.

Conclusion: Invest in a platform that created lock effects through physical bottlenecks (memory bandwidth, scale-up interconnect, optical, power) and efficiency. Be suspicious of the argument that only advocates for being faster. It's part of the compiler layer and the free tools of NVIDIA.

Following one token makes the whole economy clear.