YC Root Access · Published 2026-09-01

Building AI That Optimizes AI

privateReview: unreviewedConfidence: high
inferenceoptimizationgpusagentsllmsstartupinference-optimizationkernel-synthesisagentic-compilerlatencyheterogeneous-siliconinference-economicsllm-servingopen-source-models
Open on YouTube ↗

Summary

Overview

  • Speaker: Jared Friedman, Emilio Andere, Steven Arellano
  • Channel: YC Root Access
  • Main topic: How Wafer achieved rapid growth and raised a $40M Series A by building AI that optimizes AI inference across silicon and open-source LLMs.
  • Purpose: To discuss the founding story, technical breakthroughs, rapid scaling, and future outlook of Wafer, a Y Combinator-backed AI inference optimization startup. Jared Friedman (Managing Director at Y Combinator) interviews Emilio Andere (Co-founder and CEO) and Steven Arellano (Co-founder) of Wafer, a fast AI inference cloud startup. Founded by recent University of Chicago graduates in their early twenties, Wafer raised a $40M Series A co-led by Marathon and Chemistry after scaling from zero to $8M ARR in four months. Wafer uses AI agents to optimize open-source LLMs and GPUs across NVIDIA, AMD, and TPUs, achieving up to 2-3x performance gains and enabling massive cost savings and low latency for customers like Neon Health.

Topic Map

Introduction and Company Background

  • Explanation: Jared Friedman introduces Emilio Andere and Steven Arellano, recent University of Chicago graduates who founded Wafer and just raised a $40M Series A.
  • Key claims:
    • Wafer raised a $40M Series A co-led by Marathon and Chemistry.
    • Founders graduated from the University of Chicago about a year ago and are 23 years old.
    • Wafer grew from $0 to $8M ARR in four months.
  • Examples:
    • Founders went from undergraduate studies to running an AI infrastructure company on fire in roughly one year.
  • Terminology:
    • Series A
    • ARR
    • Inference cloud
  • Why it matters: Demonstrates the extreme velocity of modern AI startups backed by Y Combinator during the current AI revolution.

What Wafer Does

  • Explanation: Wafer is a fast AI inference cloud that runs AI models at top market speeds by using agents to optimize GPUs and hardware stacks.
  • Key claims:
    • Wafer routes and optimizes open models across NVIDIA, AMD, TPUs, and beyond.
    • Agents tune every layer of the stack for whatever silicon wins on price-performance.
    • Serves low-latency applications (voice agents) and high-throughput applications (coding).
  • Examples:
    • Voice agents needing sub-second response times to avoid breaking customer experience.
    • Coding assistants like Vercel ensuring coding agents run as fast as humanly possible.
  • Terminology:
    • Inference
    • Throughput
    • Latency
    • Silicon
    • GPU
  • Why it matters: Speed and cost in AI inference are critical bottlenecks for production applications; optimizing hardware and software stacks unlocks massive value.

The Series A and Hypergrowth

  • Explanation: Discussion around Wafer's $40M Series A round co-led by Marathon and Chemistry, driven by explosive growth from $0 to $8M ARR in four months.
  • Key claims:
    • Raised $40M co-led by Marathon and Chemistry with participation from Jeff Dean and YC.
    • Explosive growth caused them to run out of GPUs and immediately need funding to scale.
    • Shifted from selling GPU optimization software to companies to running open-source LLMs internally using their own agents.
  • Examples:
    • Optimizing GLM-5.2 and making it run 2-3x faster than market competitors on OpenRouter.
    • An offsite in Santa Cruz turning into around-the-clock hardware onboarding and debugging sessions.
  • Terminology:
    • Series A
    • ARR
    • Blackwell nodes
    • OpenRouter
  • Why it matters: Explains how extraordinary product performance directly translates into explosive revenue growth and venture capital demand.

Customer Use Cases and Neon Health

  • Explanation: Highlighting how customers like Neon Health use Wafer for automated hospital workflows, gaining 30-50% better performance per call.
  • Key claims:
    • Neon Health automates hospital medicine processing using AI agents.
    • Wafer provides 30-50% better performance on a per-call basis compared to previous larger inference providers.
    • Y Combinator itself uses Wafer's technology for the Office Hours Simulator.
  • Examples:
    • Neon Health switching from another inference provider to Wafer for lower latency on medical processing calls.
    • Y Combinator's Office Hours Simulator allowing founders to talk to AI clones of YC partners with ultra-low latency.
  • Terminology:
    • Neon Health
    • Office Hours Simulator
    • Per-call basis
    • Latency improvement
  • Why it matters: Real-world production examples validate that marginal improvements in LLM inference speed directly drive enterprise adoption.

The Technology Behind Wafer's Speed

  • Explanation: Explaining how Wafer's AI agents optimize kernels, quantization, and hardware stacks to outperform competitors.
  • Key claims:
    • AI agents act as compilers, writing custom kernels, quantization, and decoding models for specific hardware.
    • Wafer's dedicated GLM-5.2 endpoint achieved 316ms time-to-first-token in head-to-head benchmarks.
    • Open-source models paired with Wafer's optimization match or beat proprietary models at a fraction of the cost.
  • Examples:
    • Benchmarking GLM-5.2 on Wafer against Cerebras, Gemini, and GPT-4 mini.
    • Overnight benchmarking runs beating core NVIDIA libraries by coordinating agent optimization.
  • Terminology:
    • Time-to-first-token
    • GLM-5.2
    • Kernel optimization
    • Quantization
    • AB testing
  • Why it matters: Demonstrates deep technical moats in systems engineering and AI compiler optimization.

Founding Story and Advice for Founders

  • Explanation: Reflecting on how the founders started with cursor-based tools (Yakka), transitioned into hardware optimization, and advice on joining startups.
  • Key claims:
    • Started as Cursor for C++ / Yakka, using AI agents to optimize C++ code and kernels.
    • Realized the immense value and energy wasted on inefficient GPU software across the industry.
    • Advice on joining startups: Evaluate companies based on 1000x growth potential, founding team culture, and problem importance rather than specific roles.
  • Examples:
    • Building Yakka at UChicago to optimize C++ code using LLMs.
    • Realizing neither founder had ever held a 'real job' before starting Wafer.
  • Terminology:
    • Yakka
    • C++
    • Technical staff
    • Rocket ship
  • Why it matters: Provides philosophical and practical guidance for aspiring founders and early-stage startup employees.

Key Points

Explosive Revenue Growth via Technical Superiority

  • Explanation: Wafer scaled from zero to $8M ARR in four months because their proprietary agentic optimization made open-source models 2-3x faster than industry standards.
  • Evidence: Grew from $0 to $8M ARR in 4 months, leading to a $40M Series A co-led by Marathon and Chemistry.
  • Practical implication: When an infrastructure product delivers step-function speed improvements, customer acquisition and revenue growth happen organically.

AI Optimizing AI (Agentic Compilers)

  • Explanation: Wafer uses AI agents to automatically rewrite kernels, quantize models, and map code to diverse hardware (NVIDIA, AMD, TPUs).
  • Evidence: Agents take code, benchmark performance, rewrite kernels, and optimize runtime characteristics iteratively.
  • Practical implication: Manual compiler engineering is being replaced by agentic loops that continuously push hardware to physical limits.

Latency as a Product Requirement

  • Explanation: For real-time voice agents and interactive AI, milliseconds matter; shaving off latency fundamentally changes user behavior.
  • Evidence: Users stayed significantly longer and talked to avatars longer when latency was minimized using Wafer GLM-5.2.
  • Practical implication: Speed is not just a cost-saving metric; it directly unlocks new product categories and user engagement.

Evaluating Startups vs. Roles

  • Explanation: When joining early-stage companies, candidates should evaluate the trajectory of the founding team and 1000x growth potential rather than a rigid job description.
  • Evidence: Founders emphasize looking for rocket ships and exceptional founders because job roles change rapidly in high-growth startups.
  • Practical implication: Prioritize company momentum and talent density over precise title alignment when joining early-stage ventures.

Frameworks, Models & Processes

Wafer Agentic Hardware Optimization Loop

  • How it works: Takes customer workload characteristics, feeds them into an AI black box that writes custom kernels, trains speculative decoding models, quantizes models, and generates hyper-optimized runtimes.
  • Components:
    • Workload characteristic analysis
    • AI black box code generation
    • Custom kernel writing
    • Speculative decoding training
    • Quantization and runtime optimization
  • When to use: When deploying latency-sensitive or cost-sensitive LLM workloads across heterogeneous hardware.

Examples & Case Studies

Neon Health switched from a larger inference provider to Wafer.

  • Illustrates: Wafer delivering 30-50% better performance on a per-call basis for medical automation agents.
  • Lesson: Performance superiority drives enterprise migration away from legacy inference providers.

Steven stayed up all night running agents overnight to benchmark against NVIDIA libraries.

  • Illustrates: Outperforming major proprietary libraries through relentless automated optimization.
  • Lesson: Combining deep systems engineering with AI agent loops unlocks superhuman performance gains.

Y Combinator built the Office Hours Simulator using Wafer inference.

  • Illustrates: Powering real-time video AI clones of YC partners with ultra-low latency.
  • Lesson: Dogfooding and internal collaboration accelerate product validation.

Actionable Takeaways

  • Immediate:
    • Utilize agentic loops for automated kernel and runtime optimization.
    • Prioritize latency reduction in real-time voice and interactive AI applications.
    • Evaluate startups based on founder quality and 1000x growth potential.
  • Strategic:
    • Open-source models combined with custom inference optimization can match proprietary model quality at a fraction of the cost.
    • Hardware-agnostic routing (NVIDIA, AMD, TPUs) is becoming essential as silicon diversity increases.
    • Speed is the ultimate moat in AI infrastructure.
  • Questions to investigate:
    • How far can agentic compilers push hardware optimization before hitting physical silicon limits?
    • How will enterprise adoption of AMD and TPU hardware evolve as software parity improves?
    • What new interactive AI modalities become viable as time-to-first-token drops below 100ms?

Claims Worth Verifying

  • Wafer scaled from zero to $8M ARR in four months. (Financial Growth)
  • Wafer's dedicated GLM-5.2 endpoint achieved 316ms time-to-first-token in benchmarks. (Performance Benchmark)
  • Wafer raised a $40M Series A co-led by Marathon and Chemistry. (Fundraising)

Notable Quotes

"The fastest inference on any silicon" "AI that optimizes AI" "If you're offered a seat on a rocket ship, you just don't ask what exactly you're going to do within the rocket ship."

Compressed Summary

  • Wafer is a fast AI inference cloud optimizing open models across NVIDIA, AMD, and TPUs using AI agents.
  • Grew from $0 to $8M ARR in four months, securing a $40M Series A co-led by Marathon and Chemistry.
  • Achieved 316ms time-to-first-token on GLM-5.2, beating industry benchmarks through agentic kernel optimization.
  • Empowers mission-critical applications like Neon Health and Y Combinator's Office Hours Simulator with ultra-low latency.
  • Keywords: inference, optimization, gpus, agents, llms, startup
  • Core insight: By using AI agents to automatically optimize software stacks and hardware kernels for open-source LLMs, Wafer achieved explosive growth and unbeatable inference speed.

Core insights

5
Mechanismhigh noveltystrong evidence

AI agents can serve as an optimizing compiler for LLM inference: they write custom kernels, quantization, and decoding paths for specific hardware, then benchmark and revise until they beat established system libraries.

Why it matters

This turns a traditionally manual compiler and kernel-engineering process into an automated search loop, which is the underlying engine behind 2-3x inference speedups in production.

Generalization

Performance-sensitive system software can be treated as an agentic synthesize-benchmark-revise process, where the agent does the low-level optimization work that used to require senior systems engineers.

AI agents act as compilers, writing custom kernels, quantization, and decoding models for specific hardware.
Open source video
Overnight benchmarking runs beating core NVIDIA libraries by coordinating agent optimization.
Open source video
Empirical Resultmedium noveltymoderate evidence

Systems-level inference optimization can make open-source models commercially competitive with proprietary APIs, not on capability alone but on latency and cost.

Why it matters

Model evaluation and model selection in production now need to account for the serving/optimization layer, which can offset model-quality gaps at a fraction of the price.

Generalization

The competitive boundary between frontier APIs and open models is increasingly drawn by inference engineering, not just model weights.

Open-source models paired with Wafer's optimization match or beat proprietary models at a fraction of the cost.
Open source video
Wafer's dedicated GLM-5.2 endpoint achieved 316ms time-to-first-token in head-to-head benchmarks.
Open source video
Mental Modelhigh noveltystrong evidence

The highest-leverage way to productize an agentic optimization capability is to vertically integrate it into a full inference cloud rather than selling it as an external optimization tool.

Why it matters

This shifts value capture from selling software to selling measured performance of running models, enabling faster revenue and a feedback loop from real workloads.

Generalization

If an agentic tool can reliably produce deep optimization, the owning company can make more money by operating the optimized system itself than by licensing the tool.

Shifted from selling GPU optimization software to companies to running open-source LLMs internally using their own agents.
Open source video
Empirical Resultmedium noveltymoderate evidence

Latency improvement, quantified per inference call, drives enterprise vendor switching in production agent workloads: Neon Health switched after getting 30-50% better per-call performance.

Why it matters

For real-time agent loops like medical automation and voice, marginal latency wins are material enough to displace previously selected providers.

Generalization

Latency and cost per call can be decisive adoption metrics for AI workloads, and optimizing them should take precedence over many feature-level differentiators.

Wafer provides 30-50% better performance on a per-call basis compared to previous larger inference providers.
Open source video
Voice agents needing sub-second response times to avoid breaking customer experience.
Open source video
Architecturemedium noveltymoderate evidence

Optimized inference infrastructure increasingly treats heterogeneous silicon (NVIDIA, AMD, TPUs) as a single scheduling surface, with agents automatically tuning and routing across whichever chip wins on price-performance.

Why it matters

Hardware-portability becomes a compiler/agent responsibility rather than an application concern, removing the traditional CUDA-first coupling from AI infrastructure.

Generalization

High-throughput agentic workloads will be written against model/hardware-agnostic serving layers, with the compute substrate selected dynamically by the optimization system.

Agents tune every layer of the stack for whatever silicon wins on price-performance.
Open source video

Deep dives

5

Verification and numerical correctness of agent-synthesized kernels

Research question

How can an agentic kernel-synthesis loop guarantee numerical correctness, stability, and equivalence to reference inference implementations when writing custom low-level GPU kernels, quantizers, and decoders?

Why

Machine-written kernels can beat NVIDIA libraries on benchmarks, but speedup claims are only meaningful if outputs remain faithful in production. Silent numerical regressions in a fast inference cloud would break low-latency voice and medical workloads, making verification an essential layer of the synthesize-benchmark-revise loop.

AI agents act as compilers, writing custom kernels, quantization, and decoding models for specific hardware.
Open source video
Overnight benchmarking runs beating core NVIDIA libraries by coordinating agent optimization.
Open source video
Source video

Transferability of agent-found optimizations across models, silicon, and generations

Research question

How much of an optimization discovered for one model and one GPU carries over to other model sizes, architectures, and hardware generations, and what representation predicts transfer?

Why

Current evidence is centered on a dedicated GLM-5.2 endpoint with 316ms time-to-first-token. If every model/hardware pair requires bespoke optimization, the agentic inference cloud can only scale if optimizations transfer into reusable recipes instead of restarting from scratch.

Wafer's dedicated GLM-5.2 endpoint achieved 316ms time-to-first-token in head-to-head benchmarks.
Open source video
Open-source models paired with Wafer's optimization match or beat proprietary models at a fraction of the cost.
Open source video
Source video

Physical-ceiling-aware stopping rules for agentic optimization

Research question

Can a roofline model tell an optimizing agent when it is near physical hardware limits, and do such stopping rules reduce wasted GPU-hours without forfeiting meaningful speedups?

Why

The agent loop can run overnight benchmarking until it beats NVIDIA libraries, but unbounded search is costly. As optimization is applied to many model/hardware combinations, the agent must know when diminishing returns have arrived so scarce GPU capacity is not burned.

Overnight benchmarking runs beating core NVIDIA libraries by coordinating agent optimization.
Open source video
Source video

Incremental retuning as open-source model weights change

Research question

When an open-source model emits a new version, can the agent retain prior kernels and quantization recipes and adapt incrementally, or does every release require a full retuning cycle?

Why

Open-source models update frequently, which could erase expensive agentic optimization work. Measuring reuse and retuning costs over model versions determines whether an agent-optimized inference cloud can maintain a broad, current model catalog.

Optimizing GLM-5.2 and making it run 2-3x faster than market competitors on OpenRouter.
Open source video
Source video

Per-call latency and cost contracts as enterprise switching triggers

Research question

How should inference providers define, measure, and expose per-call latency/cost contracts so enterprises can reliably compare vendors and switch workloads like Neon Health did?

Why

A 30-50% measured per-call improvement convinced Neon Health to switch providers. Standardizing how that contract is measured across traffic patterns and workloads could make latency/cost the decisive criterion in enterprise AI infrastructure procurement.

Wafer provides 30-50% better performance on a per-call basis compared to previous larger inference providers.
Open source video
Voice agents needing sub-second response times to avoid breaking customer experience.
Open source video
Source video

Article ideas

4

Don't Sell the Optimization Tool; Operate the Optimized Inference Cloud

When an agent can reliably optimize inference, the business should capture the value by running the optimized model itself: vertical integration creates production telemetry that feeds the next optimization loop and makes the company more defensible than a standalone software tool.

Angle

Business-model analysis of Wafer's pivot from GPU optimization software to running open-source LLMs internally

Source video

Open Weights Plus Optimized Serving Beat Proprietary APIs on Real-World Cost-Performance

With an agentic inference layer, open-source models no longer compete only on weights; their serving stacks can match or beat proprietary APIs at a fraction of the cost, so model procurement decisions must include the serving/optimization layer.

Angle

Model evaluation and procurement from a serving-economics point of view

Source video

Per-Call Performance Contracts Are the Real AI Infrastructure Moat

A measured 30-50% improvement in per-call latency and cost induces enterprises to switch inference vendors, so AI infrastructure startups should sell enforceable latency/cost contracts rather than competing on model catalog breadth.

Angle

Go-to-market and product design for inference clouds serving production agents

Source video

From Vendor-Shaped Code to Agent-Routed Silicon: Heterogeneous GPUs Become a Scheduling Surface

Agentic per-layer tuning will make NVIDIA, AMD, and TPU choices a dynamic scheduling decision, so application and serving code should treat silicon as replaceable infrastructure behind a model-serving layer.

Angle

Architecture frontier for heterogeneous AI compute

Source video

Project ideas

4

Kernel-Reason: Agentic Kernel Search with Correctness Gates

new

An agentic synthesize-benchmark-revise loop gated by differential testing will find a GPU kernel for a representative inference operator that is at least 1.5x faster than the serving stack's baseline kernel while keeping numerical error below a high-precision reference tolerance.

Proof of concept

Construct a sandboxed harness that prompts an LLM to emit low-level GPU kernel implementations for a hot inference operator, compiles and runs each candidate, checks outputs against a high-precision reference over random and adversarial shapes, benchmarks latency, and feeds pass/fail and timing signals into subsequent LLM proposals for 20 iterations.

Measurement

Speedup over baseline kernel; numerical error of accepted candidates; percentage of proposals that compile, pass correctness, and improve; GPU-hours consumed.

Source video

Roofline Stop-Guard

new

Adding a roofline-based stopping rule to an agentic kernel search preserves at least 80% of the best-found speedup while using less than half the GPU-hours of an unbounded search.

Proof of concept

Take the kernel-search harness and run two arms on the same operator and GPU: an unbounded agent loop for 20 proposals and an agent loop with a roofline upper-bound stop rule. Log every candidate's speedup and elapsed GPU time.

Measurement

Best speedup relative to baseline; GPU-hours consumed; measured performance as a fraction of roofline peak; reproducibility across two different operators.

Source video

Optimization Transfer Probe

beyond-evals

A frozen recipe of agent-generated kernels and quantization from one open-weight model transfers at least 60% of its bespoke speedup to a same-family model, but transfers less than 20% speedup to a different-architecture model of similar size.

Proof of concept

Select three open-weight LLM checkpoints across two architectures and a shared operator suite. Run the agentic optimizer on the reference checkpoint to produce a frozen kernel/quantization recipe, apply that frozen recipe to all three checkpoints, then run bespoke optimization on each as a control arm.

Measurement

Transfer ratio equal to frozen-recipe speedup divided by bespoke speedup on each target; acceptance rate of kernels; GPU-hours avoided by reuse.

Source video

Per-Call Latency Contract Probe

new

A standardized variable-concurrency load test measuring time-to-first-token and per-request cost can reproduce observable 30-50% provider differences for a voice-agent workload with less than 10% test-retest variance.

Proof of concept

Implement a parameterized benchmark client that replays a voice-agent-style request trace against two inference providers serving the same or comparable open model, varying concurrency and context length over repeated controlled sessions.

Measurement

Median and p95 time-to-first-token, sustained throughput, cost per 1,000 calls, and coefficient of variation across repeated runs.

Source video

Architectural implications

3

Customers receive a model endpoint that is continuously tuned for specific silicon rather than a model API running on a generic hardware stack.

Before

Inference providers deploy models on fixed hardware using pre-built runtimes and kernels, and users opt into a model name with no fine-grained performance contract.

After

The serving plane gains an autonomous optimization layer that rewrites kernels and maps workloads to whichever hardware configuration is best for the model.

Consequence

Inference API products can be differentiated on measured latency/price curves instead of model catalog size, and customers should expect versioned performance SLAs per model and workload.

Source video

The same agentic optimization layer is applied to both low-latency (voice) and high-throughput (coding) workloads, implying workload-specific kernel and batching choices.

Before

A model deployment had to trade off latency and throughput statically, and teams manually chose serving parameters.

After

Agents can produce different optimized variants of the same model, one for time-to-first-token dominance and another for token throughput, and route requests based on workload pattern.

Consequence

The abstraction boundary between model, optimization, and workload policy will need explicit latency/throughput intent from clients so the auto-optimizer can specialize correctly.

Source video

A company that optimizes inference internally also runs the hardware and serves the API, creating a tightly integrated optimization-serving architecture.

Before

Optimization tools were separate from inference serving, so optimization outcomes were delivered as code or recommendations to a separate operator.

After

The optimizer runs continuously inside the serving stack, and production telemetry directly fuels the next round of kernel or quantization improvements.

Consequence

This tightens the feedback loop between runtime data and optimization, making it harder for external tooling vendors to match because they lack the serving workload signal.

Source video

Tradeoffs and failure modes

3

Agentic kernel and quantization rewriting

Benefit

Beat core NVIDIA libraries and deliver step-change inference speedups for open models.

Cost or risk

Correctness and numerical stability of machine-written kernels must be continually verified; benchmark noise and overfitting to specific test shapes can lead to regressions in production.

Overnight benchmarking runs beating core NVIDIA libraries by coordinating agent optimization.
Open source video
Source video

Deep per-model specialization

Benefit

A dedicated tuned GLM-5.2 endpoint reached 316ms time-to-first-token, which is excellent advertising and contributes to fast ARR growth.

Cost or risk

Optimization may be fragile across model versions or may require repeated retuning for every model/hardware pair, limiting breadth of the model catalog.

Wafer's dedicated GLM-5.2 endpoint achieved 316ms time-to-first-token in head-to-head benchmarks.
Open source video
Source video

Vertical integration into an inference cloud

Benefit

Directly capturing revenue from inference and having production telemetry to feed further optimization efforts.

Cost or risk

Requires substantial GPU capital and operational complexity; explosive adoption forced the company to raise money to buy more hardware.

Explosive growth caused them to run out of GPUs and immediately need funding to scale.
Open source video
Source video

Open questions

4

How do agentic compilers assure correctness of hand-written kernels and quantized models rather than only measuring speed?

Why unresolved

The evidence in the summary focuses on benchmark speedups and latency numbers, not on verification/reliability processes.

Research direction

Explore combining agentic kernel synthesis with formal checks, differential testing, and production-quality fuzzing before deployment.

Source video

How transferable is an agent-optimized kernel or runtime across models of different sizes, architectures, and hardware generations?

Why unresolved

The cited empirical successes are specifically for GLM-5.2 and targeted NVIDIA/AMD/TPU stacks, with no cross-model generalization data in the summary.

Research direction

Measure optimization transfer learning and build a representation that predicts whether an optimization found for one model will speed up another.

Source video

What happens when open-source models release updates frequently? Do the agents retain the prior kernels and adapt incrementally, or is a full retuning cycle needed?

Why unresolved

The summary doesn't address maintenance over time, only the single high-visibility GLM-5.2 success.

Research direction

Track kernel and quantization reuse rates as model weights are updated and measure whether agentic retuning costs grow linearly or sublinearly.

Source video

Where is the empirical ceiling for agentic optimization, and what mechanism determines physical limits?

Why unresolved

The summary states the loops 'push hardware to physical limits' but doesn't identify how they know when they have arrived or when diminishing returns should stop the search.

Research direction

Build a roofline model that tells the agent when further kernel optimization is unlikely to yield meaningful gains, saving compute and engineering time.

Source video

Key claims

6
factualVerification needed

Wafer grew from $0 to $8M ARR in four months.

Evidence

Grew from $0 to $8M ARR in 4 months, leading to a $40M Series A co-led by Marathon and Chemistry.

Question

Are revenue numbers audited or available in the Series A announcement?

Source video
comparativeVerification needed

Optimized GLM-5.2 runs 2-3x faster than market competitors on OpenRouter.

Evidence

Optimizing GLM-5.2 and making it run 2-3x faster than market competitors on OpenRouter.

Question

What benchmarks and OpenRouter endpoints were used, and what were the exact load conditions?

Source video
comparativeVerification needed

Open-source models combined with Wafer's optimization match or beat proprietary models at a fraction of the cost.

Evidence

Open-source models paired with Wafer's optimization match or beat proprietary models at a fraction of the cost.

Question

Which proprietary models, workloads, and pricing tiers were directly compared?

Source video
factualVerification needed

Wafer's dedicated GLM-5.2 endpoint achieved 316ms time-to-first-token.

Evidence

Wafer's dedicated GLM-5.2 endpoint achieved 316ms time-to-first-token in head-to-head benchmarks.

Question

Was the 316ms figure from an independent reproducible public benchmark or self-published?

Source video
comparativeVerification needed

Neon Health gets 30-50% better performance per call on Wafer compared to previous larger inference providers.

Evidence

Wafer provides 30-50% better performance on a per-call basis compared to previous larger inference providers.

Question

What does 'performance per call' measure and were the two providers tested under identical traffic patterns?

Source video
factualVerification needed

Agents write custom kernels, quantization, and decoding models for hardware-specific optimization.

Evidence

AI agents act as compilers, writing custom kernels, quantization, and decoding models for specific hardware.

Question

Can the company attribute concrete product deployments to agent-generated kernels versus human-engineered ones?

Source video

Connections

5