Inception Pitches Diffusion LLMs to Cut Enterprise Inference Costs

Token Efficiency Frontier and Diffusion LLMs With Inception — Ai4

Ai4

Parallel diffusion generation breaks sequential decoding bottlenecks to deliver reasoning capabilities at the speed and cost of standard non-reasoning models.

AI-assisted summary of Token Efficiency Frontier and Diffusion LLMs With Inception — original source. Check the original for full context.

Source published: 2026-08-17

Detailed notes

## Background Published on YouTube by Ai4 on August 17, 2026, this presentation features Aditya Grover, CTO and Co-Founder of Inception, discussing the token efficiency frontier in enterprise AI. The video description highlights how diffusion-based language models like Mercury and Mercury 2 generate tokens in parallel to deliver 5x speedups and cost reductions across search, coding, and voice workflows without sacrificing quality.

## TL;DR Aditya Grover presents diffusion-based language modeling as the third critical pillar of parallel AI, solving the latency and cost bottlenecks of sequential autoregressive inference. Inception's Mercury model family initiates responses with full-sequence approximations and refines tokens in parallel, matching the quality of top speed-optimized models like Gemini Flash and Claude Haiku while dramatically exceeding their throughput. Production deployments at OpenCall, Exa, and Augment Code illustrate how parallel token generation unlocks fast reasoning within non-reasoning latency budgets and drastically lowers multi-agent operational costs. Ultimately, Grover frames the industry's architectural transition as a shift away from brute-force 'token maxing' toward optimizing 'intelligence per watt.'

## Atmosphere & style The presentation carries a crisp, visionary keynote style that bridges foundational compute history with hard enterprise metrics. Grover speaks with authoritative clarity and disciplined academic conviction, making a bold architectural departure from standard autoregressive decoding feel logical and inevitable. The session feels like an exclusive technical briefing, blending pragmatic engineering economics with genuine excitement for a paradigm shift in generative inference.

## Key takeaways - [00:04](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=4s) The evolution of modern AI relies on three core pillars of parallelism: parallel hardware (Nvidia GPUs), parallel training (Transformers), and parallel inference (Diffusion models). - [00:04](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=4s) While hardware and training have successfully transitioned to parallel architectures, LLM inference has historically lagged behind by remaining bound to sequential, left-to-right generation. - [03:25](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=205s) Diffusion LLMs break the sequential bottleneck by generating all tokens simultaneously via an initial estimate and refining the sequence across parallel passes. - [03:25](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=205s) Inception developed Mercury as the first commercial-scale diffusion LLM, catalyzing competing diffusion research across major labs including Google, Nvidia, and Alibaba. - [03:25](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=205s) Mercury 2 was launched as the world's fastest reasoning LLM, generating tokens in parallel up to 5x faster than speed-optimized autoregressive models at a fraction of the cost. - [06:40](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=400s) Artificial Analysis benchmarks verify that Mercury matches the quality of models like Gemini Flash, GPT Mini, and Claude Haiku while achieving significantly higher token throughput. - [06:40](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=400s) Mercury 1 achieved an initial baseline of ~700 tokens per second, which Mercury 2 improved upon alongside increased reasoning capacity. - [06:40](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=400s) To ease enterprise integration, Inception provides drop-in OpenAI-compatible APIs across AWS, Microsoft Azure, Baseten, and direct first-party infrastructure. - [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) In latency-sensitive voice applications like OpenCall, Mercury allows developers to fit complex chain-of-thought reasoning into the latency budget of standard non-reasoning models. - [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) On retrieval benchmarks by Exa, Mercury established dominant accuracy-to-speed and accuracy-to-cost metrics for high-throughput search workflows. - [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) Agentic coding platforms like Augment Code use Mercury to handle high-frequency sub-agent tasks—such as routing, summarization, and context compression—sparing costly frontier models. - [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) The economic paradigm of enterprise AI is shifting from brute-force token consumption ('token maxing') toward maximizing cost-effectiveness and 'intelligence per watt' ('value maxing').

## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=4s) The Three Pillars of Parallel AI and the Shift to Inference

Aditya Grover, CTO and co-founder of Inception, opens by laying out the company's core mission: redefining token efficiency for large language models by inventing a new class of LLMs grounded in diffusion. To contextualize why diffusion represents the next major paradigm shift, Grover takes a step back into the foundational history of modern artificial intelligence. The AI boom rests on three core breakthroughs: the invention of parallel hardware in the late 1990s when Nvidia introduced GPUs for high-efficiency matrix multiplication, the advent of the Transformer architecture from Google's seminal "Attention Is All You Need" paper two decades later which enabled massive parallel training, and now the critical transition into the "inference era."

While hardware and training architectures have successfully embraced parallelism, inference has historically lagged behind. However, parallel generative modeling has already achieved dominant success in other modalities. For image and video generation, the state-of-the-art approach is diffusion—a technology co-invented by one of Inception's co-founders at Stanford University. Rather than generating sequentially, diffusion begins with pure noise and iteratively uncovers visual structure to match a prompt. Inception's core conviction is that parallelism will inevitably conquer text generation just as it conquered training and computer vision.

``` +------------------------------------------------------------------+ | THE THREE PILLARS OF AI | +------------------------------------------------------------------+ | 1. Parallel Hardware: Nvidia GPUs (late 1990s) | | 2. Parallel Training: Transformer Architecture (Google, 2017) | | 3. Parallel Inference: Diffusion Models (Stanford, 2019 -> Now) | +------------------------------------------------------------------+ ```

- In the late 1990s, Nvidia developed GPUs initially for graphics, which later became the backbone of scalable AI matrix operations. - The 2017 Transformer breakthrough created a perfect architectural match for GPU hardware by enabling parallelized neural network training across images and text. - Diffusion generative modeling, mainstreamed for images and video since 2019, forms the theoretical foundation Inception is applying to text generation.

---

[03:25](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=205s) Diffusion LLMs: Generating Tokens in Parallel with Mercury

Traditional autoregressive frontier models, dating back to the earliest public demonstrations of ChatGPT, generate text strictly one token at a time in a sequential, left-to-right fashion. In contrast, Inception's proprietary model family, Mercury, discards sequential decoding entirely. A diffusion language model initiates the generation process with a rough initial guess across the entire response simultaneously, subsequently refining and polishing the full sequence of tokens in parallel across multiple passes.

``` AUTOREGRESSIVE (SEQUENTIAL): Step 1: [Token 1] --------> Step 2: [Token 1] [Token 2] --------> Step 3: [Token 1] [Token 2] [Token 3] --------> (Slow / Left-to-Right)

DIFFUSION (PARALLEL REFINEMENT): Pass 1: [ Rough Guess 1 ] [ Rough Guess 2 ] [ Rough Guess 3 ] | | | Pass 2: [ Refined T1 ] [ Refined T2 ] [ Refined T3 ] | | | Pass 3: [ Final Token 1 ] [ Final Token 2 ] [ Final Token 3 ] (Ultra-Fast) ```

Because parallel token generation dramatically collapses generation latency compared to linear left-to-right decoding, Mercury delivers ultrafast responses that fundamentally alter downstream token economics. Grover notes that after extensive foundational research in academic labs, the founding team came out of stealth with Mercury, the world's first commercial-scale diffusion LLM. The release captured immediate widespread attention across the AI ecosystem, garnering praise and intrigue from figures such as Andrej Karpathy, Andrew Ng, and Elon Musk. Following Inception's debut, major industry labs—including Nvidia, Alibaba, and Google—initiated their own active diffusion LLM research efforts. Building on this momentum, Inception introduced Mercury 2 as the world's fastest reasoning LLM.

- Autoregressive generation processes text strictly sequentially left-to-right, creating inherent latency bottlenecks. - Diffusion LLMs generate tokens in parallel by initializing an approximate output and iteratively refining it to completion. - Following Mercury's release, major industry players including Google, Nvidia, and Alibaba established competing diffusion LLM research programs.

---

[06:40](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=400s) Benchmarking Speed and Quality on the Frontier

Evaluating Mercury against the broader model landscape, Grover highlights independent evaluation benchmarks produced by Artificial Analysis. When plotting throughput on the horizontal axis against overall output quality on the vertical axis, Mercury matches the quality benchmarks of leading speed-optimized models from top frontier labs—such as Google's Gemini Flash, OpenAI's GPT Mini models, and Anthropic's Claude Haiku—while vastly outperforming them in raw token throughput.

The trajectory between iterations highlights rapid progress. Mercury 1 established the baseline by delivering approximately 700 tokens per second at an entry-level quality profile. Mercury 2 pushed the frontier further along both dimensions, unlocking higher reasoning capabilities and expanded throughput. To ensure friction-free enterprise adoption, Inception serves its models through fully OpenAI-compatible API interfaces across several major cloud platforms, including Amazon Web Services (AWS), Microsoft Azure, Baseten, and Inception's own first-party managed platform.

- Independent benchmark analysis from Artificial Analysis confirms Mercury achieves quality parity with frontier speed-optimized models (Gemini Flash, GPT Mini, Claude Haiku) at multiples of their throughput. - Mercury 1 delivered approximately 700 tokens per second, with Mercury 2 significantly improving both generation quality and generation speed. - Inception provides drop-in OpenAI-compatible endpoints hosted on AWS, Microsoft Azure, Baseten, and direct first-party infrastructure.

---

[08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) Enterprise Case Studies: Voice, Search, and Coding Agents

Grover details how Mercury's extreme speed and low cost unlock real-world production architectures across three demanding domains: real-time voice, search, and agentic coding. In voice and customer support, where time-to-first-token is make-or-break, conversational AI company OpenCall previously relied on Cerebras hardware before switching to Mercury. Because Mercury operates at such extreme throughput, OpenCall can deploy reasoning modes—even medium and high reasoning configurations—faster than traditional non-reasoning models can generate responses. As Grover explains, "you can actually pack reasoning into the budget of a non-reasoning model, something which was not possible before."

``` +------------------------------------------------------------------+ | AGENTIC CODING HARNESS (AUGMENT CODE) | +------------------------------------------------------------------+ | | | User Prompt / IDE Context | | | | | v | | +-----------------------+ | | | Primary Frontier Model| (Expensive, high-tier reasoning) | | +-----------------------+ | | | | | | (Delegates background tasks) | | v | | +-----------------------+ | | | Mercury Sub-Agents | (Routing, summarization, search, | | +-----------------------+ code compression at ultra-low cost) | | | +------------------------------------------------------------------+ ```

Similar economic advantages appear in search and retrieval workflows, where high query volumes demand strict cost controls. On benchmarks published by search provider Exa, Mercury established dominant accuracy-to-speed and accuracy-to-cost profiles. In the software engineering space, developer platform Augment Code integrates Mercury into its agentic coding harness. Rather than relying solely on a costly primary frontier model for every minor execution, Augment Code orchestrates multi-agent workflows that delegate routine sub-agent tasks—such as search, routing, and context compression—directly to Mercury. Grover concludes that as raw intelligence becomes increasingly commoditized, the defining industry metric transitions from brute-force "token maxing" to "value maxing" and maximizing "intelligence per watt."

- **Voice & Support (OpenCall):** Replaced previous Cerebras deployments with Mercury, executing chain-of-thought reasoning within latency thresholds previously restricted to non-reasoning models. - **Search & Retrieval (Exa Benchmark):** Delivered superior cost and latency profiles across high-volume search querying. - **Agentic Coding (Augment Code):** Employs Mercury to offload background sub-agent tasks from expensive primary frontier models, slashing overall operating expenses and latency. - The broader AI industry is shifting from pure token consumption ("token maxing") toward economic efficiency ("value maxing" and optimizing intelligence per watt).

## Notable quotes > running a frontier model for all of them means paying frontier prices for work that doesn't need frontier intelligence. — Aditya Grover

> Mercury, the world's first generation of frontier LLMs built using diffusion. — Aditya Grover

> generates tokens in parallel to run 5x faster than comparable speed-optimized models from the top frontier labs at a fraction of the cost, at comparable quality. — Aditya Grover

> [00:04](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=4s) inference era — Aditya Grover

> [03:25](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=205s) world's fastest reasoning LLM — Aditya Grover

> [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) you can actually pack reasoning into the budget of a non-reasoning model, something which was not possible before. — Aditya Grover

> [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) token maxing — Aditya Grover

> [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) value maxing — Aditya Grover

> [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) intelligence per watt — Aditya Grover

## Mentioned Aditya Grover, Inception, Mercury, Mercury 1, Mercury 2, Nvidia, Google, Stanford University, Attention Is All You Need, ChatGPT, OpenAI, GPT Mini, Claude Haiku, Gemini Flash, Anthropic, Alibaba, Andrej Karpathy, Andrew Ng, Elon Musk, Artificial Analysis, Amazon Web Services (AWS), Microsoft Azure, Baseten, OpenCall, Cerebras, Exa, Augment Code

## Video description Aditya Grover - CTO and Co-Founder, Inception

As frontier models permeate organizations, the economics of these models beg the question: should enterprises pay for the smartest model for every workflow? In practice, AI-native enterprises make thousands of invisible calls to frontier models per session, the ones that route, compress, search, and summarize, and running a frontier model for all of them means paying frontier prices for work that doesn't need frontier intelligence. In this talk, I will show how diffusion LLMs change the token economics. At Inception, we have released Mercury, the world's first generation of frontier LLMs built using diffusion. Our latest model, Mercury 2, generates tokens in parallel to run 5x faster than comparable speed-optimized models from the top frontier labs at a fraction of the cost, at comparable quality. Available on all major platforms, Mercury 2 powers workflows at top enterprises spanning coding, search, and voice, delivering ultra-fast user experiences at a fraction of the cost of competing language models.

[Source](https://www.youtube.com/watch?v=9KJ2qcI9CRo)

中文简报

Inception力推扩散LLM以降低企业推理成本并行扩散生成打破了序列解码瓶颈，能以常规非推理模型般的速度与成本提供推理能力。 Aditya Grover指出，基于扩散的语言建模是并行AI的第三大关键支柱，化解了序列自回归推理的延迟与成本瓶颈。Inception的Mercury系列模型先以全序列近似生成初始响应，随后并行优化各Token，在输出质量媲美Gemini Flash和Claude Haiku等顶尖速度优化模型的同时，吞吐量大幅领先。OpenCall、Exa和Augment Code的生产部署实践表明，并行Token生成不仅能在非推理模型的延迟预算内实现快速推理，还能大幅降低多智能体的运行成本。Grover最后将业界的这一架构转型概括为从蛮力式的“最大化Token数量”转向优化“每瓦智能”。现代 AI 的演进建立在并行硬件（GPU）与并行训练（Transformer）之上，而 Inception 提出通过扩散模型（Diffusion）实现并行推理，以打破传统大模型受制于从左至右逐字生成的顺序瓶颈。 (0:04) Inception 推出商用级扩散语言模型 Mercury 系列，通过初始预估并在全序列上并行迭代修正 token，使推理速度最高提升至前沿加速模型的 5 倍，并带动 Google、Nvidia 与阿里巴巴等巨头开展扩散大模型研究。 (3:25) Artificial Analysis 基准评测表明，Mercury 2 在输出质量上媲美 Gemini Flash、GPT Mini 和 Claude Haiku，同时保持着极高的吞吐优势；该系列支持 OpenAI 兼容 API 并已接入 AWS、Azure 等主流云平台。 (6:40) Mercury 已在实时语音（OpenCall）、搜索（Exa）以及智能体编程（Augment Code）中落地，帮助企业以非推理模型的延迟与成本预算运行链式思考，加速推动行业迈向“每瓦智能”的经济效益最大化。 (8:53)

Reading summary

Inception CTO Aditya Grover argues that generative text is shifting from sequential autoregressive decoding to parallel diffusion inference, dramatically lowering latency and operating costs. Under this paradigm, language models refine entire token sequences at once, enabling enterprises to focus on intelligence per watt rather than brute-force token generation. Parallel Inference Replaces Sequential Decoding (0:04) Modern AI infrastructure developed across two historical pillars of parallelism: Nvidia's late-1990s GPUs for matrix multiplication and Google's 2017 Transformer architecture for parallelized neural network training. Grover positions parallel inference as the third pillar. While diffusion generative models established dominance in image and video generation beginning around 2019, text generation has remained tied to sequential autoregressive decoding, where tokens are produced strictly one at a time from left to right. To resolve this bottleneck, Inception introduced Mercury, a model family utilizing diffusion for parallel text generation. Rather than predicting subsequent tokens sequentially, Mercury generates an initial approximate guess across the entire sequence simultaneously and refines it across multiple passes. Following Mercury's commercial release and the subsequent launch of Mercury 2 as a fast reasoning model, major technology companies—including Google, Nvidia, and Alibaba—initiated their own diffusion LLM research programs. Throughput Benchmarks and Enterprise Deployment (6:40) Independent benchmarks published by Artificial Analysis place Mercury at quality parity with frontier speed-optimized models—such as Google's Gemini Flash, OpenAI's GPT Mini, and Anthropic's Claude Haiku—while delivering significantly higher token throughput. The baseline Mercury 1 achieved roughly 700 tokens per second, with Mercury 2 advancing both reasoning capabilities and generation speeds. To facilitate integration into existing production pipelines, Inception distributes its models through drop-in OpenAI-compatible API interfaces. These endpoints are accessible across major cloud ecosystems, including Amazon Web Services (AWS), Microsoft Azure, Baseten, and Inception's direct first-party platform. Workflows in Voice, Search, and Multi-Agent Coding (8:53) Mercury's throughput alters production architectures across real-time voice, search, and coding assistants. In conversational support, where response latency is critical, OpenCall replaced Cerebras hardware deployments with Mercury. Grover notes this allows OpenCall to run chain-of-thought reasoning models within the latency budget previously required for non-reasoning models. Similarly, search evaluations published by Exa showed favorable speed-to-cost and accuracy metrics across high-volume querying. In agentic software engineering, developer platform Augment Code uses Mercury within a tiered multi-agent harness. Instead of routing all tasks to expensive primary frontier models, the system delegates high-volume background sub-agent operations—such as codebase search, request routing, and context compression—directly to Mercury. Grover concludes that as raw intelligence commoditizes, industry success will depend on moving from raw token consumption to value maximization and optimizing intelligence per watt. Inception frames diffusion LLMs as the natural evolution of parallel inference, proving high token throughput on speed-optimized benchmarks. The durability of this architectural transition will depend on whether diffusion models can sustain quality parity as primary frontier labs build out competing parallel research programs.

精炼阅读摘要

Inception联合创始人兼首席技术官Aditya Grover指出，人工智能正由训练驱动走向推理驱动时代，其团队推出的Mercury系列扩散语言模型通过全序列并行精炼取代传统的自回归逐字生成，旨在打破大语言模型的延迟瓶颈并重构推理经济学。并行化演进与推理架构的范式转移 (0:04) Grover将现代人工智能的突破归结为三大支柱的历史演进。首先是20世纪90年代末Nvidia推出用于矩阵高效计算的GPU，奠定了并行硬件的基础；随后是Google在2017年提出Transformer架构，使多模态与文本的大规模神经网络训练能够充分利用硬件实现高度并行。然而，尽管硬件算力与模型训练均已全面实现并行化，推理架构在发展上却长期相对滞后。在计算机视觉领域，并行生成建模已成为事实上的行业标准。由Inception联合创始人在斯坦福大学参与发明的扩散模型技术自2019年起主导了图像与视频生成，其工作机制是从纯随机噪声出发，通过多轮迭代并行提炼出匹配提示词的视觉结构。Inception的核心判断是，文本生成领域也将重演这一技术轨迹，由全序列并行取代传统的线性生成模式。扩散语言模型的全序列并行精炼机制 (3:25) 以ChatGPT为代表的传统前沿大模型均采用自回归机制，严格按照从左至右的顺序逐个生成Token，这一串行计算方式在物理上造成了固有的生成延迟瓶颈。相比之下，Inception自研的Mercury模型家族彻底打破了顺序解码限制，在生成之初即对整个回复序列给出一个全局粗略预测，随后在全序列范围通过多次遍历对所有Token进行多轮并行打磨与修正。这种全并行生成技术大幅压缩了文本生成的端到端延迟。在Mercury作为商用级扩散语言模型发布后，迅速引发了包括Andrej Karpathy、Andrew Ng和Elon Musk等业内专家的关注。此后，Google、Nvidia以及阿里巴巴等行业研究机构也相继跟进设立了扩散大语言模型的研究项目。在此基础上，Inception进一步推出了主打高速推理能力的Mercury 2模型。速度与质量评测及主流云端部署 (6:40) 根据第三方评测机构Artificial Analysis发布的独立基准数据，在吞吐量与输出质量的双维度对比中，Mercury在综合质量上达到了前沿厂商同类轻量化提速模型的水平（包括Google的Gemini Flash、OpenAI的GPT Mini系列以及Anthropic的Claude Haiku），而在原始Token吞吐速度上显著超越了上述竞争产品。系列模型的迭代数据显示，初代Mercury 1建立了约每秒700个Token的基线吞吐量；新一代Mercury 2则在保持高吞吐的同时，进一步提升了复杂推理能力与文本质量。在部署集成方面，Inception通过与OpenAI兼容的API接口提供服务，支持企业直接通过Amazon Web Services (AWS)、Microsoft Azure、Baseten以及Inception官方托管平台进行快速集成。语音、搜索与智能体编码的降本实践 (8:53) Mercury的超高吞吐与低延迟已在对时间极为敏感的企业级场景中落地。在实时语音与客服交互领域，针对首字生成时间的严苛要求，对话式AI公司OpenCall此前使用Cerebras硬件，后迁移至Mercury；该架构允许系统在非推理模型的时间和延迟预算内，运行原本高耗时的中高阶思维链推理。Grover指出，这种特性使得企业能够在传统预算框架下直接嵌入深度推理能力。在搜索与检索场景中，搜索技术提供商Exa的评测表明Mercury在高频查询场景下展现了优异的准确率、生成速度与成本效益比。在软件开发领域，代码智能体平台Augment Code将Mercury引入其多智能体架构中，昂贵的前沿基模型仅负责核心宏观决策，而代码搜索、路由选择与上下文压缩等常规后台子任务则交由Mercury快速处理，从而大幅降低了系统整体的运行成本与端到端响应延迟。 Grover总结认为，随着前沿模型的原始通用智力逐渐走向商品化，人工智能行业的评估重心正在从单纯追求Token吞吐消耗的“Token最大化”，转向注重投资回报与运行效能的“价值最大化”及“每瓦智能”。不过，在各大科技巨头同步加速研发扩散文本模型的背景下，该架构能否在长文本一致性与更广泛的复杂逻辑任务中持续保持经济优势仍有待观察。

Detailed notes — zh

## Background 该视频由 Ai4 于 2026 年 8 月 17 日在 YouTube 平台发布。视频记录了 Inception 联合创始人兼 CTO Aditya Grover 的主题演讲，探讨了企业在路由、搜索和摘要等海量隐式调用中使用昂贵前沿模型的经济痛点，并介绍了基于扩散机制构建的并行语言模型 Mercury 与 Mercury 2 如何重塑 Token 效率与经济学。 ## TL;DR 演讲梳理了 AI 硬件、训练到推理的并行化演进脉络，指出传统自回归模型逐字串行生成的机制已成为推理时代的核心瓶颈。Inception 将视觉领域的扩散并行范式引入文本生成，推出了全球首创的商用扩散大模型 Mercury 系列，通过多轮并行去噪精炼大幅压缩生成延迟。实测数据与 OpenCall 实时语音、Exa 搜索及 Augment Code 代码系统等落地案例表明，Mercury 2 能在极低延迟预算内运行深度推理并显著降低运行成本。随着 AI 进入智能充裕时代，以扩散 LLM 为代表的高吞吐方案正将竞争焦点推向单位瓦特与单位成本下的智能输出效率。 ## Atmosphere & style 演讲整体呈现出严谨笃定、数据驱动且极具前瞻性的硬核科技气质。演讲者以清晰的学术底蕴结合真实工业界落地案例，通过层层剖析并行机制与基准评测帕累托前沿，展现出对自回归瓶颈的深刻洞察。整场分享节奏流畅洗练，传递出下一代扩散架构颠覆现有大模型推理范式的技术自信与变革活力。 ## Key takeaways - [00:04](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=4s) AI 发展经历了 GPU 硬件并行、Transformer 训练并行以及视觉生成扩散并行三波浪潮，当前正全面进入文本推理并行化的新阶段。 - [03:25](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=205s) 传统自回归大语言模型受制于从左到右逐字串行解码的瓶颈，而扩散架构（Diffusion LLM）将并行生成理念引入文本领域，实现与底层硬件计算的高度契合。 - [03:25](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=205s) 扩散模型 Mercury 通过初始全局粗略预测并在多轮迭代中并行去噪精炼生成完整文本，摆脱了逐 Token 生成的时间依赖，大幅降低交互延迟与计算成本。 - [04:59](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=299s) Inception 推出首个商业级扩散语言模型 Mercury 后，Nvidia、阿里巴巴与 Google 等行业巨头均相继设立扩散 LLM 研究项目。 - [04:59](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=299s) 新一代 Mercury 2 兼具极高吞吐性能与深度推理逻辑能力，成为全球生成速度最快的推理大模型（Reasoning LLM）。 - [06:40](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=400s) Artificial Analysis 权威评测表明，Mercury 在质量相当的前提下，吞吐速度数倍超越主流前沿实验室的速度优化型小模型（如 GPT-4o mini、Claude Haiku 等）。 - [06:40](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=400s) Mercury 完全兼容 OpenAI API 规范，并已上架 AWS、Azure、Baseten 等主流云平台，支持开发者无缝平替与快速接入。 - [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) 在实时语音客服场景中（如 OpenCall），Mercury 极高的生成速度让企业能在原本仅够运行非推理模型的苛刻延迟预算内，直接落地深度推理能力。 - [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) 在规模化搜索检索场景中（如 Exa），Mercury 在“准确率 vs 速度”与“准确率 vs 成本”维度均处于帕累托前沿，显著降低高频并发的 Token 成本。 - [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) 在 AI 编程智能体编排中（如 Augment Code），将路由、切片与验证等海量子任务派发给 Mercury，可大幅压缩端到端流水线延迟并节约推理开销。 - [12:02](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=722s) 随着 AI 进入智能充裕时代，行业核心竞争维度已转向单位能耗与成本下的智能产出效率（Intelligence per watt/cost），决定了未来业务落地的经济可行性。 ## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=4s) AI 并行化演进与扩散大语言模型的诞生背景在探讨现代 AI 的发展脉络时，推动行业爆发的核心要素主要由三波浪潮构成。首先是 1990 年代末英伟达（Nvidia）推出的 GPU 硬件，这种最初为图形渲染设计的芯片凭借极致的矩阵乘法并行计算能力，在数十年后成为支撑超大规模 AI 计算的基础设施。随后在 2017 年，Google 发布了划时代的论文《Attention Is All You Need》，引入了 Transformer 架构，实现了神经网络训练阶段的高度并行化，硬件算力与模型架构实现了完美契合。然而，当前的 AI 行业正全面迈入“推理时代”（Inference Era）。企业与各类组织的核心诉求已经从模型训练转向实际落地推理，但主流自回归文本模型在推理端依然受制于逐字串行的瓶颈。与之形成鲜明对比的是，在图像与视频等生成式 AI 领域，主流范式正是高度并行的扩散模型（Diffusion）。这一技术路线早在 2019 年由 Inception 的联合创始人于斯坦福大学实验室共同开创，如今已成为视觉生成领域的事实标准。Inception 的核心愿景正是将相同的扩散并行化理念引入文本生成，构建与底层并行硬件及训练体系相匹配的并行推理方案。 ```mermaid flowchart LR accTitle: AI Parallelism Evolution subgraph S1["硬件并行 (1990s)"] A["Nvidia GPU 高效矩阵乘法"] end subgraph S2["训练并行 (2017)"] B["Transformer 架构 Attention is All You Need"] end subgraph S3["视觉推理并行 (2019)"] C["扩散模型 Diffusion 图像/视频并行生成"] end subgraph S4["文本推理并行 (当前)"] D["扩散 LLM: Mercury Inception 文本并行解码"] end A --> B --> C --> D ``` --- ### [03:25](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=205s) 扩散 LLM 的工作原理与自回归模型的机制对比自回归大语言模型（如早期 ChatGPT 及当前的多数前沿模型）采用从左到右逐个生成 Token 的串行解码方式（Sequential Autoregressive Generation）。与之不同，基于扩散架构的语言模型 Mercury 采用完全并行的 Token 生成机制。模型在生成初始阶段会对最终输出给出一个粗略的全局猜测，随后在多次迭代中持续去噪与精炼，最终输出完整文本。由于摆脱了逐 Token 生成的时间依赖，并行生成相同数量 Token 所需的时间大幅缩短，从而在各类交互场景中实现极低延迟的超快响应，从根本上重塑了企业的 Token 经济学与成本结构。 ```mermaid flowchart TD accTitle: Autoregressive vs Diffusion LLM Generation subgraph AR["传统自回归模型 (Sequential Autoregressive)"] direction LR A1["Token 1"] --> A2["Token 2"] --> A3["Token 3"] --> A4["... (逐字串行)"] end subgraph Diff["扩散模型 (Diffusion LLMs - Mercury)"] direction TB B1["初始粗略预测 / 噪声全局状态"] B2["并行多轮迭代去噪与精炼"] B3["最终高质结构化文本输出"] B1 --> B2 --> B3 end ``` --- ### [04:59](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=299s) 发展历程与业界反响：从 Mercury 1 到 Mercury 2 自 2019 年扩散模型在图像视频领域爆发后，Inception 团队及其学术实验室经过多年深耕，攻克了扩散架构用于离散文本生成的理论与工程难题，并正式创立 Inception。随后公司结束隐身状态，推出了全球首个商业级扩散语言模型 Mercury。产品发布迅速引发了学术界与工业界领军人物的广泛关注，Andreaj Karpathy、吴恩达（Andrew Ng）以及埃隆·马斯克（Elon Musk）等均对其超高生成速度给予了高度评价，并视其为极具潜力的下一代范式。随后，Nvidia、阿里巴巴（Alibaba）以及 Google 等顶级机构也纷纷跟进扩散语言模型方向的研究。Inception 进一步推出了升级版 Mercury 2，该模型不仅具备极高的吞吐性能，还成为了全球生成速度最快的推理大模型（Reasoning LLM），全面赋能对响应速度有极致要求的语音、客服、搜索与代码生成场景。 - **行业巨头跟进**：Nvidia、Alibaba、Google 均已设立扩散 LLM 研究项目。 - **Mercury 2 定位**：兼顾深度推理能力与极速并行的全球最快推理大模型。 --- ### [06:40](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=400s) 独立评测性能与生态集成根据全球权威的独立大语言模型评测机构 Artificial Analysis 的基准测试数据，Mercury 系列模型在质量与吞吐量（Throughput）构成的坐标系中展现出了极强的竞争力。与 OpenAI（GPT-4o mini 等）、Anthropic（Claude Haiku 系列）以及 Google（Gemini Flash 系列）等前沿实验室主打的速度优化型小模型相比，Mercury 在保持相当质量水准的前提下，吞吐速度实现了数倍超越。 | 模型版本 | 性能与质量特征 | 吞吐表现 | |:--- |:--- |:--- | | **Mercury 1** | 初期探索版本，基础生成质量 | 约 700 tokens/s | | **Mercury 2** | 质量大幅跃升，兼具强大的推理逻辑能力 | 显著超越前代与主流 Speed-Optimized 竞品 | 在工程落地与生态集成方面，Inception 提供完全兼容 OpenAI API 规范的调用接口，开发者无需重构业务代码即可无缝平替。模型目前已上架 AWS、Azure、Baseten 等主流云平台与基础设施服务商，同时也支持 Inception 官方的第一方平台直接调用，重点服务对首字延迟（TTFT）极为敏感的语音对话、AI 编程智能体及高频海量搜索场景。 --- ### [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) 企业落地实战案例：语音、搜索与智能编程 Harness #### 1. 实时语音与客服场景（OpenCall 案例） OpenCall 原先采用基于 Cerebras 专用硬件加速的解决方案，在评估后全面迁移至 Mercury。在语音会话中，延迟预算极其苛刻。以往的架构受限于生成速度，在预算内只能运行不带链式思考（Chain-of-Thought）的非推理模型。而 Mercury 由于吞吐速度极快，即使开启 Medium 或 Loom 等深度推理模式，其端到端生成耗时依然低于竞品的非推理模型，使得企业能够在传统非推理模型的延迟预算内直接获得深度推理能力。 ```mermaid flowchart TD accTitle: OpenCall Latency Budget Comparison subgraph Traditional["传统方案 (Cerebras / 竞品)"] T1["有限延迟预算"] --> T2["仅能运行基础非推理模型 (无复杂逻辑能力)"] end subgraph MercuryPlan["Inception 扩散方案 (Mercury 2)"] M1["相同延迟预算"] --> M2["运行 Medium/Loom 深度推理模式 (速度仍快于竞品非推理模型)"] end ``` #### 2. 规模化搜索与检索（Exa 评测案例）在搜索引擎提供商 Exa 发布的基准测试中，搜索应用不仅要求极致的即时响应，更面临海量查询并发带来的算力成本压力。测试数据显示，在“准确率 vs 速度”与“准确率 vs 成本”两个维度的综合对比中，Mercury 模型均处于明显的帕累托前沿（Pareto Frontier），以极低单 Token 成本提供了兼顾高准确率与高吞吐的查询处理能力。 #### 3. AI 编程系统编排（Augment Code 案例）代码生成是目前对 Token 消耗最为剧烈的领域之一。随着行业从盲目追求 Token 消耗量转向追求实际交付价值，Augment Code 采用了多智能体分层编排架构（Orchestrated Multi-agent System）。系统无需将所有繁重子任务（如上下文检索、代码切片、语法验证、分支路由等）全部派发给昂贵的主智能体，而是将大量子代理任务交由 Mercury 执行。Mercury 在大幅降低流水线端到端延迟的同时，显著削减了企业的 Token 运行成本。 --- ### [12:02](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=722s) 走向智能过剩时代：单位能耗与成本下的智能效率随着 AI 基础设施的持续扩张，行业正稳步迈入“智能过剩/充裕”（Intelligence is abundant）的新阶段。在基础智能随处可得的背景下，核心竞争维度正在转向“单位瓦特/单位成本下的最高智能输出”（Intelligence per watt/cost），这也正是决定业务长期商业可行性与 Token 经济学的关键底座。Inception 正在通过 Mercury 等扩散语言模型重新定义这一效率前沿，并在客户支持、语义搜索及自动化编程等规模化生产场景中全面落地。 ## Notable quotes > running a frontier model for all of them means paying frontier prices for work that doesn't need frontier intelligence. — Aditya Grover > Mercury 2, generates tokens in parallel to run 5x faster than comparable speed-optimized models from the top frontier labs at a fraction of the cost, at comparable quality. — Aditya Grover > [00:04](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=4s) 主流自回归文本模型在推理端依然受制于逐字串行的瓶颈。与之形成鲜明对比的是，在图像与视频等生成式 AI 领域，主流范式正是高度并行的扩散模型（Diffusion）。 — Aditya Grover > [03:25](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=205s) 基于扩散架构的语言模型 Mercury 采用完全并行的 Token 生成机制。模型在生成初始阶段会对最终输出给出一个粗略的全局猜测，随后在多次迭代中持续去噪与精炼，最终输出完整文本。 — Aditya Grover > [03:25](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=205s) 由于摆脱了逐 Token 生成的时间依赖，并行生成相同数量 Token 所需的时间大幅缩短，从而在各类交互场景中实现极低延迟的超快响应，从根本上重塑了企业的 Token 经济学与成本结构。 — Aditya Grover > [04:59](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=299s) Mercury 2，该模型不仅具备极高的吞吐性能，还成为了全球生成速度最快的推理大模型（Reasoning LLM）。 — Aditya Grover > [06:40](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=400s) 与 OpenAI（GPT-4o mini 等）、Anthropic（Claude Haiku 系列）以及 Google（Gemini Flash 系列）等前沿实验室主打的速度优化型小模型相比，Mercury 在保持相当质量水准的前提下，吞吐速度实现了数倍超越。 — Aditya Grover > [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) Mercury 由于吞吐速度极快，即使开启 Medium 或 Loom 等深度推理模式，其端到端生成耗时依然低于竞品的非推理模型，使得企业能够在传统非推理模型的延迟预算内直接获得深度推理能力。 — Aditya Grover > [08:53](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=533s) 在“准确率 vs 速度”与“准确率 vs 成本”两个维度的综合对比中，Mercury 模型均处于明显的帕累托前沿（Pareto Frontier）。 — Aditya Grover > [12:02](https://www.youtube.com/watch?v=9KJ2qcI9CRo&t=722s) 核心竞争维度正在转向“单位瓦特/单位成本下的最高智能输出”（Intelligence per watt/cost），这也正是决定业务长期商业可行性与 Token 经济学的关键底座。 — Aditya Grover ## Mentioned Aditya Grover, Inception, Mercury, Mercury 1, Mercury 2, Nvidia, Google, OpenAI, GPT-4o mini, Anthropic, Claude Haiku, Gemini Flash, Stanford University, Andrej Karpathy, Andrew Ng, Elon Musk, Alibaba, Artificial Analysis, AWS, Azure, Baseten, OpenCall, Cerebras, Exa, Augment Code, Transformer, Attention Is All You Need ## Video description Aditya Grover - CTO and Co-Founder, Inception As frontier models permeate organizations, the economics of these models beg the question: should enterprises pay for the smartest model for every workflow? In practice, AI-native enterprises make thousands of invisible calls to frontier models per session, the ones that route, compress, search, and summarize, and running a frontier model for all of them means paying frontier prices for work that doesn't need frontier intelligence. In this talk, I will show how diffusion LLMs change the token economics. At Inception, we have released Mercury, the world's first generation of frontier LLMs built using diffusion. Our latest model, Mercury 2, generates tokens in parallel to run 5x faster than comparable speed-optimized models from the top frontier labs at a fraction of the cost, at comparable quality. Available on all major platforms, Mercury 2 powers workflows at top enterprises spanning coding, search, and voice, delivering ultra-fast user experiences at a fraction of the cost of competing language models. [Source](https://www.youtube.com/watch?v=9KJ2qcI9CRo)

Source quotes

Aditya Grover: running a frontier model for all of them means paying frontier prices for work that doesn't need frontier intelligence. Aditya Grover: Mercury 2, generates tokens in parallel to run 5x faster than comparable speed-optimized models from the top frontier labs at a fraction of the cost, at comparable quality. [0:04] Aditya Grover: 主流自回归文本模型在推理端依然受制于逐字串行的瓶颈。与之形成鲜明对比的是，在图像与视频等生成式 AI 领域，主流范式正是高度并行的扩散模型（Diffusion）。 [3:25] Aditya Grover: 基于扩散架构的语言模型 Mercury 采用完全并行的 Token 生成机制。模型在生成初始阶段会对最终输出给出一个粗略的全局猜测，随后在多次迭代中持续去噪与精炼，最终输出完整文本。 [3:25] Aditya Grover: 由于摆脱了逐 Token 生成的时间依赖，并行生成相同数量 Token 所需的时间大幅缩短，从而在各类交互场景中实现极低延迟的超快响应，从根本上重塑了企业的 Token 经济学与成本结构。 [4:59] Aditya Grover: Mercury 2，该模型不仅具备极高的吞吐性能，还成为了全球生成速度最快的推理大模型（Reasoning LLM）。 [6:40] Aditya Grover: 与 OpenAI（GPT-4o mini 等）、Anthropic（Claude Haiku 系列）以及 Google（Gemini Flash 系列）等前沿实验室主打的速度优化型小模型相比，Mercury 在保持相当质量水准的前提下，吞吐速度实现了数倍超越。 [8:53] Aditya Grover: Mercury 由于吞吐速度极快，即使开启 Medium 或 Loom 等深度推理模式，其端到端生成耗时依然低于竞品的非推理模型，使得企业能够在传统非推理模型的延迟预算内直接获得深度推理能力。 [8:53] Aditya Grover: 在“准确率 vs 速度”与“准确率 vs 成本”两个维度的综合对比中，Mercury 模型均处于明显的帕累托前沿（Pareto Frontier）。 [12:02] Aditya Grover: 核心竞争维度正在转向“单位瓦特/单位成本下的最高智能输出”（Intelligence per watt/cost），这也正是决定业务长期商业可行性与 Token 经济学的关键底座。

Source quotes

Aditya Grover: running a frontier model for all of them means paying frontier prices for work that doesn't need frontier intelligence. Aditya Grover: Mercury, the world's first generation of frontier LLMs built using diffusion. Aditya Grover: generates tokens in parallel to run 5x faster than comparable speed-optimized models from the top frontier labs at a fraction of the cost, at comparable quality. [0:04] Aditya Grover: inference era [3:25] Aditya Grover: world's fastest reasoning LLM [8:53] Aditya Grover: you can actually pack reasoning into the budget of a non-reasoning model, something which was not possible before. [8:53] Aditya Grover: token maxing [8:53] Aditya Grover: value maxing [8:53] Aditya Grover: intelligence per watt

Original transcript

[0:04] Uh my name is Aditya. I'm one of the co-founders and the CTO of Inception. So at Inception, [0:11] we are really trying to redefine what it means to have token efficiency for large language models. [0:18] And the way we are doing this is by inventing a new class of language models based on ideas from [0:25] diffusion. So to understand how we got here, it's helpful to take a trip down memory lane. [0:33] So if you want to think about what got us to this point where AI really took off, it's basically [0:39] three main things. One was parallel hardware. So in the late '9s, Nvidia created this wonderful [0:47] machine called the GPU which could perform matrix multiplication extremely efficiently. [0:54] And with these GPUs originally intended for graphics, uh these came down many many years [1:01] to have a presence for AI which also could utilize matrix multiplications at extreme scale. [1:09] Now two decades later uh there was a breakthrough in the world of neural networks. uh Google [1:18] released this paper called attention is all you need which introduced to the world the transformer [1:23] architecture today the transformer architecture is used in all major AI applications whether it's [1:31] text whether it's images um it really allows you to do parallel training of neural networks [1:38] so there was a really good match between the hardware that we have had for a few decades now [1:44] as well as what now became the de facto to architecture for neural network training. [1:50] But this world is now moving to the inference era. So we are all talking about how inference is where [1:57] all the enterprises and organizations are really focusing on because intelligent [2:02] models do exist all around us that allow us to explore so many different applications. [2:08] So what does parallelism look like for inference? Well, here we have a success story. So if you look [2:15] at the generative AI models that are being used for generating modalities like images and videos, [2:25] the state-of-the-art paradigm for those happens to be extremely parallel technology called diffusion. [2:32] So many of you might have seen these kinds of demos where you start with all noise [2:38] and then you clearly uncover structure to generate text that describes your favorite prompt. [2:45] So this was happens to be a technology that was also co-invented by one of my co-founders [2:51] back in 2019 at our Stanford lab [2:55] and now this is the mainstream solution for all of image and video generative modeling. [3:03] At inception the bet we are taking on is to now apply the same technology for text and the promise [3:10] is the same. parallelization is going to win and we need the inference solution for parallelization [3:18] that complements what we already have for hardware and for training of neural networks. [3:25] So how does how does this look like uh since since uh we made this bet? Uh so well uh if you just to [3:33] give you a quick demonstration of how this how this technology works in practice. So we are [3:41] a company that builds uh our own language models and our language models are called as mercury. So [3:48] these are the world's fastest language models as independently validated by numerous organizations [3:54] and what they do is they don't generate tokens sequentially. So what you're seeing at the top [4:00] is what is known as sequential auto reggressive generation where you took generate one token at a [4:06] time left to right. Uh that's what the earliest demonstrations of Chad GPT used to look like. [4:12] That's what a lot of frontier even today look like. What we're building with diffusion LLMs [4:19] are solutions which generate tokens in parallel. So you start with a rough guess for the answer. [4:27] That's what you see on the top and then you continuously refine it to generate the final [4:31] solution. Now why does this matter? Well, it turns out the amount of time it takes to generate tokens [4:39] in parallel is much lesser than the time it takes to do it sequentially from left to right. So for [4:46] all the applications you're building, you can get extremely fast solution, extremely fast responses [4:52] and that can totally change the token economics as we shall see for some of these applications later. [4:59] So here is a compressed summary of how this field has been taking off [5:04] and is ushering a new revolution for AI economics. So uh back in 2019 the fusion [5:12] for images and videos was already taking off and doing pretty well. Uh this was supplemented [5:19] uh many years later. A lot of research went into the research in uh my own research lab as well [5:25] as that of my co-founders and many other folks in the community to build together [5:31] a new foundation for LLMs which are parallel and once we had interesting results in a lab we [5:38] decided to start this company called inception. Um a few months later we came out of stealth [5:44] uh with the world's first commercial scale diffusion language model called Mercury. uh [5:50] Twitter was excited. So everyone from Andre Karpathi, Andrew Wing, [5:54] Elon Musk um these are folks uh who were extremely impressed by seeing how fast this technology was [6:03] and really were betting on this being the gamechanging paradigm in the years to come [6:10] and many other labs followed soon after. So now there are diffusion LM efforts [6:14] active at Nvidia, Alibaba, at Google. And earlier this year, we released Mercury 2, [6:22] the next evolution of our language model, which is the world's fastest reasoning LLM. [6:28] And it's now powering a bunch of ultraast applications for voice and customer support, [6:34] as well as in search, in coding, many of which I'll also talk about very soon. [6:40] So how fast is it? Uh well extremely fast. So this is a chart that's generated by artificial analysis [6:47] the world's leading independent uh evaluator for language models. And what you see on the x-axis [6:55] is the speed uh measured as throughput. Higher is better. So you want to be more towards the right. [7:02] And on the y-axis you're seeing quality. And here we're comparing against a bunch of [7:07] different language models from the frontier labs as well as some open source solutions. So you have [7:13] uh the speed optimized models from uh Enthropic, OpenAI, Google. And what you can see is [7:21] Mercury gets you similar quality as the speed optimized models from Frontier Labs. So [7:27] uh these could be like Gemini flash, GPT mini or claude haikus while it happens to be much [7:33] much faster in in throughput and this is only getting better. So as you see with Mercury 1 [7:40] uh the quality was uh low and the speed was still pretty high about 700 tokens per second. [7:46] But now with Mercury 2 that we launched a few months ago we have increased both the speed [7:51] and quality of these models and intend to keep doing so with the upcoming versions of Mercury. [8:00] So um from the AI stack perspective uh we are building our own LLMs. We provide them in an [8:07] OpenAI compatible format for you to plug into any applications. You'll find us on all the platforms [8:14] of interest from AWS to base 10 to a lot of Azure, a lot of cloud providers. Um, if you want to use [8:23] our first party platform, we support that as well. And all of these platforms are powering a bunch [8:29] of applications which require speed. So some of these applications span voice and customer support [8:37] where the time to first token is extremely critical. Um it also powers a lot of coding agents [8:44] as well as search and retrieval tasks which all of which require token economics to work at scale. [8:53] So just to show you some case studies uh this is a case study from uh one of our customers open call [9:01] um and what you're seeing here is uh basically how we deployed mercury models into their [9:08] stack so they were using earlier a solution on cerebras and they switched over to using mercury [9:15] uh when they found that the quality and speed that mercury offers sets a new frontier here that [9:22] is unparalleled even compared to what they were using earlier. So specifically what you [9:28] can see here is that if you see the chart on the right mercury which is a reasoning model [9:34] even under high reasoning under different modes of reasoning for instance in loom or medium modes [9:40] of reasoning it's doing faster than non-reasoning models which are currently being used for voice [9:46] and customer support applications. So because it's so fast, you can actually pack reasoning into the [9:52] budget of a non-reasoning model, something which was not possible before. Now another case study, [9:59] this time in a different domain uh of search. Here you're looking at both the speed and cost. [10:06] So uh for search applications, you want fast responses, but because of the volumes, [10:11] you also want to do this at uh low costs. And here you're seeing how the accuracy and speed profile [10:19] versus also the accuracy and cost profile both look extremely favor favorable for Mercury models [10:26] compared to other LLMs on on this benchmark that was released by Exa one of the search providers. [10:34] Okay. Uh the story keeps going on. Uh coding again coding has become one of the biggest [10:40] markets um where there is an intense demand for tokens. Uh but this intense demand for tokens [10:48] is now also coming up with questions around the sustainability of this as as as we think about [10:54] from going from token maxing to actually value maxing. Um and how we can think about um diffusion [11:02] LLM such as Mercury in this in this space is again uh by using the fact that Mercury serves tokens [11:09] extremely efficiently. Uh so this is again one of our customers augment code which talks about how [11:17] they use uh orchestrated system which uses mercury for a lot of the sub aent tasks. So you could have [11:24] an expensive mall as a primary agent, but not everything has to be done by the primary agent. [11:30] And a lot of the tasks that they have within their harness actually are then relegated to Mercury [11:36] because Mercury is able to bring down their uh latency as well as cost. So it gets you [11:43] twin benefits of defining a new kind of frontier for what diffusion LLMs would provide to based [11:50] on uh their fast speed and reduce costs. So with this um I I will conclude um and I would say that [12:02] as we move towards Sierra where intelligence is abundant, the remaining open question [12:07] is more around who provides the best intelligence per what because that ultimately defines the token [12:13] economics for the applications that exist today. And with diffusion LLMs uh such as Mercury, [12:21] we're trying to redefine that frontier and we are also being deployed extensively ac [12:29] customer support, search and coding. [12:32] So if you're interested in any of these applications, please do reach out. Thank you.