A new infrastructure test has put NVIDIA’s Vera central processing unit (CPU) into focus for a part of AI computing that receives less attention than graphics processors: the work required to run AI agents, execute tools, manage sandboxes, and coordinate long-running tasks. On October 19, 2026, Reuters reported that cloud-computing company Modal plans to use NVIDIA Vera CPUs for hosting AI agents after early tests showed up to twice the task throughput of the Intel and AMD systems used in its comparison.

The result is worth watching, but it needs careful framing. It is an early, company-reported benchmark—not an independent finding that Vera is twice as fast for every AI workload. Modal plans to operate a mixed fleet of processors rather than abandon Intel and AMD, and the report does not establish that every customer can already request Vera-powered infrastructure.

What happened on October 19?

Modal provides cloud computing infrastructure for developers, including environments used to run code and AI workloads. According to Reuters, the company said it intends to begin using NVIDIA’s Vera CPU to host agents. Until this move, Modal had used Intel and AMD processors for that category of work.

Modal said early tests showed Vera could double the amount of work AI agents complete compared with the Intel and AMD chips tested. The result prompted Modal to support NVIDIA’s processor design, a move that will require substantial software changes on Modal’s side. Reuters also reported that Modal intends to keep Intel and AMD systems in its fleet and place jobs on the hardware that performs best for them.

That last detail matters. The announcement is not a declaration that one CPU has won every benchmark or that existing infrastructure is being replaced. It is a deployment decision based on a particular set of tests and workloads. The company’s next steps will show how the results translate from an early test environment into a production service.

News date: October 19, 2026.
Availability status: Modal said it plans to start using Vera for agent hosting. The Reuters report did not give a general customer launch date or confirm that Vera-backed capacity is already available to every Modal user.

Why AI agents need CPUs as well as GPUs

AI infrastructure is often discussed in terms of GPUs, which are central to training and running many large AI models. But an AI agent does more than generate text. It may plan a task, call a tool, execute code, inspect files, search a repository, run tests, evaluate the result, and then decide what to do next.

Much of that supporting work can involve the CPU. A service may need to start an isolated execution environment, coordinate processes, manage memory and data movement, run language runtimes, compile code, handle network requests, or keep multiple independent tasks moving at once. If those steps become a bottleneck, adding more model-serving capacity does not automatically make the full workflow faster.

The balance depends on the task. A workflow dominated by model inference may be constrained mainly by accelerators, model size, memory bandwidth, or network latency. A coding agent that repeatedly starts processes, searches files, compiles code, and runs tests can place a different mix of demands on the system. The CPU matters because the agent’s total completion time includes the work around the model, not just the model’s generated tokens.

This is why a processor designed for agentic workloads is a meaningful infrastructure development. It does not mean that Vera replaces GPUs or that every AI application needs a dedicated Vera server. It means CPU architecture and memory behavior may influence how efficiently a cloud provider can run many concurrent agent tasks.

For background on the broader infrastructure trade-off, see our Microsoft Maia 300 explained article, which examines a different approach: a custom accelerator aimed at AI inference and cloud-scale workloads.

What does “twice the work” actually mean?

The headline claim is about throughput: how much work a system completes over a period of time. Throughput is not the same as the latency of a single request. A processor might complete more total tasks when many jobs run concurrently without making every individual task take half as long.

That distinction is especially important for AI agents. An agent task may contain a sequence of CPU operations, model calls, file operations, and waits for external tools. A benchmark that measures how many tasks finish under concurrent load answers a different question from one that measures the time required to finish one isolated task.

The Reuters report summarizes Modal’s result as twice the amount of work AI agents can get done. It does not provide enough detail on its own to establish a universal two-times improvement across all agent types, programming languages, models, concurrency levels, or production configurations. Readers should therefore treat the figure as an early reported result for the tested setup.

Before applying the number to a real service, developers should ask:

  • Were the compared systems tested with the same task mix and software configuration?
  • Was the result measured on one task at a time or under concurrent load?
  • Were task completions validated for correctness, rather than counted simply because a process ended?
  • What happened to individual-task latency as concurrency increased?
  • How did memory capacity, memory bandwidth, software maturity, and system configuration affect the result?
  • What was the cost per completed task, including hosting and operational overhead?

Those questions do not invalidate the report. They define what is needed to turn a promising benchmark into a reliable purchasing or architecture decision.

Why NVIDIA Vera is relevant to agentic computing

NVIDIA has positioned Vera as a CPU built for the workloads that support agentic AI, reinforcement learning, data processing, and large-scale infrastructure. In its official technical announcements, the company describes a design with 88 custom Olympus CPU cores and memory bandwidth of up to 1.2 TB/s. NVIDIA has also published performance claims for selected workloads, which should be read as vendor claims tied to the configurations and comparisons it describes.

A CPU can influence agent infrastructure through several connected factors. Core count affects how much work can run in parallel, but core count alone does not determine performance. Memory bandwidth can matter when many processes compete for data access. Per-core performance influences work that cannot be parallelized easily. Software support, runtime behavior, and the efficiency of container or sandbox orchestration also affect how many useful tasks a service can finish.

Modal’s reported results are interesting because they concern a practical service workload rather than a generic claim about processor specifications. Still, the available report does not establish that memory bandwidth alone caused the measured improvement. A fair explanation should distinguish NVIDIA’s published architecture details from Modal’s early comparison and avoid attributing the entire result to one feature without evidence.

NVIDIA’s broader Vera announcement and its later update on system deliveries provide background on the product and its intended role. They are useful context, but they are not independent verification of Modal’s specific benchmark.

Why Modal is keeping Intel and AMD

Modal’s plan to use a mixed hardware fleet is an important part of the story. Cloud providers operate varied workloads, and the best processor for one job may not be the best choice for another. Some tasks benefit from high parallel throughput; others are more sensitive to single-task latency, compatibility, memory requirements, or software maturity.

Reuters reported that Modal tested Vera against Intel and AMD processors already on the market. The company also acknowledged that those competitors are developing newer models that could narrow the difference. Modal’s stated approach is to evaluate hardware as it becomes available and use whichever option performs best for a particular job.

That is a more useful signal than treating the test as a final ranking of processor vendors. It suggests that AI infrastructure may increasingly be optimized around workload-specific placement: the system chooses hardware based on the characteristics of a task rather than running every job on one uniform processor platform.

For developers, this also means that hardware labels are not enough to predict performance. A production decision should account for the actual runtime, concurrency, supported architecture, dependency compatibility, observability, and total cost. A faster processor that requires extensive changes to build systems or deployment workflows may have a different operational trade-off from a system that can be adopted with minimal changes.

What this could mean for coding agents and developer tools

Coding agents are a natural workload to watch because they often combine model reasoning with repeated interactions with a development environment. An agent may inspect a repository, search for symbols, edit a file, run a test suite, interpret failures, and repeat the process. Each step can involve different proportions of model inference, CPU execution, storage access, and network activity.

If a provider can run more sandboxed tasks on a host while maintaining acceptable latency and isolation, it may be able to improve capacity for these workflows. Potential benefits could include more concurrent jobs, shorter queues during busy periods, or more efficient use of infrastructure. Those are plausible implications, not confirmed customer outcomes from the October 19 report.

The same principle applies to agents used for data analysis, browser automation, research, and reinforcement learning. They can create many small operations around model calls, and their resource profiles can vary significantly. An improvement on a benchmark that resembles the production workload is more informative than a general processor specification—but developers still need to validate it on their own tasks.

Our guide to running DeepSeek locally on two DGX Spark systems covers a different part of the stack: serving a model on specialized hardware. Together, the two topics illustrate why AI performance depends on both the model-serving path and the infrastructure that surrounds it.

What has not been confirmed

The announcement should not be interpreted as proof of several broader claims.

It does not mean every AI agent will run twice as fast. The reported improvement applies to Modal’s early tests and the systems compared. Different workloads can produce different results.

It does not mean individual tasks take half the time. Throughput and latency are distinct metrics. The report’s headline describes more work completed, not a universal reduction in end-to-end task duration.

It does not establish public availability for every Modal customer. Modal said it plans to start using Vera and that software changes are required. The report did not provide a general availability date, pricing, region list, or customer-facing configuration details.

It does not show that Intel and AMD are being removed. Modal said it intends to keep using those processors in a mixed fleet, and newer competing systems may change the comparison.

It does not prove lower prices or lower energy use for customers. More throughput can improve economics under some conditions, but the final result depends on acquisition costs, power, utilization, workload scheduling, software engineering, and service pricing. The report does not provide enough information to calculate a cost-per-task advantage.

These limits are central to responsible technology reporting. A benchmark can be newsworthy without proving every possible benefit that might follow from it.

How developers should evaluate the claim

Teams choosing infrastructure for coding agents or other long-running workflows should test their own representative tasks. Begin by defining what successful completion means: for example, a test suite passes, a repository search returns the expected result, or an agent completes a controlled sequence of tool calls. Then compare systems using the same workload and correctness criteria.

Measure at least four dimensions. First, measure throughput: how many validated tasks finish during a fixed interval. Second, measure end-to-end latency for an individual task. Third, record reliability, including failed jobs, retries, timeouts, and output correctness. Fourth, calculate cost per successful task, including the resources and operational work required to run it.

Run tests at several concurrency levels, not just on an idle machine. Record the CPU architecture, memory configuration, software versions, container image, task dataset, and any changes needed to support a new architecture. If tasks run in isolated sandboxes, also measure startup time and verify that isolation and permissions remain correct.

For agent applications, include the full workflow rather than timing only one CPU-bound step. A faster sandbox may not materially improve the total user experience if most time is spent waiting for model responses or external services. Conversely, a CPU bottleneck may become much more visible as a provider increases concurrency. The goal is to identify the limiting stage rather than assuming a processor benchmark translates directly into application speed.

Our AI agent reliability checklist provides a complementary framework for evaluating whether an agent completes tasks correctly, not merely quickly. For systems that call hosted models and tools repeatedly, our guide to controlling AI agent API usage, budgets, and rate limits covers another important part of the total operating cost.

What to watch next

The most useful follow-up evidence will be a detailed Modal engineering post describing the benchmark methodology, the task mix, the exact processors and configurations tested, and how successful completion was verified. It will also be important to learn when Vera-backed Modal capacity reaches customers and whether the company publishes service-level performance or pricing information.

Independent tests would help establish whether the advantage persists across different agent frameworks, coding tasks, concurrency levels, and software environments. Results from newer Intel and AMD systems will also matter because the October 19 comparison used processors already available to Modal at the time of testing.

For customers, the practical questions are straightforward: Can the service run the required workloads? Is it available in the needed environment? Does it reduce queue time or improve completion rates? Does it maintain reliability and security? And does the improvement justify any difference in cost or integration effort?

Sources

Bottom line

Modal’s plan to adopt NVIDIA Vera for AI-agent hosting is a meaningful infrastructure development because it highlights the CPU work behind agentic systems. The reported two-times throughput result is promising, but it remains an early company-reported benchmark, not a universal performance guarantee. The next decisive evidence will be transparent methodology, production availability, independent comparisons, and measurements of latency, reliability, and cost on real agent workloads.