Modal taps Nvidia Vera CPUs after reporting 2x sandbox throughput

Modal taps Nvidia Vera CPUs after internal testing showed up to twice the throughput under load, challenging its reliance on Intel and AMD processors. Throughput measures completed work per unit of time. The result concerns shared computing capacity, rather than a promise that every AI task finishes twice as fast.

That distinction puts the competitive pressure in focus. Nvidia is pursuing the ordinary software execution surrounding AI models, where Intel and AMD already supply Modal’s processors. A CPU, or central processing unit, runs general software instructions. For an AI service, that includes executing generated code and handling work between model responses.

Modal’s finding supports a specific purchasing argument: judge processors by useful work completed on busy servers. However, adopting Vera also requires software changes, and Modal plans to retain its existing suppliers. The immediate story is an additional hardware option with a promising workload fit, rather than a completed replacement of its fleet.

Modal taps Nvidia Vera CPUs for a planned sandbox rollout

In its October 19 engineering post, Modal said it had received its first Vera server in San Francisco the previous week. The company reported up to double the throughput against an equivalent Intel Granite Rapids machine during early concurrent testing. Its sandbox throughput findings describe plans to introduce Vera support, rather than a completed fleetwide deployment.

The verified change is a planned architecture expansion backed by customer testing, with production adoption still requiring engineering work.

A sandbox is an isolated environment that runs code while separating it from other activity. For an AI coding agent, that environment becomes the place where proposed changes encounter executable reality. The model can suggest a fix, but software still needs to build, run, and return results.

This creates a different hardware decision from choosing a processor for a single application. A cloud provider must consider how unrelated customer jobs behave together. The preferred server needs to support productive activity across its tenants without making individual jobs unacceptably slow.

Modal’s test therefore matters as evidence from a prospective operator. Nvidia has an interest in presenting Vera favorably, but Modal also faces the consequences of introducing another architecture. Supporting new hardware adds work before any performance advantage reaches customers.

That does not make Modal an independent testing laboratory. Its results remain company measurements, shaped by its selected workloads and operating priorities. Nevertheless, the decision to undertake compatibility work gives the findings more commercial relevance than an isolated vendor demonstration.

The wording around adoption deserves care. Receiving a server, completing an evaluation, announcing support plans, and serving ordinary customer traffic represent different milestones. They should not collapse into a single claim that Vera already powers Modal’s entire service.

Likewise, a throughput advantage does not establish an identical improvement for every customer. Some workloads consume little processor time. Others spend substantial periods waiting for external services. Hardware gains reach users according to which parts of their jobs actually depend on the processor.

The useful question is therefore narrower than whether Nvidia has suddenly become the fastest CPU supplier. It is whether Vera offers Modal enough additional capacity, under acceptable response times, to justify expanding its software and hardware support.

That question creates the article’s main competitive line: Nvidia’s new option against Modal’s established Intel and AMD infrastructure. The benchmark opens that contest, while deployment experience will determine its operational value.

AI agents put pressure on the processors between model calls

AI agents expand the CPU purchasing decision because useful work continues after a model produces its next instruction.

An AI agent is software that uses a model to select and execute steps toward a goal. Its progress depends on both the model’s decisions and the systems carrying them out. Improving either side helps only when it addresses work that limits completion.

Consider an illustrative coding task. An agent proposes a change, executes a test, reads the failure, and revises its approach. The generated answer is an intermediate step. The task remains unfinished until the surrounding software supplies feedback the agent can use.

This makes processor performance relevant without diminishing the role of GPUs, or graphics processing units, which accelerate highly parallel computations. The hardware categories support different parts of the process. Faster model computation cannot eliminate time spent waiting for necessary software execution.

Nvidia’s July agent workload analysis argues that sustained CPU performance under load affects the progress of AI services. That is a vendor argument, rather than independent confirmation of Modal’s results. Its relevance lies in the mechanism: sequential dependencies can make CPU delays consequential beyond the CPU itself.

The pressure on Intel and AMD comes from how buyers define the comparison. If the purchasing criterion emphasizes completed agent work on occupied servers, familiar processor specifications become supporting evidence. They do not settle the decision by themselves.

Core counts, for example, indicate available execution resources. They do not automatically reveal how quickly a mixed collection of dependent tasks will finish. Buyers still need to observe the behavior of their actual applications and the surrounding platform.

The same applies to a headline benchmark win. A result becomes commercially persuasive when it maps to a service constraint the customer recognizes. Additional capacity matters most when that capacity can be used without creating another bottleneck or compromising service quality.

For Modal, the potential benefit concerns the infrastructure behind customer agents. For developers, the relevant outcome is whether their jobs complete reliably when other users are active. For enterprise buyers, the issue is whether service capacity remains predictable as usage grows.

These interests overlap, but they are not identical. An operator can gain additional room to accommodate demand without immediately changing an individual customer’s experience. A customer can also experience better responsiveness without knowing which processor supplied the improvement.

That separation prevents an easy overstatement. Nvidia winning additional CPU consideration does not establish that every AI application needs Vera. It shows that agent execution gives a cloud operator another reason to reconsider hardware that previously satisfied its requirements.

The resulting competitive demand is concrete. Established suppliers need to remain attractive on representative, occupied systems. Nvidia needs to show that its advantage survives the transition from a selected evaluation to a dependable service.

Nvidia Vera benchmarks test useful work under contention

Modal’s public Agentless Agent Bench provides an important methodological detail missing from a simple “2x faster” headline. It uses 50 selected Terminal-Bench tasks with reference solutions, removing model response time and network activity. A run counts as completed only when its verifier passes.

The Nvidia Vera benchmarks examine a defined execution workload, rather than the complete intelligence or speed of an autonomous agent.

A reference solution supplies known commands for completing a task. Removing the model’s decision process helps isolate the machine running those commands. Verification then checks whether the execution produced an acceptable result, rather than merely terminating quickly.

The repository describes both serial and concurrent tests. Serial testing runs tasks individually. Concurrent testing allows multiple tasks to compete for the machine’s resources. These approaches answer different questions, so their results should not be treated as interchangeable.

A serial result helps characterize execution without interference from competing benchmark jobs. A concurrent result examines what happens when resources must be shared. A processor can look ordinary under the first condition while becoming attractive under the second.

This is where contention enters the story. Contention occurs when active tasks compete for a shared resource, such as memory access or execution capacity. It can limit progress even when each task performs reasonably well in isolation.

The Vera vs x86 comparison therefore needs an operating condition attached. Here, x86 refers to the instruction family used by the Intel and AMD systems under discussion. The meaningful claim concerns the tested workload under load, rather than a universal ranking of instruction families.

A server operator also needs to distinguish throughput from latency, the elapsed time required to complete a task. Higher throughput is useful, but accepting unlimited delay would make the measurement commercially misleading. Capacity needs an accompanying standard for responsiveness.

Imagine a shared service completing more jobs overall while a subset of customers waits much longer. Aggregate throughput would improve, yet the service might become less suitable for interactive work. Buyers need enough detail to recognize that possibility.

The benchmark’s verification requirement addresses another concern: unfinished or incorrect executions should not inflate the result. However, passing these selected checks does not establish broader model accuracy. The reference solutions remove the very decision process that would determine an agent’s reasoning quality.

Prebuilt environments also define the scope. Preparing software before measurement reduces setup interference and helps isolate execution. It does not measure every delay a customer encounters when starting a fresh environment or acquiring dependencies.

These choices are defensible for a targeted hardware experiment. They become problematic only if the result is presented as an end-to-end measure of all agent behavior. A focused benchmark should support a focused conclusion.

The Nvidia Vera benchmarks make a useful case for further evaluation because the test design is inspectable. Reproducing the result with disclosed hardware and settings would strengthen it. Extending the experiment to actual service traffic would answer a different, equally necessary question.

Vera vs x86 includes the cost of supporting another architecture

Vera uses Arm, an instruction architecture that differs from the x86 software target behind Modal’s existing fleet. Nvidia’s Vera CPU architecture positions the processor for both standalone servers and systems paired with accelerators. This makes it a direct candidate for general execution infrastructure, not solely an accessory to a GPU purchase.

A favorable processor result must outweigh the engineering and operating work required to support another software target.

Compatibility starts with whether the required software can execute correctly. Source code portability helps, but an application also depends on its libraries, build tools, and packaged components. A successful migration must account for the entire working environment.

Container packaging does not erase this distinction. A container bundles software with its dependencies, but its executable components still need to support the underlying architecture. Moving the same package between different machines can therefore require rebuilding or replacing parts.

The work extends beyond getting a demonstration running. Operators need repeatable builds, clear failure diagnosis, and confidence that updates preserve expected behavior. Each additional supported platform expands the combinations engineers must understand.

For this reason, retaining Intel and AMD has a practical logic. Existing workloads can continue using a familiar target while compatible workloads become candidates for Vera. That approach allows adoption to follow demonstrated suitability rather than requiring a universal conversion.

It also complicates scheduling, the process that assigns work to available machines. A mixed fleet needs to send each job to hardware capable of running it. Capacity that exists on an incompatible machine cannot automatically satisfy a waiting job.

That limitation matters when demand changes. Additional Vera servers might expand capacity for one workload category while leaving another constrained. Evaluating the fleet therefore requires more than adding together all available processors.

The competitive comparison should recognize this asymmetry. Intel and AMD benefit from already supporting Modal’s installed software environment. Nvidia must offer enough value to justify work that the existing choices do not require.

At the same time, compatibility is not a permanent verdict against another architecture. Engineering investment can become worthwhile when repeated operating benefits exceed its ongoing burden. The threshold depends on workload volume, software portability, and the operator’s ability to maintain support.

This is why Vera vs x86 should remain a purchasing analysis rather than an architecture loyalty contest. An instruction family does not determine every outcome. Processor design, memory configuration, software, and deployment conditions all influence the result.

The presence of another Arm-based alternative would not, by itself, reproduce Vera’s behavior either. Sharing an instruction architecture establishes a compatibility relationship, not identical performance. Buyers still need measurements from the actual systems they intend to operate.

For developers documenting migration decisions, a searchable knowledge base can preserve test conditions and compatibility findings. That record helps distinguish an observed hardware benefit from assumptions introduced during deployment planning.

Modal’s move gives Nvidia an opening because the company is willing to examine those tradeoffs. It leaves Intel and AMD with a continuing role because suitable hardware must satisfy software requirements as well as performance goals.

The 2x result leaves important purchasing questions open

Tom’s Hardware’s processor adoption coverage reports that Modal will retain AMD and Intel CPUs. It also notes gaps in configuration details and energy comparisons. Those limits matter when translating an internal test into a broader purchasing recommendation.

The available evidence supports a workload-specific opportunity, while leaving a universal performance or efficiency ranking unestablished.

The secondary headline groups Intel and AMD together, but Modal’s clearest numerical statement identifies an Intel comparison under concurrent load. Readers should not silently convert that result into an identical advantage against every AMD processor.

Nor does “equivalent” explain the entire comparison. Buyers need to know what equivalence means: comparable processor resources, similar system capacity, or another selected constraint. Different definitions can produce different interpretations of the same measured result.

Memory deserves particular attention. Memory bandwidth measures how much data can move through the memory system over time. If a workload repeatedly waits for data, greater execution capacity alone may not resolve its limiting factor.

That observation supplies a plausible evaluation question, rather than proof of Vera’s precise advantage. Attributing a result to memory requires evidence that separates memory behavior from other system differences. A throughput chart alone cannot establish the full causal explanation.

Energy efficiency requires its own measurement. A machine completing more work might also consume more electricity. Conversely, it might finish useful work with less energy overall. Neither conclusion follows automatically from throughput without corresponding power data and a defined measurement period.

Commercial efficiency is broader still. Operators must consider acquisition, deployment, support, and utilization alongside electricity. No disclosed result establishes that customers will receive a matching reduction in service charges.

Reliability also belongs in the comparison. Faster completion during a controlled run does not describe maintenance behavior, failure recovery, or consistency across a larger deployment. These factors can affect how much measured capacity becomes dependable customer capacity.

There is a methodological tension around removing network and model delays. Doing so makes the processor comparison cleaner. It also limits how directly the result predicts an agent’s total completion time.

An application dominated by remote responses has less time available for CPU improvements to save. An application dominated by local execution has a stronger reason to investigate the result. The same hardware finding can therefore matter differently across customers.

This does not invalidate the benchmark. Isolating a component is a normal way to understand its contribution. The mistake would be applying the component’s measured gain to the entire application without measuring the application itself.

Competitive generations create another moving target. A deployment decision should compare systems available on relevant delivery schedules. A result against one installed machine does not settle the outcome against later products from the same supplier.

The skeptical conclusion is specific: Modal has supplied a credible reason to test Vera for concurrent execution, but public evidence does not settle every buying criterion. That is enough to make the adoption news meaningful without treating it as a marketwide verdict.

Watch deployment, independent replication, and competitor responses

The next evidence should connect the reported execution gain to available capacity, reproducible measurements, and current purchasing alternatives.

First, watch for a defined Modal rollout. A support announcement should clarify which workloads can use Vera, where capacity becomes available, and what compatibility requirements apply. Those details would show how the evaluation becomes a customer service.

The strongest adoption signal would be ordinary workloads running successfully through the same operational processes customers already depend on. A narrowly scoped preview would still represent progress, but it would support a narrower conclusion about readiness and scale.

Availability alone would not establish that the throughput advantage persists. Useful follow-up evidence would describe behavior during representative demand, including completion times and failed executions. That would connect the hardware finding to outcomes customers can recognize.

Second, watch for independent reproduction with clear configurations. Another evaluator should disclose the machines, software settings, workload selection, and completion rules. Repeating a headline number without those conditions would add visibility while contributing little verification.

Replication would strengthen the case if the advantage survives reasonable changes in test conditions. A smaller gain would still be informative. It would help buyers identify where the original result travels and where it depends on a particular setup.

Production measurements would add another layer. A benchmark removes distractions to isolate a question; a service must operate with those distractions present. Both forms of evidence matter, but they should retain their separate purposes.

Third, watch how Intel and AMD answer the purchasing question. The relevant response is performance on comparable agent execution workloads, using systems buyers can actually obtain. A different benchmark victory would offer context without directly resolving Modal’s finding.

Competitive testing should also preserve the distinction between an individual job and a busy host. Faster isolated execution may be valuable, yet it does not automatically answer a capacity problem. Equally, greater aggregate capacity needs an acceptable response-time profile.

Over the coming months, these signals will either broaden or narrow the significance of Modal’s decision. A clear rollout and independent confirmation would strengthen Nvidia’s case. Persistent compatibility restrictions or workload-specific results would limit its reach without erasing the initial finding.

For readers evaluating AI infrastructure, start with the part of the workflow that consumes time. Ask providers to distinguish model delays, software execution, and waiting for shared capacity. Keep the tested workload and hardware configuration beside every performance claim. When Modal taps Nvidia Vera CPUs, the actionable question is how that choice affects useful work on the service you use. Follow the rollout, inspect reproducible results, and compare current alternatives before treating a throughput ratio as a general buying rule. What matters for your application: faster individual execution, more concurrent jobs, or more consistent completion when the platform is busy?