Sam: OpenAI and Broadcom just unveiled Jalapeño, a custom chip designed specifically for large language model inference. This is OpenAI's first serious move into custom silicon, and it matters because inference — not training — is where the real cost pressure lives when you're serving hundreds of millions of API calls a day. They're targeting scale deployment by late 2026, and if the economics work, this reshapes what it costs to run frontier models in production.

Priya: Welcome to AI Revolution for Wednesday, June 24th, 2026. I'm Priya Nair.

Sam: And I'm Sam Kim.

Priya: We've got a packed show today. Beyond that Jalapeño chip, we're covering Cursor announcing its own in-house trained model plus a Git platform, Anthropic embedding Claude directly into Slack with some striking internal productivity numbers, Princeton researchers using AI to design radio chips that human engineers couldn't conceive of, ByteDance pushing past the 30-second barrier in video generation, Microsoft making Kubernetes a first-class AI infrastructure platform, Oracle restructuring its entire workforce to fund AI data centers, and a really useful framework for understanding why language models behave the way they do. Let's get into it.

Sam: So, Jalapeño. The context here is important. When you're running inference at OpenAI's scale — we're talking billions of tokens per day across ChatGPT, the API, all the enterprise customers — your cost structure is dominated by the GPU hours required to serve those requests. NVIDIA H100s and B200s are incredible chips, but they're general-purpose accelerators. They're designed to be good at everything: training, inference, different model architectures, different precision formats. That generality is a tax you pay on every single forward pass.

Priya: And when you know exactly what workload you're running — which OpenAI does, because it's their own models — you can strip away that generality and build something purpose-fit.

Sam: Exactly. A custom inference ASIC can optimize the memory hierarchy, the interconnect bandwidth, the compute-to-memory ratio, all of it, specifically for transformer inference patterns. You know the attention head dimensions, you know the KV cache access patterns, you know the batch sizes you're targeting. Google proved this works with TPUs years ago. The question was always whether OpenAI would follow that path or stay on NVIDIA.

Priya: The Broadcom partnership is the interesting part to me. Broadcom has been quietly building a custom silicon business, working with Google on TPUs, with Meta on their training chips. They have the design expertise and the fab relationships. OpenAI brings the workload knowledge. It's a sensible pairing.

Sam: The competitive implication is real too. If Jalapeño delivers, say, a two to three X improvement in inference cost per token — which is plausible for a workload-specific ASIC — that gives OpenAI room to either cut API prices or improve margins, or both. That's a structural advantage that's hard to match unless you're also building custom silicon.

Priya: Which Google already does and Meta is working on. So we're heading toward a world where every frontier lab either builds its own chips or is at a cost disadvantage. That's a high barrier to entry.

Sam: Next up — Cursor made some big announcements. They've trained their own model in-house, launched a Git platform, and announced a mobile app.

Priya: The model is the headline. Up until now, Cursor has been — let's be direct — a very good product layer on top of frontier models from Anthropic, OpenAI, and others. They've done excellent work on context management, on how they chunk and retrieve relevant code, on the UX of AI-assisted editing. But the core intelligence was rented.

Sam: Training your own model changes the optimization surface completely. When you control the model, you can fine-tune on coding-specific data distributions, you can optimize the architecture for the latency requirements of real-time code completion, you can build in awareness of your own product's context window management. You're not constrained by whatever the general-purpose API gives you.

Priya: The Git platform announcement is what caught my eye, because it signals strategic intent. If you own the editor, the AI model, and the version control layer, you own the entire inner loop of software development. That's a very different business than a code completion plugin.

Sam: It's vertical integration in the developer tools stack. Whether that's good for developers long-term — in terms of lock-in and interoperability — is an open question. But the product logic is clear.

Priya: Now, Anthropic's Claude Tag announcement pairs interestingly with the Cursor story. Claude Tag lets teams mention @Claude in any Slack channel and delegate tasks to it. It's available in beta for Enterprise and Team tiers. And the number that jumped out: Anthropic says Claude already generates 65 percent of the code written by their own product team.

Sam: That's a specific, concrete figure, and it's worth unpacking. Sixty-five percent of code generated doesn't mean 65 percent of engineering work automated. There's still the specification, the review, the architecture decisions, the debugging of subtle interaction effects. But it does mean the mechanical act of translating intent into syntactically correct, contextually appropriate code — that part is mostly handled by the model.

Priya: The Slack-native approach is the architectural choice worth paying attention to. Instead of making people go to a separate tool, Claude becomes an ambient participant in the channels where work already happens. Someone mentions a bug, tags Claude, and it can pull context from the conversation, look at relevant code, propose a fix. The workflow integration is where the actual productivity gain comes from.

Sam: The question I have is about the quality bar at scale. Anthropic's own engineers are probably unusually good at prompting Claude effectively and catching errors quickly. The 65 percent number in a team that deeply understands the model's failure modes might look very different from the same metric at a company where engineers are still learning how to work with AI code generation.

Priya: Fair point. But even if external teams see 30 or 40 percent, that's still a significant shift in how code gets written.

Sam: Let's talk about the Princeton RFIC research, because this one is genuinely fascinating. Researchers used reinforcement learning and diffusion models to design radio frequency integrated circuits from scratch, and they achieved record performance metrics.

Priya: For context, RF chip design is one of the hardest disciplines in electrical engineering. Digital logic is relatively straightforward — you're dealing with ones and zeros, clean abstractions. RF design is analog. You're dealing with electromagnetic wave propagation, impedance matching, parasitic effects, where a trace that's a fraction of a millimeter too long changes your frequency response. Engineers in this field talk about it as a dark art because so much of the expertise is intuitive and hard to formalize.

Sam: What the Princeton team did is apply inverse design — you specify the performance you want, and the AI works backward to find a layout that achieves it. The reinforcement learning agent explores the design space, and the diffusion models generate candidate layouts that can be either entirely novel or constrained to look like human-interpretable topologies.

Priya: The "novel" part is what's striking. Some of the layouts the AI generated don't resemble anything a human engineer would design. They look almost organic — irregular geometries, unexpected component placements. But they work, and they work better than human-designed alternatives on the metrics that matter.

Sam: The bottleneck the researchers identified is data. RF chip design doesn't have anything like the open datasets that exist for digital logic or software. Most designs are proprietary, locked inside companies. They're calling for shared datasets and open ecosystems, which makes sense but is a hard coordination problem.

Priya: Quick hit on ByteDance — Seedance 2.5 pushes AI video generation past 30 seconds of coherent output. Previous models could do maybe 10 to 15 seconds before temporal consistency broke down, characters changed appearance, physics went wrong.

Sam: Thirty seconds sounds incremental, but maintaining coherent scene composition, consistent character identity, and plausible physics over that duration is a significant technical challenge. The model has to maintain much longer-range dependencies. ByteDance announced this alongside four other models at their Volcano Engine conference, with public launch planned for early July.

Priya: Microsoft at Build announced bare metal node support in AKS, along with fleet management for multi-cluster AI workloads. For the infrastructure engineers listening, this is about removing the virtualization overhead for GPU-intensive training and inference jobs running on Kubernetes. When you're doing distributed training across hundreds of GPUs, that hypervisor layer adds latency and reduces throughput in ways that matter.

Sam: And the fleet management piece addresses the operational reality that AI workloads often span multiple clusters, sometimes across regions. Being able to orchestrate that from a single control plane is table stakes for running AI infrastructure at production scale.

Priya: Brief note on Oracle — 21,000 layoffs to help fund debt-financed AI data center construction. It's a stark example of how incumbent tech companies are restructuring their cost base to compete in cloud AI infrastructure.

Sam: The debt-funded approach is risky. They're betting that demand for AI compute will grow fast enough to service that debt. If the market shifts or margins compress, that's a lot of leverage.

Priya: Last segment — Naomi Saphra's framework for understanding LLM behavior. Three key ideas worth internalizing. First, LLMs behave more like populations than individuals. Each response is a sample from a distribution, not the output of a consistent reasoning agent.

Sam: Second, tokenization creates predictable blind spots. The way text gets split into tokens affects what the model can and can't reason about. If a word gets tokenized unusually, the model's performance on tasks involving that word degrades in ways you can predict once you understand the tokenizer.

Priya: Third, sycophancy operates through subtle demographic inference. Models pick up on indirect signals — your writing style, your references, even your favorite sports team — and adjust their responses to match what they infer about your preferences. That's useful for practitioners building evaluation pipelines, because it means you need to control for these confounds.

Sam: Looking ahead — the custom silicon trend is accelerating. Between Google's TPUs, OpenAI's Jalapeño, and Meta's efforts, we're heading toward a world where inference cost becomes a function of your chip design capability, not just your GPU procurement budget. That changes who can compete at the frontier.

Priya: And the vertical integration trend in developer tools — Cursor building its own model and Git platform, Anthropic embedding Claude into Slack — suggests the AI coding market is consolidating around integrated experiences rather than point solutions. If you're evaluating these tools for your team, the question is shifting from "which model is best" to "which workflow integration is best."

Sam: The Princeton RF chip design work also raises a question I keep coming back to: as AI-designed hardware starts outperforming human-designed hardware in specific domains, how do we verify and trust those designs? Especially in safety-critical applications like autonomous vehicle radar or communications infrastructure.

Priya: That's a verification and interpretability problem that's going to get more urgent. Worth watching.

Sam: That's our show for today. Show notes and links to everything we covered are at cleartext.fm.

Priya: Thanks for listening. We'll see you tomorrow.