Sam: OpenAI announced its first custom silicon yesterday. It's called Jalapeño, co-developed with Broadcom, and it's an ASIC designed specifically for LLM inference. Not training — inference. That distinction matters because inference is where OpenAI spends the vast majority of its compute budget now, and Nvidia's roughly 75 percent profit margins on GPU hardware mean every token OpenAI serves carries a significant silicon tax. Jalapeño is their attempt to change that equation, and it puts them on the same path Google started with TPUs over a decade ago.

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

Sam: And I'm Sam Kim.

Priya: We've got a packed show today. We're going deep on this custom chip story because it connects to two other silicon announcements that dropped in the same 24-hour window — IBM's sub-nanometer prototype and Qualcomm entering the data center market. Then we'll cover Google baking computer control directly into Gemini 3.5 Flash, a Chinese model putting real pricing pressure on Western labs, AI designing radio chips, Grab's production architecture for securing agentic AI, and a few more. Let's get into it.

Sam: So Jalapeño. The key thing to understand about ASICs versus GPUs is specialization. A GPU is a general-purpose parallel processor — it's good at many things, which is why Nvidia dominates. But that generality comes at a cost. When you know exactly what workload you're running, you can strip away everything you don't need and optimize the data paths, the memory hierarchy, the numerical precision — all of it — for that specific task. That's what an ASIC gives you. Google has been doing this with TPUs since 2016, Amazon has Trainium and Inferentia, and now OpenAI is joining that club.

Priya: The timing makes sense when you think about where OpenAI's business is. They're serving millions of API customers, ChatGPT has hundreds of millions of users, and every single response is an inference call. At that scale, even a 30 percent reduction in per-token compute cost translates to billions of dollars annually. And when your primary hardware vendor is taking 75 percent margins, the incentive to vertically integrate is enormous.

Sam: Exactly. And they're targeting late 2026 deployment, which is aggressive but plausible given that Broadcom has done this before — they built Google's TPU silicon. The interesting question is whether Jalapeño is inference-only long term or if this is step one toward training chips. My read is inference first because that's the immediate cost pressure, but the organizational capability to do custom silicon is the real strategic asset here.

Priya: And this didn't happen in isolation. Qualcomm also announced the Dragonfly C1000, their first dedicated data center processor, pushing beyond their traditional mobile and edge territory into server-class compute. So in one week, you have two new entrants in the data center AI silicon market. Nvidia is still dominant, but the competitive landscape is diversifying fast.

Sam: Which brings us to the IBM announcement, which operates at a different layer of the stack but is equally significant. IBM built a prototype chip packing roughly 100 billion transistors on a fingernail-sized area. That's approximately double the density of their 2021 state-of-the-art. They're claiming this extends Moore's Law by about a decade beyond where current projections had it plateauing.

Priya: Help me understand what that means practically. We've been hearing "Moore's Law is dead" for years.

Sam: Right, so Moore's Law in its original formulation is about transistor density doubling roughly every two years. The concern has been that we're approaching physical limits — you can only make transistors so small before quantum effects make them unreliable. What IBM is demonstrating with this sub-nanometer process technology is that there are still architectural and materials science innovations that can keep pushing density higher. For AI specifically, denser transistors mean you can fit more compute and more on-chip memory into the same power envelope. That directly affects how large a model you can run efficiently and how much energy it consumes. Every AI accelerator roadmap for the next decade depends on continued progress at this foundational layer.

Priya: So the silicon story today is really three data points that all point in the same direction — more competition, more specialization, and continued physical scaling. That's a good setup for where AI infrastructure is heading. Let's shift to the model side. Google integrated computer use directly into Gemini 3.5 Flash.

Sam: This is a meaningful architectural decision. Previously, computer-use capabilities — where a model can see your screen, move a mouse, click buttons, type text — were typically implemented as wrapper layers on top of a model. You'd have an orchestration system taking screenshots, feeding them to the model, parsing the model's output into mouse and keyboard actions. Google has baked this into the model itself, exposed directly through the Gemini API. On the OSWorld benchmark, which tests an agent's ability to complete real desktop tasks, it scores 78.4 — on par with GPT-5.5.

Priya: Why does it matter whether this is native versus a wrapper?

Sam: A few reasons. When computer use is native to the model, the model can reason about the visual state and the actions in a unified way rather than through a lossy translation layer. It reduces latency, reduces error accumulation, and makes the whole system more reliable. But the bigger implication is what it enables for developers. You can now call a single API and get an agent that can navigate a browser, fill out forms, run software tests, automate office workflows. The barrier to deploying autonomous desktop agents just dropped significantly.

Priya: Which immediately raises the security question. If you're giving a model the ability to operate a computer autonomously, you need to think carefully about sandboxing, access controls, and prompt injection. An attacker who can manipulate what appears on screen could potentially redirect the agent's actions.

Sam: That's a real concern, and it connects nicely to the Grab story we'll get to in a moment. But first — GLM-5.2 from Zhipu AI. Snowflake's CEO ran a 103-task coding benchmark comparing it against Claude Opus 4.7, and GLM-5.2 nearly matched Opus's performance at roughly one-fifth the cost per output token.

Priya: There's a nuance here though.

Sam: There is. GLM-5.2 uses about twice as many tokens per task to achieve similar results. So the effective cost advantage isn't five-to-one, it's more like two-and-a-half-to-one when you account for total token volume. But that's still a substantial gap. For enterprises building cost-sensitive pipelines — think batch processing, code review, automated testing — that pricing difference is material. And it puts real competitive pressure on Western labs to either improve efficiency or adjust pricing.

Priya: The broader pattern here is that Chinese labs continue to close the capability gap while maintaining significant cost advantages. For architects designing production systems, the question is increasingly not "which model is best" but "which model gives me the best performance per dollar for my specific workload."

Sam: Now let's talk about Grab's Palana platform, because this is one of the most detailed public descriptions I've seen of how to actually secure agentic AI in production. Grab — the Southeast Asian super-app — built a Kubernetes-native platform specifically designed to run autonomous AI agents safely. They use isolated namespaces for each agent, out-of-process control planes so the agent can't tamper with its own orchestration, and Vault-backed proxy-mediated secrets management so the agent never directly handles credentials.

Priya: The design philosophy here is really about treating LLM-driven agents as untrusted workloads. Unlike deterministic software where you can reason about what code will do, an agent might decide to call an unexpected tool, write and execute code, or respond to a prompt injection in ways you can't predict. Palana assumes all of that can happen and contains it at the infrastructure level.

Sam: If you're deploying agentic AI in your organization, this is worth studying as a reference architecture. The key insight is that you can't solve this at the model layer alone — you need infrastructure-level isolation. It's the same principle behind container security, applied to a new class of unpredictable workloads.

Priya: Quick hit — the AI talent migration from Google continues. Jonas Adler and Alexander Pritzel are leaving Google for Anthropic, following a pattern that now includes Noam Shazeer and Nobel laureate John Jumper. Google still has enormous research depth, but sustained attrition at the senior level affects institutional knowledge and research direction.

Sam: One more I want to highlight — Princeton researchers using reinforcement learning and diffusion models to design radio frequency integrated circuits. RFICs are notoriously difficult to design — analog RF is sometimes called a "dark art" because it requires deep intuition about electromagnetic behavior that doesn't reduce to clean digital abstractions. The Princeton team's AI-designed chips achieved record performance metrics while drastically cutting design time.

Priya: What's interesting here is that AI-driven chip design has mostly been applied to digital logic — placement and routing, synthesis optimization. Extending it into analog RF is a harder problem because the design space is more continuous and the physics constraints are more complex. The researchers noted that the primary bottleneck for further progress is the lack of large shared chip design datasets, which is a common theme — the limiting factor for AI in specialized domains is often data access, not algorithmic capability.

Sam: And briefly — the Authors Guild tested five AI detectors against human-written text. Results were all over the map. Pangram and Grammarly correctly identified every text as human-written. Sidekicker and ZeroGPT flagged every single one as AI-generated. The Guild points out a fundamental problem: professionally written text is statistically similar to AI output because the models were trained on professional writing. This is a circularity that detection tools may never fully resolve.

Priya: So looking ahead — what are the threads to watch from today?

Sam: The silicon diversification story is the big one for me. We now have OpenAI, Google, Amazon, and Qualcomm all building or shipping inference-optimized silicon that competes with Nvidia. Combined with IBM showing continued density scaling, the hardware landscape 18 months from now could look very different from today. That affects inference pricing, which affects what applications are economically viable.

Priya: And on the software side, native computer use in production model APIs is going to accelerate agent deployment. The Grab architecture shows that the security community is thinking seriously about containment, but the tooling and best practices are still early. I expect we'll see a lot of organizations deploying agents before they've fully worked through the threat model. That gap between capability and security maturity is worth watching closely.

Sam: Agreed. The capability is moving faster than the guardrails, and that's where the interesting engineering challenges will be for the rest of this year.

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

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