Fifty Gigawatts and a Voice From a Prompt

SemiAnalysis, a research firm that sells datacenter and semiconductor data models, has published a forecast that about 50 GW of new datacenter capacity will come online worldwide in 2027. By its own comparison, that roughly equals the entire global datacenter stock built through 2024, added in one year. The post responds directly to Brad Gerstner of the investment firm Altimeter. On the All-In Podcast, Gerstner showed SemiAnalysis's earlier figure of +43 GW for 2027, called it "too aggressive," and said his "hunch" was about 25 GW. The post doesn't explain the move from 43 GW to roughly 50 GW. The headline uses the larger number.

A caveat applies throughout. Most of the evidence comes from SemiAnalysis's own paid products, including its Datacenter Industry Model, Industrials Model and Energy Model. Outsiders can't check the underlying data. The section on whether all this capacity leads to oversupply is behind a paywall.

Why skeptics doubt it

Evidence 1: buildings that are nearly finished

The most concrete evidence is physical. SemiAnalysis says more than 24 GW of capacity across just 40 campuses is in an advanced stage of construction and due in 2027. Most of these sites are past the halfway point, with outdoor cooling and electrical equipment already installed. It says those 40 are a small fraction of the "multiple hundred" advanced-stage sites it tracks. It also points to giant sites that were delivered, such as Crusoe's in Abilene, AWS's in Indiana, and QTS/Microsoft's in Georgia. It credits these sites with training frontier models it names as GPT-6 and Fable 5.5.

Evidence 2: leading indicators

Two indicators move ahead of completions.

The headline figure is that more than $1 trillion of binding, non-cancellable lease value has been signed in 2026 so far. SemiAnalysis says most of the debt backed by these leases has already been raised. As an illustrative check of our own, not one from the article: at $30–50B per GW, $1T works out to roughly 20–33 GW of contracted capacity. That fits a build that lands across 2027–28.

How you build 50 GW in a year

Big equipment orders are already flowing to suppliers such as Vertiv, ABB and Sterling Infrastructure. The hard part now is turning orders into finished buildings, and the article describes three responses.

Building outside the US. Building abroad avoids US limits on labor and power, and in some countries permitting. SemiAnalysis shows ex-US construction accelerating sharply in 2027 and expects it to gain a lot of market share in 2028.

What follows, and what's left open

The author expects much more compute supply. In his view that means cheaper and smarter AI, faster model progress, a revenue jump for the leading labs, "unthinkable" capital spending, and upward pressure on interest rates as the buildout competes for capital. He also suggests datacenters and power may stop being the binding constraint. Pointing to the firm's earlier "Great Silicon Shortage" analysis, he argues that memory and logic chips could become the main bottleneck in 2027–28. If so, some of the new buildings could wait for chips, which is the oversupply question the paywalled section takes up.

Three questions are left open. The data can't be verified independently. "Broadly solved" power isn't backed with numbers in the free text. And the 43 GW versus 50 GW figures aren't reconciled.

• Gemini 3.8 Flash TTS is built for creative direction: designing new voices and directing performances line by line.
• Gemini 3.8 Flash-Lite TTS is the cheaper tier, for high-volume dubbing, content production and expressive voice agents.

The post is a product announcement. It is detailed about features and light on evidence.

What problem this addresses

Developers building with TTS usually hit the same limit: a fixed menu of voices with a few knobs for speed and pitch. Gemini 3.1 Flash TTS offered 30 voices. That's enough for a voice assistant but too few for a game with dozens of characters, or for a dubbing pipeline that needs a voice to fit a regional audience. Expressive delivery is the harder part. The way a line is read depends on context: sarcasm, a whisper in a suspense scene, a listener saying "mhm" while someone else talks. Older systems either can't express these or need hand-written markup.

Google's answer is the approach LLMs brought to text: describe what you want in natural language.

Getting a voice

Flash TTS offers four routes:

1. Generative voice design. You write a prompt describing role, accent and voice characteristics, in any of more than 100 languages and dialects. Google's examples range from "a dramatic, fire-breathing dragon" to a narrator with a regional cadence.
2. A library of 2,000+ production-ready voices. It includes regional varieties such as Mexican Spanish, Quebec French and Scots English.
3. Voice replication. This builds a consistent voice profile from a 30-second sample of your own voice, or of a voice you have the rights to use.
4. Save and scale. Designed voices can be saved and reused across projects with "minimal drift," meaning the voice shouldn't gradually change from session to session.

A fifth feature, voice remixing, isn't out yet. It would let you take a library voice and adjust timbre, pitch, pace and accent with prompts such as "add subtle Southern US accent."

Directing the performance

Both models accept performance direction, in two ways. You can write explicit stage directions for each line, or let the model infer delivery from cues in the script. Google's examples run from "a calm customer service agent" to "a whispered suspense scene."

Further capabilities:

Here is how a script might look, as an illustration: a narrator line with the direction "hushed, slow," then Speaker B replying <gasp> You heard that too?, then Speaker A answering |mhm| before continuing. The post shows the tag syntax but doesn't publish a full API schema, so check the docs for the exact format.

The evidence

Every quantitative claim comes from external leaderboards, not from Google's own evaluations:

Third-party rankings, and especially blind human preference, are more credible than a lab grading itself. Still, the post leaves out:

• the runner-up scores or the margins, so a lead of 71.4 over 70 can't be told apart from 71.4 over 50
• which competitor models were included
• what the Hume scales measure or how they are built
• confidence intervals, or how many votes the arena rankings rest on
• why only those six languages are named; it may be that the models aren't top-ranked in others, such as English

Google also says the models show "major improvements" over Gemini 3.1 Flash TTS on long-form content and two-speaker control, but gives no number.

Practitioners will also notice that there are no latency figures, no time-to-first-audio, no streaming details and no pricing. For voice agents, latency usually decides whether a model is usable. And the whole point of Flash-Lite is cost, yet the post never quantifies that saving. There is nothing on architecture or training either.

Safeguards

Voice cloning raises obvious risks of impersonation and fraud. Google describes three layers of protection:

Watermarks only help if somebody checks for them. And metadata like C2PA is easily stripped when audio is re-encoded or re-recorded, which is a general limit of these methods rather than something the post addresses. The model card has more detail.

How to read it

The main change is in how you interact with the model. Voice selection and delivery both become prompt-driven, and a small catalog becomes something close to unlimited. The leaderboard results suggest the quality is competitive. But without margins, latency or prices, the post doesn't give enough to choose a production TTS provider. Developers should run their own blind comparisons against current vendors in their target languages before switching.

The practical change is where the coordination lives. One Triton model instance of type KIND_MODEL can now own several GPUs. It creates a TensorRT execution context, a CUDA stream and an NCCL communicator for each GPU (each "rank"), then launches all ranks together for every request. The application calls one named model over gRPC and never manages ranks.

The problem being solved

Generative models increasingly need more compute or memory than one GPU offers. Splitting a request across GPUs lowers its latency, but it usually forces the serving application to handle rank startup, communicator lifecycles and synchronization. NVIDIA's pitch is that this code can now leave the client, and the multi-GPU engine can be packaged as an ordinary versioned Triton model.

One limit matters. The parallelism must be compiled into the TensorRT plan before deployment. Triton's configuration activates a distributed plan; it does not turn a single-device engine into a distributed one. In the eight-GPU config, the instance group is { kind: KIND_MODEL count: 1 } and two parameters are set: enable_multi_device: "true" and multi_device_gpus: "0,1,2,3,4,5,6,7". The single-GPU baseline uses a normal instance pinned to GPU 0.

The workload: Cosmos 3 Nano video

The demo uses Cosmos 3 Nano, an NVIDIA video generation model featured in an earlier NVIDIA post on TensorRT multi-device inference. The work is split in two:

• Hugging Face Diffusers still runs on the client. It handles prompts, latents, classifier-free guidance (CFG), the scheduler, VAE decoding (turning latents back into pixels) and frame postprocessing.
• Dynamo-Triton serves only the 36-layer denoising transformer.

The split follows the cost. On one GPU, the transformer takes 93.4% of generation time. Generation uses 35 denoising steps. CFG needs two transformer predictions per step, one unconditional and one conditioned on the prompt, and the Diffusers client sends them as two sequential calls. That makes 70 transformer calls per video. Each call sends prepared tensors and gets back noise_patches. The article doesn't say why the two CFG predictions aren't batched into one call.

This configuration produces 44,160 video tokens plus a 2,992-token text sequence. The engine uses Ulysses context parallelism, a scheme first published as DeepSpeed-Ulysses that splits long sequences across GPUs.

At context-parallel size 8 (CP8), each rank holds 5,520 video tokens, one eighth of the sequence. Most of a transformer layer works on each token independently, so the MLPs and projections run on that shard with no communication. The shorter text path is copied to every rank rather than split.

An illustrative analogy: eight readers each hold one chapter of a book. To check cross-references, they swap pages so each reader holds the whole book but checks only one kind of reference. Then they swap back to their own chapters.

The engine was exported from PyTorch and compiled with Torch-TensorRT. Three custom converters map placeholder operations to TensorRT's public collective layers: reduce-scatter, all-to-all and all-gather. Each context-parallel plan contains 2 reduce-scatters at the start, 3 all-to-alls in each of the 36 layers (108 total), and 1 all-gather at the end. The attention itself uses standard attention with these collectives around it, not TensorRT's separate multi-device attention operator. The article doesn't say what each of the three per-layer all-to-alls carries.

Benchmark setup and results

All variants ran on the same eight-GPU NVIDIA system. The article doesn't name the GPU model or interconnect. Each run produced a 1280×720 clip of 189 frames at 24 FPS with 35 steps. The timings cover prompt work, the 70 Triton calls, CFG and scheduler updates, VAE decode and postprocessing. Model loading and mp4 encoding are excluded. Each figure is the mean of five full generations after one warm-up.

Two effects are visible:

• Communication overhead. The transformer calls themselves reach 6.09× on eight GPUs, about 76% of linear scaling by my calculation. The collectives cost more as the number of ranks grows.
• Fixed overhead (Amdahl's law). Work outside the transformer calls stays at 10.2–10.5 seconds in every configuration. As transformer time shrinks, that fixed part grows in share. End-to-end speedup is 4.58×, roughly 57% of linear. My extrapolation: with about 10.4 seconds that never shrinks, no number of GPUs could push end-to-end time below about 10 seconds.

Checking output quality

• CP2 and CP4 scored MAE 12.759 and PSNR 21.111 dB.
• CP8 scored MAE 16.316 and PSNR 19.400 dB.

The outputs are explicitly not pixel-identical. Splitting the work changes the order of floating-point operations, and the differences grow over 35 steps. The sampled frames show the same scene in every run: a robot arm cleaning a plate. A PSNR around 19–21 dB is a loose match, so "same scene" is the honest claim, not "same video."

Trade-offs and open questions

NVIDIA frames this as trading GPUs for latency. A clip that took more than two and a half minutes now takes about 34 seconds. The cost is efficiency. By my arithmetic, CP8 uses about 273 GPU-seconds per video against about 157 for one GPU, roughly 1.75× the compute per result. On a busy service, eight single-GPU replicas would likely produce more videos per hour.

The article says plainly that it did not measure concurrent throughput, cost per video, or total cost of ownership, and tells teams to test against their own latency targets. Also untested: other parallelism strategies such as tensor parallelism or ring attention, batching the two CFG calls, and what happens across nodes rather than within one eight-GPU box. The case for this feature is interactive tools where a person waits for each result.

OpenAI has published a policy document on how it wants independent organizations to assess its safety work. It names four priority areas for assessment and seven principles for how assessments should run. The scope is private and nonprofit assessors doing technical safety work. OpenAI says work with governments is separate and may follow different rules. The document is a proposal, not a set of results. OpenAI says it is "in conversation with multiple third parties" about engagements that fit these priorities.

The problem it's addressing

A frontier lab's safety story usually depends on its own evaluations, its own safeguards and its own reading of the results. Outside evaluators have tended to get short windows before a launch, limited access, and little say over what they test. OpenAI frames the new work differently. It is meant to be "launch-agnostic", run over weeks to months, and aimed at testing specific safety claims in depth instead of approving a release.

Four priority areas

2. Safeguards. OpenAI lists four layers of protection: model-level safeguards, enforcement safeguards, security safeguards, and misalignment monitors. The questions it proposes include:

OpenAI notes that standards for internal deployment, meaning models used inside the lab, are "still nascent". That is a notable admission, because internal use is where a highly capable model might first act without anyone outside seeing it.

4. Misalignment incidents. These are cases where a model acts without authorization or evades oversight. OpenAI points to "the OpenAI Hugging Face incident" as a case where it brought in an outside investigator. The article doesn't describe what happened. Investigators would need cyber-forensics skills, alignment expertise, and the ability to analyze chain of thought at scale. They would answer two questions: what happened and why, and whether the fixes would prevent it happening again. Their findings would then feed back into the model's safety case.

Seven principles

• Pre-registered scope. Claims are agreed and written down before work starts. Each claim is labeled as either one the lab puts forward or one the assessor chose and the lab agreed to. There should be a process for serious risks found outside the agreed scope. Final reports must say what was not assessed.
• Proportionate access. Access should be within legal, security and IP limits. Where direct access isn't practical, assessors can work through a company representative or privacy-preserving mechanisms.
• Transparent methodology. Reports should separate findings from interpretation and state their uncertainty. Assessors should justify their criteria where no standard exists.
• Expertise and independence. Assessors disclose conflicts of interest, including financial ties, relationships with the developer, and prior work on the system being assessed. Recusal or exclusion periods help keep payment from shaping findings.
• Security and confidentiality. Where an assessor's own environment isn't secure enough, work may happen on company-managed devices or premises.
• Actionable findings and time to remediate. Labs get "a reasonable period" to fix problems before publication.
• Responsible publication. Reports should be as open as possible. Labs can request redactions, and assessors keep editorial control and may note where substantive redactions were made and how they affect the report. Where public release isn't possible, results can go confidentially to bodies such as company boards.

Reading it critically

Some parts of the document point toward real accountability. Pre-registering claims stops a lab from choosing, after the fact, which results count. Allowing assessors to propose their own claims, and to flag redactions, gives them some leverage. Explicitly scoping in internal deployment and monitors that "cannot easily be disabled" goes beyond typical pre-launch red teaming.

The safeguards in the other direction are just as visible. The lab must agree to the scope. Access is bounded by IP and security. The lab gets time to fix problems before publication and can request redactions. Some findings may go only to the company's own board. Each condition is reasonable on its own. Together they mean the lab still controls much of what the public eventually sees. Nothing in the document says who decides when a "reasonable period" has run out, or what happens if lab and assessor disagree about a redaction.

The open questions are practical ones: which organizations OpenAI will work with, who pays them, and whether published reports will include negative findings. OpenAI says it wants these principles written into "shared international standards" through laws and private governance bodies. The first reports will show how much these principles change in practice.

The problem: fast kernels, slow plumbing

In ROS 2, nodes exchange typed messages over topics. Usually a message's payload is serialized and copied through CPU memory on its way from one node to the next. Suppose a perception node runs on the GPU and its downstream consumer also runs on the GPU. Each hop still copies the frame from device to host, serializes it, deserializes it, and copies it back to the device. The article's argument is that "a fast CUDA kernel alone does not guarantee a fast ROS 2 graph."

NVIDIA contributed a CUDA buffer backend built on CUDA Virtual Memory Management, the CUDA API for reserving and mapping GPU memory explicitly. When a publisher and a subscriber both meet its requirements, the payload moves between them with no serialization and no host copies. The requirements are:

The worked example: Depth Anything 3

1. converts the incoming ROS image into an OpenCV matrix
2. runs depth inference on the GPU
3. converts the resulting cv::Mat back into a ROS image
4. publishes a 32-bit float depth image

So the GPU-native model is wrapped in CPU-side boundaries: two payload-sized host transfers, a host allocation, and serialization.

What the skill makes the agent do

The skill is not a template and does not rewrite code automatically. It directs the agent to:

The resulting patch

Most of the edits adapt the TensorRT wrapper so it accepts CUDA buffer handles while keeping its existing API. On the ROS side the change amounts to:

• one subscription option, acceptable_buffer_backends = "cuda"
• one allocate_buffer() call, which gives the outgoing Image.data CUDA-backed storage
• two stream-aware handle extractions: from_input_buffer(), which uses CUDA input directly and promotes CPU input when needed, and from_output_buffer(), which provides a write handle
• one ordinary publish()

The model's postprocessing writes the depth result straight into the outgoing message's GPU buffer. That avoids a device-to-host copy and an intermediate device-to-device copy.

One detail is easy to get wrong. The handles live in an inner scope. Closing that scope releases the write handle, which records a CUDA event after the GPU work is enqueued, so subscribers cannot read the buffer before the write finishes. The message type stays sensor_msgs/msg/Image. There is no custom message, no duplicate GPU-only topic, and no separate CPU and GPU publisher branches.

Optional CPU consumers inside the node, point-cloud construction and debug visualization, are deliberately left alone. When enabled, they still copy to the host. The migration keeps them as explicit side paths so they don't complicate the main publication path.

Building and verifying

The backends ship as ROS 2 plugins in the ros2/rosidl_buffer_backends repository. You build cuda_buffer_backend with colcon (ROS's build tool) in the same workspace, source it, and set the RMW. Core ROS 2 does not need rebuilding.

Verification has three layers:

What's missing

The tutorial reports no latency or throughput numbers. It tells readers to "record comparable latency measurements before and after," but doesn't publish its own. It also says nothing about how reliably the agent completes the skill, which agent or model was used, or how much human correction was needed. The only result shown is that the depth output looks unchanged (Figure 3).

The zero-copy path also has tight limits. Both nodes must share a host, a GPU and a Linux user, so it does not help across machines or containers running as different users. And any CPU consumer on the topic still forces the fallback path.

The broader lesson

For people building with agents, the interesting part is the shape of the skill rather than the robotics. It is investigative first: trace the data and audit before editing. It asks for a minimal, contract-preserving diff. And it requires checking the result against ground truth (profiler traces, the negotiated backend, tests over both CPU and GPU paths) instead of trusting the patch. NVIDIA says the same workflow applies to any CUDA-accelerated ROS 2 node with variable-length primitive fields.