The fastest reasoning LLM just arrived — and it's not from OpenAI, Google, or Anthropic. Inception Labs, founded by Stanford AI image pioneer Stefano Ermon, launched Mercury 2 on February 24, 2026. The model reaches 1,009 tokens per second on NVIDIA Blackwell GPUs with just 1.7 seconds end-to-end latency — compared to 14.4 seconds for Gemini 3 Flash and 23.4 seconds for Claude Haiku 4.5 with reasoning.

Mercury 2 achieves this through a fundamentally different architecture: diffusion-based language modeling. Instead of generating text token by token, Mercury 2 refines multiple text blocks simultaneously — like an editor revising an entire draft at once rather than writing word by word. At $0.25 per million input tokens and $0.75 per million output tokens, it's also 4x cheaper than Claude Haiku on output pricing.

For latency-sensitive applications — voice assistants, real-time coding, search systems — Mercury 2 is a breakthrough. But the question that speed alone can't answer: what happens to conversational context between interactions?

Mercury 2: How Diffusion Changes Language Generation

Traditional transformer-based LLMs generate text autoregressively — one token at a time, each depending on all previous tokens. This sequential constraint creates a fundamental speed ceiling. Mercury 2 breaks through it by applying diffusion — the same technology that powers modern image and video generation — to language.

The model processes multiple data tokens simultaneously, refining an entire response in parallel rather than building it sequentially. This parallel generation is what enables the 5x speed advantage over conventional speed-optimized models. The 128K context window supports substantial input processing, and the model handles tool usage and JSON output for practical integration.

For single interactions, Mercury 2 delivers both speed and capability. The reasoning quality matches models that take 10x longer. But diffusion doesn't solve persistence. Mercury 2 generates incredibly fast responses — and then those interactions vanish from context. A voice assistant powered by Mercury 2 responds in milliseconds but remembers nothing between conversations. A coding tool delivers instant suggestions but can't learn from the developer's patterns over time.

How Mercury 2 Handles Interaction Context

Within its 128K context window, Mercury 2 maintains coherent understanding. The diffusion process considers the full input context when generating responses, producing outputs that are contextually aware and internally consistent. For multi-turn conversations within a session, the model tracks the conversation thread effectively.

The speed advantage makes Mercury 2 particularly compelling for real-time applications. Voice assistants need sub-second response times to feel natural. Real-time coding tools need instant feedback. Search systems need rapid result generation. Mercury 2 meets these requirements where slower models create perceptible lag.

Between sessions, context resets completely. The voice assistant that spent fifteen minutes learning a user's preferences starts fresh next time. The coding tool that understood the project's architecture loses that understanding when the session closes. Mercury 2's speed makes each interaction brilliant — but isolated.

The MemU Agentic Memory Framework: Fast Responses With Lasting Context

The MemU Agentic Memory Framework provides the persistent context that makes Mercury 2's speed truly transformative. Rather than fast interactions that reset, MemU enables fast interactions that compound — each one building on accumulated understanding.

Consider a customer service voice assistant powered by Mercury 2. The agent responds in under two seconds — dramatically faster than any competing model. With the MemU Agentic Memory Framework, that speed comes with recognition: "Welcome back, I remember we adjusted your billing cycle last week — is everything working as expected?" Speed plus memory creates an experience that feels both instant and personal.

The architecture complements Mercury 2 through three capabilities:

• Interaction continuity: The MemU Agentic Memory Framework captures context from Mercury 2 interactions and makes it available for future ones. Users experience continuous relationships rather than isolated conversations.
• Pattern learning: Across thousands of fast interactions, patterns emerge — user preferences, common issues, effective resolution approaches. MemU captures and retrieves these patterns to inform future responses.
• Real-time retrieval: Memory lookup adds negligible latency — sub-100ms retrieval means Mercury 2's speed advantage is preserved while gaining persistent context.

MemU makes Mercury 2's speed meaningful across time — every fast interaction adds to what future interactions know.

Head-to-Head: Fast and Forgetful vs. Fast and Persistent

Mercury 2 alone: 1,009 tokens/second, 1.7s latency, 5x faster than competitors. Brilliant for real-time applications. But each session is isolated — no accumulated user understanding, no progressive personalization, no learning from interaction patterns.

Mercury 2 + MemU: Same speed advantage plus persistent memory. Users experience continuous relationships. Interaction quality improves over time. Sub-100ms memory retrieval preserves Mercury 2's latency advantage. The fastest LLM becomes the fastest LLM that remembers.

Get Started with MemU

Mercury 2 represents a genuine architectural breakthrough. Diffusion-based language modeling achieves speed levels that transformer architectures struggle to match. For latency-sensitive applications, the 5x advantage is transformative.

The MemU Agentic Memory Framework ensures that speed serves long-term relationships, not just immediate responses. Fast interactions that build on previous ones. Real-time applications that get smarter over time.

Visit memu.pro to explore the Agentic Memory Framework API, or check out the open-source repository on GitHub to start building persistent memory into your Mercury 2 applications today.