Agent Cloud:Databricks 对 AI 未来的押注——Matei Zaharia 与 Reynold Xin
Databricks 开源的 OmniGen agent layer,旨在把模型和 harness 的频繁更替变成接口问题,而不是客户迁移问题。 Matei Zaharia 说,这一层源于工程师围绕 Isaac 搭建工作流;Isaac 是内部封装的 Claude Code 和 Codex。与此同时,Genie 及其他 agent 需要可移植的会话、协作、历史记录、搜索、安全和支出控制。统一 API 接收消息或文件,流式返回文本和工具调用,并支持取消当前轮次;Matei 对开源的理由是,一个拥有众多集成的开放层,最终会胜过封闭的同类产品。
核心平台判断是,有用的 agent 需要的是位于正确位置的专有数据,而不只是另一个通用模型。 Swyx 提出,传统软件可能被重写:把数据放到位,再叠加能力足够强的 agent;Matei 认同“没有正确的数据,你其实做不到”。因此,Databricks 的收官策略是,让 agent 能够在安全边界内访问数据、治理体系和执行环境。
LTAP 直击把交易数据迁入分析系统时,脆弱 CDC 管道形成的既有成本。 Matei 认为,Databricks 无需统一查询引擎,只要统一存储,就能获得 HTAP 约“99%”的收益:利用闲置存储集群 CPU,把面向行的 Postgres 页面转码成压缩列式数据,供分析系统即时读取。这样既能绕开中间 CDC 管道,也能避免调查任务压垮生产数据库。
Agent 的普及正在催生控制平面市场,因为二元权限无法表达企业风险。 Zaharia 的上下文策略会记录 agent 是安装了一个仅有1天历史的 NPM 包,还是读取了1,000份机密文档,再据此决定后续操作是放行、拦截还是升级审批。同一会话状态也能在调试任务烧掉$500后,将任务支出上限设为$5。安全是首要问题,但成本敞口同样会在拥有100,000名员工、为客户写代码的咨询公司中不断放大。
Databricks 同时把自身的运营规模作为基础设施证据,以及系统设计数据的来源。 Matei 说,公司每天在三朵云上启动5,000万–6,000万台虚拟机,处理EB级数据;Neon每天启动约1,300万个数据库,agent和分支机制贡献了其中相当一部分活跃度。与此同时,Databricks 介绍了一款新的分析引擎,其采样 trace table 包含约1千万亿个数据点,首批部署目标是将任务完成时间压缩到几十毫秒。
Databricks 针对 Snowflake 的竞争逻辑具有路径依赖:先开放,再做大。 Ion Stoica 强调,Databricks 起步于大规模数据摄取、机器学习和开放格式,随后再提升服务速度;Snowflake 则聚焦于更窄的专有数仓场景。对于不愿再陷入数十年锁定的企业,开放底座和统一数据管理平面,可能比单个引擎的局部最优更有价值。
Mosaic 的角色已从通用开放模型转向专用模型和复合 agent 系统。 Ion Stoica 说,Databricks 没有把主要精力放在再训练一个 frontier model 上。Zaharia 的文档理解模型能返回结构化 JSON,成本约为 frontier model 解析的1/100,同时效果更好;Databricks 还介绍了由开放模型生成训练环境的管道,在一项任务上击败了 Opus 和 GPT-5.5。主流用户何时能自行定制模型仍不确定,但更强的基座模型、更好的 RL traces 和合成数据,会持续降低门槛。
1. OmniGen 把 harness 更替变成基础设施问题
Databricks 的 Data + AI Summit 已从最初约50人的 Berkeley Spark 教学聚会,发展到全球约100,000人参加,其中30,000人线下参会。这一规模为 OmniGen 这款新的开放 agent layer 提供了背景。
Matei Zaharia 说,OmniGen 源于两个问题的交汇:Databricks 工程师围绕 Isaac——一个内部封装的 Claude Code 和 Codex——搭建了复杂的工作流和 UI;而 Genie、内部 agent 以及客户 agent 又需要“每隔几个月”切换模型和 harness。
他的产品要求不止于推理能力:“如果不能和别人共享会话、保留历史记录、进行搜索,agent 就完全没用。”Coding agent 和定制化业务 agent 的表面形态不同,但都需要同一套交付、协作、可移植和控制层。
统一 API 将 agent 会话定义为一种可以接收消息或文件、流式输出文本和工具调用、并取消当前轮次的对象。Databricks 把基于终端的 Claude Code、Codex、Pi、OpenAI SDK 及其他 harness 映射到这一接口,吸收上游 API 变化,同时让用户可以自由替换其 UI。
发布后不久,这一项目已经吸引了外部参与。主持人提到,项目很快出现约400次合并请求;Matei 猜测其中约一半来自其团队之外,包括 Kubernetes 支持、云沙箱集成,以及 Cursor CLI 和 Antigravity 等额外 harness。
Matei 将这一层比作现代数据栈:数据摄取、转换和可视化曾经是有用的抽象,但客户最终希望减少彼此割裂的系统。他认为,围绕构建一个简单 agent 所需的大量框架,也可能出现类似的整合压力。
2. 持久化云沙箱修复别扭的本地工作流
Swyx 的起点极具画面感:开车去看医生时,他把笔记本电脑 tether 到手机,在红灯时查看 coding session,确保任务继续运行。这种生产力体验像是来自未来,但运行方式却像“编程的黑暗时代”。
他的需求清单远不止远程聊天:持久化云沙箱、交互式 shell、文件列表、日志 tailing,以及正确渲染的 Markdown。Coding 环境可能携带数十GB的源代码、构建产物和已安装库,因此即使存储与算力已经分离,本地持久性仍然重要。
托管式 session 能把个人原型变成团队软件。工程师们曾搭建“5、6个”类似的内部 agent 框架,但没有服务器、身份认证和安全控制,就无法安全协作,也无法让 agent 连接受保护的公司数据。
3. 开放协议协调无法同步演进的各方
Zaharia 将 agent 接口比作网络协议和数据共享。Walmart 这样的零售商可以向供应商开放实时库存视图,供应商再与自有数据结合,决定发运什么。当多方以不同速度推进时,稳定的互操作层比反复按需开发集成更持久。
agent、用户和工具之间也存在同样的协调问题。Vibe-coding 可以快速生成一次性软件,但当独立系统需要长期协作时,它无法替代协议。
Spark 提供了战略先例。将机器学习、图处理和连接器做成可组合的库,让外部参与者覆盖数千种数据库和格式;这些工作单凭一个团队不可能完成,而所有参与者都能从共享底座中受益。
Databricks 的边界很务实:在集成和网络效应会不断叠加的地方采用开源层;但对于无法仅靠代码交付的运营服务,则直接出售服务。要防止流处理任务或 Lakebase 数据库一夜之间丢失数据,需要一支负责任的运营团队。
4. 有状态策略让自主运行更安全,无需持续审批
Zaharia 否定了简单的允许或拒绝工具清单。agent 可能确实需要读取机密文档、安装 NPM 包或向公司网站发布内容,但如果在一个已被攻破的 session 中全部放开,就会形成数据外泄路径。
上下文策略会跟踪操作的顺序和规模。安装一个仅有1天历史的软件包,或读取1,000份机密文档,都可能改变后续发布操作是被允许、拦截还是升级审批;相比静态权限,这让系统同时更有用、更安全。
底层 API 还需要语义翻译。Databricks 内部的 Google Drive MCP server 暴露约60个调用;可复用的策略库可以识别其中哪些调用会公开分享文档,再让策略针对这些更高层级的事件生效。Zaharia 将这一方法与 Panther 基于 Python 的事件处理联系起来。
成本也会成为状态变量。一个 agent 读日志消耗了$500后,Zaharia 希望把任务委派出去、设置$5上限,并在需要更多预算时弹出审批提示。Databricks 目前给工程师提供不限量使用,但会分析 traces,识别异常、评估效率,并比较 Rust、TypeScript 等语言中的模型能力。
被问到初创公司可以做什么时,Zaharia 指向 coding-agent 使用、支出和质量分析:找出薄弱任务、缺失技能,以及团队应该改进 agent 的领域。他认为,这很可能成为 agent 开发的管理平面。
5. Agent 工作负载正在改变算力的单位经济模型
Matei 说,Databricks 每天在三朵云上启动约5,000万–6,000万台虚拟机,每天处理EB级数据——通常还没等听众吃早餐就完成了。他将 Databricks 形容为全球最大的 CPU 算力编排者之一。
Neon 目前每天启动约1,300万个数据库,其中很大一部分活动由 agent 和快速分支驱动。一次性数据库和持久化 coding 沙箱代表了不同的消费模式:自主软件反复创建基础设施,而不是把每个数据库都视为需要精细配置的永久资产。
6. LTAP 通过统一存储而非统一工作负载,移除 CDC 瓶颈
Matei 将数据库分为两类:Postgres、MySQL 和 Oracle 等 OLTP 系统,针对行级交易优化;以及面向聚合、机器学习和扫描的分析系统。在生产数据库上运行足够大的分析查询,可能拖慢甚至拖垮本来要被解释的应用。
标准答案是 change data capture:读取数据库增量,再在分析平台中重建状态。这套机制基础却脆弱——schema 变更会打断管道,工程师凌晨3点被叫醒;当 Matei 在主题演讲现场询问谁喜欢自己的 CDC 配置时,举手的“可能只有2个人”。
早期 HTAP 系统试图用一个引擎同时覆盖两种场景,但 Matei 认为,它们牺牲了 Postgres 和 Spark 生态,又很难在性能上同时匹敌两端。“最后两边其实都做得很差。”
LTAP 被称为“正确实现的 HTAP”:保留独立的交易引擎和分析引擎,但让两者共享一个存储层。Matei 认为,这可以提供约99%的目标收益——数据一产生就能用于推理——而不必让一个查询引擎服务所有工作负载。
讨论还强调,分析任务可以在独立的机器集群上运行,因此调查不会压垮仍在为用户提供服务的在线交易数据库。
7. 闲置存储 CPU 让行列转换几乎零成本
这一能力建立在 Lakebase 和 Neon 式的存储、算力分离之上。团队没有把 Postgres 页面原样持久化到开放数据湖,而是探索写入分析引擎可以直接消费的列式数据。
会议一度停留在第一性原理争论上,直到一名工程师做出了原型。存储集群有闲置 CPU 可以进行行列转码;生成的数据压缩效果更好,因此服务可以少写一些数据到 S3 或其他对象存储。Matei 的结论是:没有“额外开销”,也没有“性能妥协”。
Matei 起初并不相信团队为这一产品写下的 agent 定位。一名澳大利亚客户改变了他的看法:服务遥测可以暴露 SLA 下滑,但 agent 还需要底层订单和用户数据来解释原因。把运营上下文接入后,这些调查 agent 的能力可能提升“10倍”——“现在我确实相信我们自己的表述了。”
8. 原型和具名客户终结战略争论
LTAP 的突破没有宏大的启动会,也没有正式设计文档:“有人真的直接去做了个原型,而且它能跑。”OmniGen 也说明了同一道理:可运行的软件和真实用户会暴露抽象需求文档无法呈现的约束。
Matei 描述了一种持续小步发布、紧密接触客户的文化。他对新产品团队的第一个问题是:目标客户是谁,你是否和他们熟到直呼其名,是否会给他们发短信?许多产品在几周内完成初版,再通过这一反馈闭环迭代。
Matei 回忆起 Delta Lake 早期的一名客户,其事件速率和数据新鲜度要求远超公司当时已有的工作负载。讨论将这一时间点放在公司成立约4年后,即2017–2018年前后。工程师 Michael Armbrust 让它在该客户处跑通后,方案也适用于其他客户。
Ali Ghodsi 说,Clean Rooms 最初只为2名客户构建。他认为,与其因过度适配1、2名客户而承担风险,不如避免“煮沸海洋”、最后一个客户都没有;但他也提醒,有些客户最终应该被放弃。
9. 企业采用需要不同的产品直觉
Ali Ghodsi 强调,老牌企业拥有受监管数据、隐私义务、遗留系统,以及涉及更多利益相关方的采购流程。只为技术条件完美的科技公司优化的开发者工具,可能很难扩展到更大的市场。
科技公司经常会回应:“我自己做就行。”但零售商和其他企业可能明确拒绝把流式处理可靠性当成自己的业务;他们不想因为“某个奇怪的 nerd”无法让管道持续运行,导致生产系统宕机。
这些客户仍然拥有深厚的领域知识——航空工程、医学或临床数据——但他们要的是通往知识的桥梁,而不是数据库培训。他们想要的界面基本是:“我有这样一个包含临床数据的巨大矩阵,怎么把它聚类?”至于答案背后的基础设施,他们“永远不想知道”。
10. 新分析引擎是一座用真实工作负载训练的工厂
Ali Ghodsi 认为,几乎所有真正获得规模的分析引擎都已有约10年历史。它们都从一个狭窄用例起步,不断叠加权宜扩展,最后变成“一大堆”妥协;重写旧引擎会触发经典的第二系统陷阱,并经历传统的5年成熟周期。
Databricks 没有主要从论文中挑选算法,而是打造了“一座生产数据库的工厂”。一个机器学习模型——不是 LLM——从包含约1千万亿个数据点的采样 trace table 中学习,并预测候选实现面对真实查询形态时的表现。
相关特征包括规模、吞吐量、延迟、数据分布、稀疏性、复用率和 distinct-value 数量。甚至 ASCII 与 Unicode 的区别也很重要:如果一个字符串维度只有256种密集取值,就可以用数组查找替代哈希表。
该模型既指导工程优先级,也参与运行时调度,因为针对几十毫秒延迟优化的算法,可能并不适合扫描PB级数据。部署会从新的 endpoint 和增量能力开始,避免一次性进行5年周期的硬切换,最终目标是覆盖旧引擎能够处理的全部场景。
11. 开放存储比一个万能查询引擎更重要
Ion Stoica 明确反对把所有查询工作负载压缩进一个 HTAP 引擎。LTAP 的核心是统一存储,同时保留专用执行层;agent 已经可以同时编写 PostgreSQL 和 Spark SQL,因此让人类只使用一种语言,不再是阻碍架构落地的硬性要求。
被问到为什么 Databricks 超过了 Snowflake——尽管两者都拥抱云架构,并将存储与算力分离——Stoica 提出了两点差异:开放性和 AI。Databricks 从 Parquet 起步,沿着开放格式演进;早在 ChatGPT 出现之前,其平台就已经被定位为“机器学习加数据”。
Stoica 说,Databricks 起步于大规模数据摄取、JSON 日志、大规模批处理和低成本开放存储;Snowflake 则专注于一块更小但价值更高、需要快速服务的业务数据。两家公司曾经合作,直到客户开始问 Databricks:“我为什么还需要另一个东西?为什么不能直接查询你们的表?”
他的总结是“先开放,再做大”(start open and start large)。经历过30年供应商锁定的企业希望拥有开放底座,最好还能用一种方式管理公司数据。Stoica 说,5、6年前这种偏好仍然颇具争议,当时 Snowflake 联合创始人曾主张“谨慎选择开放”。
12. 专用模型把专有上下文转化为竞争优势
Ion Stoica 说,Mosaic 最初凭借早期开放 LLM 成名,Databricks 后来又发布了规模超过 Llama 3 的 DBRX。但 Databricks 并没有选择主要靠投入算力再训练一个通用 frontier model 来竞争;Genie 则把外部模型或定制模型用作“虚拟数据科学家”,理解公司的数据和相关工具。
对于规模足够大的专用工作负载,训练模型仍然值得。讨论提到,一款文档视觉模型可以把 PDF 或 Word 页面转成结构化 JSON,效果优于 frontier model 解析,成本约为其1/100;这避免了把页面图像发送给 Claude Opus 或其他 frontier model 时产生的巨额 token 账单和各种差强人意的结果。
Databricks 也在开发面向 coding workflow 的专用 sub-agent。Stoica 说,随着更强的基座模型生成更好的 RL traces 和合成环境,定制化会变得更容易。Databricks 已经有管道让开放模型生成自己的训练环境、自我训练,并在一项任务上击败 Opus 和 GPT-5.5;未解决的问题是,这一能力何时能从专家研究者下沉到只需描述任务的普通用户。
Databricks 当前同时服务两类客户:一类需要 AI Runtime,包括按需 GPU、库、数据移动和监控;另一类需要帮助构建评测和合成数据。收尾判断将所有问题串联起来:模型已经具备足够好的推理能力,许多传统软件可能都会变成运行在正确数据之上的 agent,但“没有正确的数据,你其实做不到”。
One of the theses we have is that once you can get the data in the right place, the AI models are becoming pretty good. The generic agents are fairly good—I mean, Ali talked about AGI already here. They have pretty good reasoning capabilities. Actually, I think much of the traditional software will be rewritten with this new paradigm, which is just: get the data to be there, and then let's slap some AGI on top. Magic will come out.
Yeah.
But without the right data, you can't really do that.
Matei Zaharia from Databricks, welcome to Latent Space.
Thanks for having us.
Alessio Fanelli
Yeah, thanks so much.
Thanks for taking time out. You have your Databricks Data + AI Summit going on. You were just telling me how the first summit that you guys ran was just 50 people.
Yeah, it was a little meetup at Berkeley, I think. We put together tutorials and taught people Spark.
Alessio Fanelli
Yeah. Obviously, now it's—I think the headline number is 100,000 people around the world, with 30,000 in person. It's a crazy community. I just saw the keynote. [laughter]
Ali is just—did you know that it was obvious back then that Ali would be such a great CEO? He's a great presenter. What do you think?
I mean, I think among our group of founders, it was clear that he'd be the best at this, and it turned out great. He's ramped up on so many topics while running a company. He would just go in and study a topic and become as knowledgeable as all the experts. Even if you can't hire the person, you learn enough about finance and sales and whatever it was, and go from there.
Alessio Fanelli
I mean, he's obviously very high IQ and has very high EQ, but Ali today is quite different from Ali 10 years ago. [laughter] I think there's a lot of work that he put in to get to this point.
Yeah. To me, the most appealing thing about him is that he's funny.
It's true. It's hard to make jokes about data, serious topics, security, and what have you.
Alessio Fanelli
Oh yeah, that's for sure.
You guys launched a whole bunch of things. I'll just name-check the stuff, because we're not going to cover everything: OmniGen, your baby; LTAP, your baby; your Dream Engine. We're also going to cover Genie and Customer 360. You acquired Panther, there's Delta Sharing, and there's Unity AI Gateway. A lot of these are things that you would expect Databricks to do. It's part of the roadmap, and everyone in your category has similar things. But I think the 2 of you are leading the 2 most unique and differentiated initiatives in the landscape. Maybe we'll start with OmniGen, and then we'll go into it. I do think that a lot of people are exploring this sort of meta-harness concept. What led you to it?
There were actually a couple of converging lines, which I think is a good sign that you need something new. On the one hand, there's all the coding agents. Internally, we have a really great developer infrastructure team. They built something called Isaac that's basically a wrapper on Claude Code and Codex, and lets you use them either on the web in sandboxes, or just on your dev machine, laptop, or whatever.
They were adding all kinds of stuff there, and we saw that the more advanced engineers were building their own workflows with tons of agents. They were building their own UIs and stuff on top of that. The other line was us building agents. We shipped this data science agent called Genie on the research team, which I co-lead. We also build a lot of internal ones for various things, and then we have all the customer ones.
All of them were running into this issue of, “I need to switch models and harnesses every few months.” Plus, the agent is completely useless if you can't share sessions with someone and have history and search—all this layer on top of it for collaboration. I thought about it from both contexts, and at first people thought it was weird: Why are you doing coding agents and custom agents in the same thing? But I said it's basically the same problem. You just want to build the stuff that lets you deliver the agent, maybe control it if you care about security, and make it portable across things.
We prototyped some things as experiments. We said, “Yeah, actually, we can make it work,” and then we built it for real.
Alessio Fanelli
I'm wondering if this kind of architecture maps to anything in your careers in the past. I always think about how a lot of things tie back to operating systems.
A lot of operating systems tie back to databases, or the other way around. [laughter]
The thing I do think it ties a lot to is network protocols, like the Internet Protocol. We also did stuff with data sharing, which most viewers probably won't know unless they—
Yeah, Delta Sharing is an open protocol for sharing.
Delta Sharing. Yeah, so you have a company maintaining some kind of table. Let's say Walmart or something: They have the inventory and what's been sold in each store. They also have suppliers, and the suppliers would love to produce more things and ship them exactly when you need them.
Why can't you share a view of that table in real time with them? Then they query it, join it with their data, and decide what to send. It's one of these things where you might ask: Today, since we can vibe-code anything so fast, why do we even need to design protocols or APIs or software? Why can't you just vibe-code things on demand?
Actually, for this type of interoperability, where multiple parties are moving at different speeds and building stuff, and you still want some layer on top to coordinate, you do want to design it and build it. It reminds me of agents talking to each other, and users talking to agents and tools.
Alessio Fanelli
Do we know of any other comments or alternative viewpoints?
I think, by the way, we had a debate on exactly this. We said the benefits matter a lot, and around the time we decided to do this thing, I was telling Matei, “It just happened to be a particular week when I was coding nonstop from the moment I woke up until the moment I went to bed. I was looking at my Claude sessions and my Codex sessions, and one of the things that was particularly annoying was having to keep my laptop open.”
I was actually driving to a doctor's appointment, and I remember wanting to make sure the whole thing continued working. It's so comforting to hear you say that, because I'm like, “I don't know if I'm a clown and I'm doing this.” Honestly, I was driving and tethering my laptop to my phone, keeping it on the side, and whenever I hit a red light, I started looking at what was going on on my laptop. I just felt that was ridiculous.
Yeah.
It felt like we went back to the dark ages of programming.
I mean, the productivity you gain from all these coding agents is amazing, but have you heard of the cloud? [laughter]
It was crazy to me.
Alessio Fanelli
Was it the thing we were working on—the sandboxes—or was this before that?
It was a sandbox.
Okay, so you were—
I was approaching it from a very different angle. I wanted to say, “Hey, we're going to have cloud sandboxes that don't shut down. You can get one very quickly, but not just for running agentic sessions. It's also for running development.”
I was personally building that that week, and through building it, I ran into all these issues. Then I wrote a document for my case: “Here's my wish list of what the actual environment should do.” I think he ended up implementing almost every single one of them.
Yeah, I remember Reynold saying—because my first prototype of this had just chats with your agent—“I have to be able to open a shell, like my own shell, and list files and tail them.” So I was—
Alessio Fanelli
Is this an SSH into a mainframe?
Yeah, actually, it has that. [laughter]
Tailing my logs.
Yeah, yeah.
Another thing I think I asked for was—I still use Cursor for the sole purpose of rendering Markdown files.
Uh-huh. Yes.
“Give me a way to see my Markdown files and render them properly. I don't need a separate tool anymore.” Yeah, I think you also built that in.
We did that. We had a lot of engineers building their own vibe-coding setups. But the other thing they all said was, “Hey, I built something that's amazing for me, but no one else on the team can use that because I don't have a server to collaborate.”
This is why we tried to set up OmniGen, so you can have a server and have the security set up in there. You can log in with Google or whatever and actually securely share stuff. That's why we've seen a lot of other agents hit things like this: people think they prototyped an awesome agent, but it's not allowed to connect to some really important data or whatever because of the security team.
At this point, for those watching along on YouTube, we're going to bring up an image of the structure here, and we can talk through a little bit of the architecture. I just want people to understand because, when we're talking about software, it can be very abstract. Here's actually what we're talking about.
You've worked out this entire platform in open source, basically. There's a runner component and a server component with a sort of uniform API that you've figured out, along with all sorts of other elements. Obviously, you can plug in all these persistence layers and compute layers. This is a whole cloud. This is Agent Cloud.
Yeah, it's got these components to work with it. A lot of the action happens on the machine where you deploy your agent to, so whatever you've got on there, you can run. But yeah, it's sort of the minimal thing you want to have hosted collaborative agents and to have that server.
One of the reasons we open-sourced it is that, for anyone building agents, this gives them an app they can start with and customize. We were seeing in Databricks, too, that someone would make a nice agent app, and then other teams would ask, “Can I just use yours for my agent?”
I think we had 5 or 6 different agentic frameworks built by every different team. They all do more or less the same thing.
Shawn Wang
Yeah, people want to take something that works and fork it, and you might as well have something open source. That was another question, which is interesting for Databricks: What do you choose to open source, and what do you choose to make proprietary? This goes back to Spark, right?
Yeah. [laughter] One of the reasons to open source something is if you think it's a layer that will actually have some network effect. It'll benefit from many people collaborating on it.
For example, with Spark, I don't know if you know that, when Spark came out, we also focused a lot on letting you have libraries on top. They used to be different distributed computing engines for machine learning and graph computation. We said they should all be libraries that you can compose, and we made it super easy to add connectors to data sources, too.
We benefit because we don't have the time to write connectors to 1,000 different databases and file formats. We can just use the ones people make, and of course they benefit from joining this thing.
Another way to think about it is, I can imagine that if our thing wasn't open, we'd have some kind of agent-hosting thing, but it wouldn't be open, and then there's an open one. Which one's going to win in the long run? Here, because there is this benefit from people writing integrations, it'll be that.
Then there are other things that you just can't even deliver as open source that are things the company does. For example, how do you make sure your streaming jobs or your Lakebase database doesn't lose all your data at night? That requires an operational team that's going to sit there. There's no way around it; it has to be a service.
We want to make sure that, as a company, we're really good at those infrastructure services, and then we're as open as we can be in terms of what you build on top.
Shawn Wang
I mean, speaking from a benefits perspective, I think we're already seeing pull requests and ecosystem integrations, even though it was only released on Saturday.
Yeah, Saturday. Someone—
Shawn Wang
Let's see what's going on. Yeah.
You can look at the merge lines. I actually asked some legend this morning about the—
Shawn Wang
400 merges already?
I would guess around half are not from my team. For example, someone added support for running it on Kubernetes. People added many cloud sandboxes. This can launch a cloud sandbox and run your agent in there, which is great for sharing, too, because it's not on your laptop with someone running sketchy code on it.
Many startups have put those in, and we expect to see more of them. We also have more agent harnesses already: Cursor, CLI, and Antigravity.
Shawn Wang
That's all beautiful. I feel like the last time this happened, there was the rise of the modern data stack. I don't know if it was that useful. I'm actually kind of curious about your postmortem. I think most people will agree that it is finally dead, but maybe this gives rise to a new modern AI stack that does the same thing. [laughter]
I mean, I think the modern data stack was a pretty useful thing, probably even up until this day. For the audience who don't actually understand the history, I think the modern data stack effectively decomposed into this: You need a layer to ingest the data. You need a layer to transform your data. All of this is run, and then you need a layer to maybe visualize your data. All of this runs on some sort of data warehouse or, later on, as we're doing, a lakehouse.
I think those concepts are all very powerful and very useful. They enabled a lot of workloads. What people eventually run into is kind of a question of unification and consolidation. It's, “Hey, do you really need to chop all of this into different pieces and work with so many different vendors and platforms in order to get a very simple visualization done?”
Over time, everybody started realizing that customers are pushing us. We started to realize that, so we started building more and more capabilities and trying to consolidate. At the end of the day, customers don't have to worry about hooking up 5 different systems in order to produce a chart.
But I think, honestly, something like this is probably happening with how many different frameworks you want to hook up together in order to do a very simple agent.
Shawn Wang
Just to be clear, I would say the core of this is this common API on top of all the harnesses. The API is basically like: you've got an agent session, and you can send in a message or a file. Basically, that's what you can send in, and then you get out these streams as it's streaming text or as it's doing tool calls.
The other thing you can send in is a command to cancel a turn. So that's the API. What we did is we could get you that on top of Claude Code running in a terminal, Codex, Pi, the OpenAI SDK, all that stuff. We map them all to that same interface.
That's something that you'd have to maintain yourself if you built your own agent orchestrator. Whenever Claude changes its API, you have to tweak your thing, or it's going to lose some messages. So that's the thing that's valuable to maintain.
Then on top of that, we built a few apps. I think we built a pretty cool UI and stuff, and we built the security and control piece, which I'm excited about. But it's that common interface. It doesn't try to be a stack.
In fact, you could plug in your own UI on top of this server. That's one of the use cases we care a lot about because we want to use this in our own products.
Yeah, it should be everywhere.
Shawn Wang
Yeah. I think one of the things that's really interesting to me is—first of all, I'll endeavor to do everything I can not to call it the modern AI stack because I think we have a name. But one of the first people who told me about compute sandboxing was Nikita from Neon.
A lot of people think of Neon as serverless Postgres with the separation of compute and storage, instant branching, and all those things. But actually, every database company is also a compute company.
Yeah.
Shawn Wang
He was actually showing me his whole sandboxing solution. I don't think he ever launched it.
So, our sandbox solution—the reason we could have built it so quickly was because we realized that if you just take the actual lakehouse architecture and remove the database from it—by the way, it was coming from you—there are some differences.
For example, in the ones that support this particular workload, it's important to have local persistence because you want your state to persist. Your libraries—you don't have to install your library every time, right? Whereas the Neon architecture, because of the separation of storage from compute, you don't need persistent local disk.
There are some differences, but at the end of the day, yeah, it's—
Shawn Wang
Yeah, so this is when you run a coding sandbox.
If I use the dev infrastructure we had internally at Databricks, there are tens of gigabytes of data just for all the source code, artifacts, and stuff that I built, and I want that to come back next time. But yeah.
Shawn Wang
Before the show, we were talking about some adoption statistics that might be surprising. They could be internal or external, whatever comes to mind—just to impress people with the scale at which this is happening.
On the analytics side, I think we launch maybe 50 or 60 million virtual machines a day across our 3 clouds. So we're one of the biggest compute orchestrators out there, for sure, for CPU compute. All of those, I think, process exabytes of data. I joked that, depending on which time zone you're in, typically before you have breakfast, Databricks will have already processed exabytes of data that day.
On Neon, it's actually pretty interesting too: it's launching, I think, 13 million databases a day now.
Shawn Wang
What do you mean?
A lot of those were thanks to agents and branching experimentation. Because we made it so easy and so quick to launch databases—and thanks a lot to Nikita's team for that—it's changing the way people use databases.
Shawn Wang
Okay, we're going to go into more database talk in a bit, but I want to make sure we close up anything on Omnigen. You mentioned you're excited about the security and control side. A lot of companies are figuring that out right now, as well as the spend side. What have you found there?
I spent quite a bit of time talking to internal users—developers, security teams, managers—and also lots of customers. There are a few things. First of all, one thing that immediately became obvious, as far as security, is that there's this tension between usability and security.
A lot of coding agents today have very basic controls: you can tell me which tool patterns are allowed or disallowed, or whatever. It's yes or no. That puts you in a very tough spot. As an example, should my agent be able to read some confidential documents? Or should it be able to install new packages from NPM, which maybe is compromised? It's a yes-or-no question, but maybe I want to allow it.
Should my agent be able to publish stuff to the company website? If I'm using the agent to code on the website, yes. But should it be able to do both? It could grab a confidential document, get prompt-injected, and leak it. Probably not.
The thing we decided we need is stateful, or what we call contextual, policies, where you keep track of the state of that session. It's not, "Is it allowed to push to the marketing site or not?" It's, "Hey, if it did a risky thing, like it installed a 1-day-old package from NPM, or it read 1,000 confidential documents, then no. Don't do it. Otherwise, maybe it's okay."
That's one example of moving that trade-off. It's both more secure and more useful by having a more powerful engine, essentially. This requires tracking sessions.
The other piece that was interesting there is that there are these very low-level events it's doing, and you want some libraries on top that parse them. For example, we have an MCP server on Google Drive internally. It's got 60 API calls. How do I know which of those will share a document with stuff on the internet and which ones won't? It's annoying.
So we designed the policy layer in OmniGen around functions, and you can have libraries. Someone can make something that maps low-level events to high-level ones, and then you write a policy about the high-level things that came out.
Shawn Wang
And was that related to Panther?
Yeah, Panther will help with that. Panther is kind of a similar idea on the event-processing side, and it's Python-based versus a weird custom language. This is sort of more in real time.
Shawn Wang
Those things are happening.
Yeah. These are the cool things. I think the contextual or stateful part, and then the way it can have libraries, was another reason to make it open source, because others will write libraries and we and our customers can use them.
The final thing is that, because it's stateful, one of the states we track is how much you spent in that session. I asked an agent to debug something, and it spent $500 because it decided to read a lot of log files and burn a lot of tokens. But I can literally say, "Okay, launch a sub-agent to do this and cap it at spending $5. Ask me for permission if it needs more."
Because we're counting that within the session, it'll pop up and tell me, "Okay, you spent $5. Do you want to go on?"
Shawn Wang
For more context here, Matei spent the last 5 years architecting Unity Catalog at Databricks, which is the governance layer for data.
That's right. Yeah.
Shawn Wang
And it's sort of combining expertise at that layer together with all the AI governance here.
Yes. But I also spent a lot of time being annoyed by coding agents and getting burned. As the CTO, I don't want to end up on the front page because I installed some weird npm package and leaked all the code.
So I'm especially paranoid, but I also have very little time. I don't want to sit there approving, "Do you want to run a 20-line bash script? Yes or no?" That's why I spend a lot of time figuring out how I can make it as safe as possible and not annoying.
Shawn Wang
Is safety—and let's call it security—a bigger concern than token maxing or token budgets?
Yeah, they're both there. I guess it depends on the type of company you are. Some companies have limited budgets, and they really care—
Shawn Wang
About that. Or, I mean, you can be Uber and still be concerned, you know.
Yeah, totally. For us, security is absolutely critical as a cloud provider. It's the most important thing.
We're not so worried about token maxing yet, but I've seen—for example, I talked to some consulting companies. They have 100,000 employees who are all coding for customers. If each of those spends an extra $1,000 a month, that's not fun. We have only a few thousand engineers.
Shawn Wang
What's the policy at Databricks? Is it just unlimited, or...?
Unlimited, but we do use our own product to analyze the traces and stuff, and we have a team that's looking to optimize and see if anyone's doing something weird. We actually had some really cool insights just from analyzing current traces, like which models are better at, say, Rust versus TypeScript or whatever. At least in our codebase.
Shawn Wang
Yeah, amazing. Obviously, I have to ask the token-maxing question. I think it's a key thing, but yes, security and control are above that, and figuring out a sane layer where you can have some autonomy, but not too much.
Yeah. We want to make it super easy. As an engineer, you should be able to set the thing. In OmniGen, you can ask your agent, "Set up a policy on yourself to do this."
Shawn Wang
If there's anything I should be showing, I don't see it on GitHub.
It's in the docs there, so you can look at it later. Just look in the docs on contextual policies if you want to see them.
Shawn Wang
Yeah, if you want to follow up on this, this is exactly where to look.
Yeah, and the story of these is that I wrote a doc with 10 ideas for things to work on. That was my wish list of things people asked for, and I told the team, "Hey, can you do at least 5 of these for the launch?" Then they got back to me with all of them.
Shawn Wang
Oh, wow.
You can come up with more, but some of them are just meant to be examples. Really, you can intercept any event the agent is making, and then either block it, force it to ask the user, or allow it. You can update state to keep track of stuff.
Shawn Wang
Ultimately, I think of you as a systems designer: you let people plug in, right? That's the whole modus operandi of what you do.
Yeah. We care a lot about composability too. Can someone else write a library that others use?
Shawn Wang
There's also a batteries-included philosophy here, probably very similar to how you did Spark: you could just start using it.
That's right. It has to be good out of the box at certain things, and then you can build your own things on top. In Spark, if you just want to read a table or do an aggregation, it should be awesome out of the box.
Shawn Wang
People who want to catch up on OmniGen should watch your keynote and go through the GitHub and the docs. If they want to contribute or build on this ecosystem, where would you call out as the most high-leverage places to get involved?
Get involved in the Discord and GitHub. Our team is there monitoring, and some of the things people ask for, we just build ourselves.
Some of them, we're collaborating with them to build that, and they also tell us how they would like to use it, because I think especially for developers, everyone wants it to work their own way. With a really good developer tool, you have to hear the feedback on all the ways and figure out the abstractions and how to let people customize. So we'd love to hear from you if you think, “Hey, I don't want it to work this way.” Tell us. We really just want to get that compatibility layer across agents and then let you do stuff on top.
Shawn Wang
Yeah. Is there anything, in terms of the startup side? I'm a founder, I see an opportunity, and I want to get in front of you. What's your request for a startup? What do you wish someone was working on?
Oh, for a startup.
Shawn Wang
Yeah. You have your own startup and it's doing well, but if you weren't working on your own startup, what would be obvious to work on? [Laughter.] You advise many startups too, obviously.
I do think that, as a company with a lot of engineers, anything that helps me make sense of how people are using coding agents and their spend, but also quality—like, “You should add this skill,” or, “You should write this thing,” or, “Your agents are really horrible at tasks involving this service,” or, “Go spend time.” That would be nice. Yeah.
Shawn Wang
Yeah, the closest I found is this team, Git AI.
Oh, cool, yeah.
Shawn Wang
They started with, “We'll just do code and human attribution,” but they're basically building the analytics layer on top of that. I do think there are a bunch of them. Artificial Analysis is obviously doing super well with their stuff. There will be people—I think this is the domain of consultants first, but then people will actually build software that has the management plane for coding agents.
Yeah, I think there'll be a lot of insights there. You have that in other areas.
Shawn Wang
Okay, well, the other big thing is your dream engine. [Laughter.] If you want to tell the story of OLTP, our background is that I'm going to make people listen to our Ankur Goyal episode, where we talked about SingleStore, HTAP, and all that history.
Yeah, yeah. The OLTP idea is actually pretty simple. People have heard of Ankur's talk about HTAP; it's effectively the world of databases. Sorry, there's maybe a lot of context that needs to be injected here. The world of databases—
Shawn Wang
We're going to be the database podcast that's forcing people to learn their databases, guys. You cannot vibe-code with just Markdown files.
It's one of the most important fundamentals of systems technologies out there. But the world of databases is effectively split into roughly 2 halves. There's what we call OLTP databases, which are transactional—think of your Postgres, your MySQL, and your Oracle databases. And the other side is what we call analytics, which we might sometimes refer to as OLAP.
The difference is that on OLTP, you typically run transactions on an event that looks up one specific row; we update that row, right? It's a very row-oriented data structure. In analytics, you're trying to reason about the data; you're trying to compute, “Hey, what's my revenue per store? How's my website doing every day?” And then you eventually want to run machine learning on it to predict, “Hey, how might my sales be going in the future?”
They are very different architectures, and everybody starts with OLTP databases because every app, when it becomes serious enough that it needs more than Markdown files, needs to have a database. You don't want to lose your data; you want to have some transactional consistency. But once you want to reason about the data, if you only have 100 rows, it's probably okay to run it on your Postgres or your MySQL database. But once you have more data and want to run more complicated analysis, the analysis might crash your Postgres database. So you start getting data out of the—
Shawn Wang
Replicate them into the analytic systems.
Yeah. Some of them actually get into Elasticsearch for log analysis. A lot of our customers obviously get into Databricks to run more sophisticated things. And there's this term called CDC.
Shawn Wang
CDC
change data capture.
And what it does, it reads the binlog of the database. If you don't understand what a binlog is, that's fine. But it's a little delta of the data, and then it reconstructs, based on the delta, the state of the database on the analytic side.
But CDC is a very painful thing. It's basically standard in the industry; everybody uses it. Many data engineers end up being woken up at 3:00 a.m. because of some pipeline issue.
Shawn Wang
My explanation is that everybody became a $5 billion company just doing CDC.
Yeah, exactly. CDC is a very—it's one of the most boring but one of the most fundamental operations powering modern society. But it's so brittle that we joke it should be called continuous data corruption, because you might change your schema on your OLTP database and then the CDC pipeline fails to handle the schema change. And then everything goes out.
Shawn Wang
I mean, there are all sorts of tricks that you can do, like you add in some versioning or whatever, but—
Yeah, but it's, in general, very complicated. At my keynote, I asked the audience to put up their hand if they love their CDC pipeline. Only maybe 2 people put it up. So, at SingleStore, about maybe a decade ago, I think the industry had this idea: “Hey, what if I built a single database that can handle both workloads?”
Shawn Wang
Which, by the way, every database person has always dreamed about.
Yes, this is the holy grail of database engineering. Why not build a single system that can do both of these? But it ends up just being a lot of compromises. One, I think the first issue is that each— they say Postgres has a massive ecosystem, right? You want to be using the tools that are built for Postgres, and Spark, for example, has a massive ecosystem. There are a lot of libraries you want to use. If you were to create a new thing, you don't have an ecosystem; you tend to create a new, smaller proprietary API, and you're lacking both.
It's also very difficult to make it performant enough to be comparable on either side. So it ends up actually sucking at both. And our whole idea of LTAP—obviously a wordplay on the term HTAP—is that we think this is HTAP done right. HTAP wants to build a single engine for both. We think you can get 99% of what you need by unifying the storage and just having a single storage layer.
Once you have the single storage layer, if your Postgres databases are writing data in a column-oriented format, everything analytics can just go read that data directly without any delay, right? There's no pipeline in between, so all the data would immediately be available for reasoning and analytics.
I think I was telling some customers earlier that when we talked about this, it was going to be super useful for agents. At first, I didn't really believe in it myself, even though we wrote that positioning. But last night I was having dinner with an Australian customer, and they told me, “One of the big issues we have is that we have all these logs from our services, and we see SLA dips and want to investigate. But there's no way for those agents to even understand what's going on in the actual databases themselves.”
All we see is just product telemetry of the database and the services. You would actually make those agents 10 times more powerful if they understood, for example, who's actually placing those orders, what is happening, and what exactly they're doing. So now I'm actually sold on our own message.
Shawn Wang
Yeah.
I think it really gets you almost all of the benefits of the HTAP holy grail, which is: make the data available immediately for reasoning and analytics.
Shawn Wang
Yeah, I think the way that humans are generally intelligent and want to have the ability and access to query anything, even while they do the work, they also need history and context. Where else do they get context? That's an analytical workload.
Exactly. [Laughter.]
Shawn Wang
Yeah, I remember when we had incidents with our databases and the engineer said, “Well, I can't just run a giant query on it to see what's going on, because that's going to bring down the database and hurt it even more.” That's the kind of stuff that this gets rid of, because you spin up a whole separate fleet of machines that's doing the analytics. You're not overloading the main database that's still trying to serve stuff.
Yeah.
Shawn Wang
So this has been a dream for a while. What had to get done in order to get to today? I feel like you've announced variants of this several times, but it wasn't as clear as LTAP. Yeah. I think LTAP is like, okay, we've got it, guys.
I was talking to somebody at Meta, and he was asking me, “What's the catch? Why is it possible now?” I think the reality is we took a lot of time to actually work on the Lakebase architecture. Obviously, a lot of it came from the Neon team, which is separation of storage from compute. And it turned out it was just a tiny little step away, going from that to this LTAP idea. In the Neon architecture and in the Lakebase architecture, we're writing data in row-oriented format to the open data lake.
But in there, we're writing in Postgres pages. Actually, Ali and I were spending a lot of time debating: can we actually just change that to write in column-oriented format? We were just debating, and then one day, one of our engineers, who's actually super smart, came in and said, “Hey, I just prototyped it. It works.”
Shawn Wang
Wait, prototype what?
Prototype instead of storing the data in the data lake in row-oriented format.
Shawn Wang
Like Postgres pages—write them in Parquet?
Yeah. He just made the observation that our storage fleet has a lot of extra idle CPUs. We could use those CPUs to do the transcoding from row to column, where row is good for OLTP, but column is good for analytics.
So let's do the transcoding at that time. As a matter of fact, once you transcode the data, it compresses better. So, for those services writing to, for example, S3 or other data-lake-like object stores, you can actually write the data faster because it's smaller.
Shawn Wang
Yeah.
So there's no overhead—there's no compromise in performance.
Shawn Wang
Overhead?
Yeah, but we had extra CPUs anyway.
Shawn Wang
The fleet anyway, yeah.
So the debate ended. It's one of the classics of the tech industry: a lot of debate, but then somebody actually went ahead and just tried to prototype it, and it worked.
Shawn Wang
But something this strategic and important to the company—I expect there to be a kickoff thing, like a design doc. Nothing like that?
Nothing like that. We were debating in many, many meetings, debating whether it was possible or not from first principles, and then somebody just did it.
Shawn Wang
Yeah, if you set yourself up so people do that, that would be great. That happened a bit with OmniGen too. If I just had a doc and we could make this together, everyone would think, “What about this? What about this?” But if you try it out, it helps. If you have real users and they bash it, and it's still working—or, in this case, if you have the workload and you know what the workload looks like—you can just test the same pattern.
Tech aside, which is very cool, this is the most important thing: the culture of innovation. You don't have to ask my permission, and you don't have to go through a whole formal process. Just do it.
Well, especially these days, I think with AI, it's actually easier to do that.
Shawn Wang
I think you're very right. I've met a lot of C-suite executives at large companies, and I think that at scale, things slow down. I'm sure you've felt it already, but somehow you have this core of people who are exempt.
How?
I think we hire and work with really, really good people, and that's a very important part of it. Empowering them, but also spending a lot of time with us in the trenches, matters a lot too.
I think first, people could adapt to being in the larger company, so that helps. We want to make sure they know that they can try stuff, settle debates, and have a lot of examples of how it was done before, or launch a thing in beta, or whatever.
The other thing we encourage a lot is: instead of trying to boil the ocean for everything, let's figure out how to do it incrementally and very quickly. Many of our products are built in the span of weeks. Usually, my first question to whoever is building something is, “Who's the target customer? Who are you working with? Are you on a first-name basis with them? Are you texting with them?” I think having that very tight loop helps.
Shawn Wang
Can you bring up another launch that comes to mind within this kind of thing? I just want to give you some background on that.
It was more of an internal thing, actually, because we would use that for our developers. Basically, the whole AI team got access to it and was using it, and we made sure it worked from the beginning with our internal code base, which is an enormous monorepo. We gave them some infrastructure and lots of token capacity. So it was all the developers.
Yeah, we had others. I don't—this is, I think, a public story, but—
Shawn Wang
I was going to ask about Marketplace and Delta Sharing. Did all of them have that? I just don't remember exactly which ones publicly referenced it.
Yeah, they had others. Well, very early in the company, there was Delta Lake, which is the transactional storage layer we built. Our largest customer at the time said, “Okay, I need something in the cloud because, if the rest of our network is compromised, this thing needs to be separate to store and query the events.”
Then they talked to us and said, “Okay, this is the rate of events per second. This is the freshness I want. Can you do it?” That was way larger than any workload we had. We had our engineer, Michael Armbrust, working on that, and he worked just to make it work. Once it worked for them, it worked for everyone else. This was early in the company, probably 4 years in or so.
Shawn Wang
2018?
Ali Ghodsi
Yeah, 2017, 2018.
Clean Rooms, which is basically how you share data without sharing the underlying data, but still allow specific operations, was initially done just for 2 customers. I think the industry has a sense of, “Maybe if you overfit to 1 or 2 customers, it's going to be really bad for you,” but I think the downside of overfitting is much smaller than the upside itself. If you try to be too ambitious and boil the ocean, it's a much bigger problem.
Shawn Wang
Yeah, because you might end up actually having no customer.
Ali Ghodsi
Yeah, that's the more likely outcome. Then you can sort of pivot from there. I do think there is such a thing as a bad customer that sometimes you should fire.
One of the challenges we probably see—and maybe many AI and newer-generation companies are seeing—is that tech companies are very different from non-tech companies or traditional enterprises. If you optimize everything just for tech companies, you might have very big challenges scaling outside of tech companies.
Shawn Wang
Okay, what are the top 3 differences that you always think about?
Ali Ghodsi
Yeah, a big one is security, data privacy, governance, all that stuff. Usually, if you're building some kind of B2B or developer tool, your biggest market is going to be enterprises, but it's very different when you're dealing with a company that's existed for 30 years and has had some form of IT for that long. They have so many legacy systems, or they operate in a regulated space.
Whereas a startup, or even a more recent tech company, has everything new and sort of pristine. It's just different, and if you've never worked with enterprises or been in one, you just won't know about it.
Shawn Wang
And the procurement process is probably quite different. There are actually far more stakeholders.
Ali Ghodsi
That is one. Yeah. Another piece that's interesting is that, in some tech companies, people will say, “Oh, I can build that myself. I'll just build that myself.” So then you go—
Shawn Wang
I don't think people say that about Databricks.
Ali Ghodsi
They do. It depends on the teams and things. But, on the other hand, many of the enterprises say, “Actually, I don't—I never want to be in the business of building that. I don't want my—whatever, I'm a retailer or something—I never want to be down because some weird nerd couldn't get streaming pipelines working.”
Shawn Wang
Yeah, this makes them great customers, to be honest, right?
Ali Ghodsi
But you have to understand that it's hard without having worked there and stuff. You may not appreciate it.
Shawn Wang
Look, I think they're all great. Don't get me wrong. They have different challenges. But many of the tech companies, for sure, are far more DIY.
Ali Ghodsi
On the flip side, you have people who are very much experts in their domain. They're building airplanes, designing medicines, whatever, and they just want a bridge to the knowledge. They don't want to learn databases or whatever, as cool as we think it is, or as interesting as the average software engineer might think it is to read a little bit. They just never want to know.
They just say, “I have this giant matrix or whatever with my clinical data. How do I cluster it or whatever?”
Shawn Wang
Yeah, that's true. Okay, so then I wanted to actually build out the dream engine vision.
[Laughter]
Where does this all lead?
Ali Ghodsi
One of the things we realized maybe a couple of years back is that every single database engine out there, especially on the analytic side, is kind of a decade old. Pretty much everything that has reasonable traction is about a decade old.
They all started by targeting some very specific, narrow use cases. Over time, they became more and more successful, grew in their ambition, and tried to support more and more use cases. But the fastest way to support those use cases tends to be to hack around what was initially created. Those systems were not built for those use cases, but you can support them more or less okay. Before you know it, after 10 years of organic evolution that way, it becomes a gigantic pile of technical debt. That includes Databricks.
Very few companies or systems, I think, have the guts to say, “Let’s go start from scratch. Let’s go back to the drawing board and design, knowing everything we know today after a decade of workflows and probably billions in revenue. Let’s attempt to rewrite it from scratch and actually make sure it works and can support all these use cases.” So we started doing that.
But it’s a very ambitious project. By the way, you can search on Wikipedia for this thing called second-system effect.
Shawn Wang
Yeah, I know that. Every developer must know what second-system effect is.
Ali Ghodsi
It’s basically: You build your first thing, and it works out great, and the second one is bound to fail because it’s too ambitious.
Shawn Wang
You think you know everything, and then you’re like, “I’m going to design the perfect system this time.”
Ali Ghodsi
Yeah, and it turns out it’s not perfect, and then it starts failing. You’re too ambitious, you never launch, and you get killed.
The engineering team that actually started this was brilliant. I think we hired some of the best database engineers on the planet into Databricks, and they were brilliant. Thank God it’s not their second system. Many of them have built more than 2 in the past.
Shawn Wang
Nice.
Ali Ghodsi
But they were still worried about this. “Hey, building a database engine from scratch—I think the conventional wisdom is that it’s going to take, like, 5 years to mature. This will be a very long-term project. It could fail.”
One of the engineers was kind of joking and said, “Hey, maybe we just call it Project Stream Engine.” If we name it after a co-founder, maybe we don’t get canceled or killed.
But I think they built something pretty remarkable. They went back to the drawing board and changed the way database engines were built from a paradigm point of view.
Usually, when you build a database engine, you read a lot of academic papers, try to understand the latest algorithms and data structures, and put them together to see whether they work or not. There’s a high risk of failure there as well, because whatever looks really good on paper might work really well in 70% of the workloads, but then backfire on the other 30%.
They actually went and built more of a factory for building databases. They spent more time building this factory, and the factory takes the decade of traces we have. I think they count as a quadrillion data points in the trace table.
Shawn Wang
You don’t drop anything? Or do you sample?
Ali Ghodsi
We for sure sample, but there’s still a massive amount of data. They use that to build a model—a machine learning model, not an LLM. The machine learning model can very, very quickly tell us how any algorithm and any implementation will perform for any specific type of query with very, very high fidelity.
Based on that, they can pick the most likely algorithm and data structure that will actually help with the different kinds of workloads.
Shawn Wang
Mhm.
Ali Ghodsi
That happens both at runtime and at implementation time.
Shawn Wang
Mhm.
Shawn Wang
I mean, it sounds like you want to route to different data structures.
Ali Ghodsi
Yeah. If you think about it, a single database has many things implemented together, but you want to make sure they all work well with each other. For any given operation, there might be more than 1 implementation.
The reality is that an algorithm that works super well, for example, for very, very low latency might not work very well for, say, scanning through petabytes of data. Most often, there’s a trade-off between throughput and latency.
Shawn Wang
What are the key dimensions? Scale, throughput, latency—what else?
Ali Ghodsi
The distribution of data.
Shawn Wang
Yeah.
Ali Ghodsi
Right. How sparse the data is. That matters a lot. How frequently do you hit the same data?
Shawn Wang
Yeah. How many distinct values and stuff like that?
Ali Ghodsi
Those things matter a lot. The number of distinct values basically impacts the memory consumption of your aggregation hash table. At some point, there’s a hash table.
Shawn Wang
That’s something I’m going to try to list in my write-up. I really want a taxonomy. To me, taxonomies are so helpful because they cover everything you should think about.
Ali Ghodsi
I think if you actually try to list it out, there are probably a million different features.
Shawn Wang
[Laughter]
I always want, like, “Okay, give me 12.”
[Laughter]
You know, someone did an original paper, like, 40 years ago, about the 8 fallacies of distributed systems. That kind of thing is super useful.
Ali Ghodsi
Yeah, that’s it.
Shawn Wang
It’s like, “Okay, think through these 8.”
Ali Ghodsi
But let me give you a very weird example that actually has a profound implication for performance: Is your string ASCII, or does it have Unicode in it? How should I encode this?
Shawn Wang
I mean, strings are the most complex data types.
[Laughter]
Ali Ghodsi
For example, if strings are super dense, you could actually convert every string into a number. Imagine I have to do an aggregation. Instead of having a hash table, you could actually have an array, because if your string is dense enough—if you only have 256 options—you don’t need a hash table. You can just do an array lookup.
Shawn Wang
Like a country code or something.
Ali Ghodsi
Yeah. So there are probably millions of features in that model. Using that, they can, one, basically prioritize the different algorithms that might actually impact performance in practice.
Many of them are very counterintuitive. Things that you think might work super well actually don’t work that well in practice. More importantly, at runtime, you can dispatch the right algorithm and data structure.
Shawn Wang
I’m listening to the dream. I feel like Databricks is doing a really good job with the incremental evolution. Do you have to hard-cut to a new system at any point?
Ali Ghodsi
We designed it in a way that it can be incremental. First, we’re releasing a new endpoint.
But this goes to the broader notion of what we wanted to do. By design, this new engine should be able to do everything we’re able to do before, and better. The better part refers in particular to very low-latency workloads that can finish in tens of milliseconds.
But we want to roll it out incrementally, with incremental capabilities, so it doesn’t take 5 years to actually see the light at the end of the tunnel.
Shawn Wang
I think that’s a heroic task. I don’t know what other way to say it. I’m really interested in any sort of new workload and new databases. Obviously, I think I’ve maybe established that I’m a little bit of a database nerd.
The accounting databases, like TigerBeetle—I don’t know if you’ve seen those.
Ion Stoica
What do they do?
Shawn Wang
It’s a double-entry accounting database. It’s just meant to really model financial accounts and credit systems.
Ion Stoica
It’s like a very specific database.
Shawn Wang
Very high-throughput, yeah. Yeah. No, it’s exactly that. When you were talking about how everyone starts with a thing, then scales up, and then tacks on other things, it’s exactly that.
I recently interviewed Simon from Turbopuffer—same thing. Chroma as well. All the vector database companies of 2023 are suddenly now just generally general-purpose blob storage.
Ion Stoica
Especially, a vector database should never have been a separate category.
[Laughter]
Shawn Wang
I think that used to be a hot take. Now it’s the conventional wisdom nowadays. What should be a separate category? If everything becomes ELT, what’s—
Ion Stoica
I think the thesis of ELT is that we’re not collapsing the databases at the actual query layer. We’re just collapsing the storage layer. That’s a very important part.
We actually don’t think it makes sense to collapse the query layer into a single HTAP-style database. Part of it, by the way, is that a lot of people say, “Hey, it would be nice if there was only 1 query language I had to worry about instead of worrying about PostgreSQL and maybe Spark SQL. Why not just 1?”
But I don’t think that’s an issue for agents. Agents are very fluent in PostgreSQL or Spark SQL. They’re never going to get confused. As long as the data is there and accessible, agents will do fine.
That might have been—
Shawn Wang
Yeah, and the—
Ion Stoica
5 years ago might have been a problem for humans.
Shawn Wang
That could arise over time also, but it should. This leads to how to do things incrementally, right? We realize you don’t need it right now.
Ion Stoica
We don't need to solve that problem to have a lot of value from the current Delta app.
Shawn Wang
Yeah, okay. I'm going to end the pod with a bit of a spicier thing. Everyone has had the received wisdom around separation of storage and compute and tried to build the cloud. I had the same pitches from Snowflake. How have you succeeded where they failed?
Rough. Well, I respect that they're a competitor. Objectively, you have outpaced them.
What is the core insight, from your point of view, that you guys just took in a different direction?
Ion Stoica
Probably the biggest fundamental difference is that one is open. Both companies started around the same time. Both went to the cloud. Both focused on a separation-of-storage-and-compute architecture. But the biggest difference is that Databricks had never had a proprietary format, right? We started with the open ecosystem. We started with Parquet and then evolved into Delta and Iceberg and all that. It's like one big thing. I think that matters a lot. The other one is AI.
Before October 2022, when ChatGPT came out, we had always pitched Databricks as machine learning plus data. A lot of the platform was built with machine-learning use cases in mind. Obviously, AI is a little bit different, and Matei has spent far more time there than I do. But the whole platform was—we never felt, hey, we're just a data infrastructure platform.
Shawn Wang
Like Databricks only, yeah.
Ion Stoica
I think they started with—they thought, okay, we'll just manage the most valuable data and try to make it really fast. For that, we'll have our own storage, which is optimized with the engine. Then we'll just target the small amount of data that managers, finance people, and so on look at and make that super fast to serve.
It was a different space, whereas we started with: we'll do the bulk processing and ingest. You've got a bunch of JSON log files, you've got whatever—we do that very large-scale stuff because that's what Spark was for: large-scale batch-processing stuff. Then we'll keep the data in an open format. It might be slower, but it's already out there, and you can consume it downstream.
It turned out that it's easier to go from that batch thing that's really good at scale and ingesting and is super low-cost, and create versions of it that have the speed and features of the super-easy-to-use, smaller-data-for-business-users thing.
Shawn Wang
And then there's OPTIMIZE.
Ion Stoica
Yeah, start open and start large. In some sense, we started upstream of them. There was a time when we both listed each other as partners, because if you used both solutions together—Databricks for your ingest and compute, and then served the tables out of Snowflake—you got all the visualization and all the really fast stuff. That's great.
Then we both realized customers were telling us, "Why do I need this other thing? Why can't I just query your tables?" And we said, "No, we're horrible at that. Please use our partner for the SQL warehouse stuff." Then they realized, "Wait a minute, so much of the compute is moving upstream into this other thing."
Shawn Wang
You have to go into each other's territory, yeah.
Ion Stoica
But I think we did start with the bigger scope and with the open thing. That's important, actually. If your company's existed for 30 years, you've experienced being locked into Oracle and all kinds of crazy things. If you're the CTO there and you're setting up the architecture for the future of your company, you're going to want to pick a foundation that's open. You only want one way to manage data in your company, ideally. You don't want 7 different systems.
Shawn Wang
But I think the data formats have won. I think now every enterprise wants to put data in open data formats.
Ion Stoica
But it was actually very controversial back then. I think 5 or 6 years ago, one of the Snowflake co-founders actually wrote a blog called "Choosing Open Wisely," which basically argued against—
Shawn Wang
Yeah, yeah.
Ion Stoica
I think they might have taken it down. You have to find the archive now.
Shawn Wang
Oh, I mean, it's never going away now. No, no, it's still there. I love the perspective that only you guys will have because, obviously, you run the company. Thank you for indulging this. It's an incredible perspective.
Ion Stoica
Maybe one last one. As you were talking, I think I have to give Ali a lot of credit.
Shawn Wang
Mhm.
Ion Stoica
He's an incredible CEO. I think he's the perfect combination of IQ, EQ, technology obsession, execution, and business acumen.
Shawn Wang
Mhm.
Ion Stoica
He's also a founder, which makes it a lot easier for him—
Shawn Wang
Yeah.
Ion Stoica
—to mobilize and execute. I think that's—
Shawn Wang
Oh, that was it. So, did you have Ali? Okay.
Ion Stoica
Well, there's a whole lot of other things, but I think Ali played a pretty big role in the—
Shawn Wang
I thought there was going to be some technical choice that he contributed to.
Ion Stoica
He pushed for a lot of these. There were forks in the road where he pushed for one way, and then it became clear that that was the right way.
Shawn Wang
Second one, not a clear question again: Mosaic. A lot of people in our community are curious about the model story of Databricks. When you guys bought Mosaic, the thing was like, "Okay, well, we can do fine-tuning. We're going to do an in-house model," because they had the Mosaic models. It seems like you're not doing that, and it seems like you're going toward more of the AI apps and the harness stuff. What's the story there?
Ion Stoica
When Mosaic started, I think it was well known, or became most well known, for releasing open-source LLMs early on, and they were general models. Actually, before that, they were doing other things. They were focused on optimizing training systems, basically. They had the fastest image-model training stack in the world and stuff like that.
Then they decided to do LLMs, which was smart. They moved into it before ChatGPT, so they had some of the first open-source LLMs.
Shawn Wang
Yeah. We interviewed Jonathan Frankle and Abhi for MPT-7B.
Ion Stoica
Yeah, exactly. Oh, yeah, very cool. We decided that even though we did launch an open-source model, DBRX, and went up to above the Llama 3 scale, we decided that we really wanted to focus on the next step. There would be so many people releasing models, and instead of doing the general model, where a big part of the recipe is just throwing a lot of compute at scale, we wanted to focus on the next step: let's say you have the very smart model. How do you make it useful?
For us, it was a lot about automating how to make it very good at querying data. That's the first-party agent we have called Genie. It's like a virtual data scientist. Imagine there's someone who already knows all the stuff in your company inside out and knows all the machine-learning libraries, all the data libraries, all the stuff on the web, and you can ask them questions. That's what we wanted to do first.
That meant, let's not focus as much on just training some kind of frontier model, but let's build a system using either external models or fine-tuned, customized components. We're still doing quite a bit of model training, though. In fact, we're always procuring lots of GPUs and stuff to do it.
There are a few places where we're doing that. One is that there are many high-volume use cases where, if you have a specialized model, it's just so much better than any of the general models you get. A nice example of that is understanding documents—PDFs, Word documents, stuff like that—and parsing them.
If you've ever tried to do that, it's frustrating because you send it to Claude Opus or whatever, and it almost gets it, but it gets some things wrong. It's super expensive. You just burned a huge amount of tokens plopping an image into there.
Our team built this document-vision model that takes a page and gives you back nice JSON with all the components. It's very competitive. It's probably 100 times cheaper than those frontier models and still better. That's actually done by one of the researchers who came from DeepMind and was a co-founder of Adept, a very early LLM-scaling person, but focused on this.
Likewise, we're doing specialized sub-agents for part of what the coding agent does. If you've seen the stuff on advisor models from Harvey, also from—
And Anthropic's Claude Code as well, yeah.
—and UC Berkeley, actually, one of my grad students there wrote a paper called "Advisor Models." I think it came out before those did. I'm sure others had the idea at the same time, but that's something that helps a ton.
We actually showed some stuff just today at the keynote on—
Is it Parth? Oh, you know Parth?
Parth, yeah, yeah. Parth is—
—speaking at my thing.
He's speaking at Continual Learning Bench.
Yes, yes. I'm one of his advisors at Adept, yeah.
I interviewed his brother, Chai, because he's also at Adept.
Yeah. Yeah.
That family's very smart.
Ion Stoica
Yeah. They're awesome. [laughter]
We're doing some of that, and as we get experience with these in the first-party agents, we're also doing them with customers. My feeling is that customizing models is actually going to get way easier over time. That's what we're finding, because the base models are smarter, so they generate better traces in RL already, and RL is about learning from your own past traces.
Synthetic data generation is way better and way easier now. We have pipelines just using open-source models. The same model generates training environments and trains itself and beats Opus and GPT-5.5 and stuff at a task. So I do think it's going to pick up. The ease of training the algorithms is only going to go up over time.
There's a question of when it crosses into the mainstream. Instead of just the specialized document-parsing thing we did, where you need a hardcore LLM researcher, when does it get easy enough that anyone can plop in some stuff and describe a task?
Yeah. Well, you know what makes it easy? Interfaces and unified APIs. Obviously, if it's not interoperable, then you cannot switch.
That's what we're seeing with Omnigent and the composable agents. You can have sub-agents with specialized models, and then you can train the whole thing. I think that'll help a lot, too.
The last thing I was going to leave you with—I'm sequencing this, so I'm actually kind of proud of myself—is Satya. He's talking about this. I interviewed him at Microsoft Build a couple of weeks ago, and then he wrote this essay, which I'm sure you've seen, about the whole model-building frontier ecosystem. He sounded, when I was talking to him, more like a Databricks CEO. [laughter]
Uh-huh.
Is there—I mean, this thing presumably went viral in my circles. I don't know if it did in your circles. What's the theory of, I guess, tokens as IP, building up the context? He basically said everything, but data is the new oil, or context is the new oil—some version of that that you guys have heard before.
Ion Stoica
Yeah, I agree. I think the data you have, as you get better technology around that, you can just do more in your domain with it. It's not even just about AI. Even when people started collecting stuff in real time, I remember all the power companies put in smart meters and stuff, and all the car manufacturers started putting in sensors and cameras and stuff.
Any technology makes data more valuable and can give you some advantage—anything that helps you do something with it and make some decisions. AI is the same way. You had all this stuff that's just sitting there. Now you can have an agent automatically tell you. For example, I discovered a feature in my product was broken because a customer complained. The agent tells me, “I noticed no one is uploading files anymore because they got errors,” or whatever.
As you saw with Lakebase, as a database company, because we have all this history of all the queries and all the table layouts and how they work, we can build a new engine very quickly that's actually good, and we're confident that it's going to be good. So I think this is right. I think the question is exactly how it will land, but I do think custom model customization, which Sajid talked about, is going to get easier over time.
Yeah.
Which is why, by the way, I brought up the model thing, because they have their Mosaic AI things and you guys don't. That was the mental question.
Ion Stoica
Yeah, we do have—we're doing RL fine-tuning as a service with a bunch of customers. We have preview customers, and we have a general offering called AI Runtime. We get you GPU clusters on demand with a software stack in there that makes it easy to do training.
So we didn't—but that's existed for a while. We've had GPU compute for a while, and that's where a lot of the Mosaic stack went to help scale that.
Yeah.
Ion Stoica
But we found that the engagements—there are 2 types of customers. There are some who just want GPUs and libraries to get data in and out and monitors. That's what AI Runtime is. And then there are some that say, “Hey, can you actually work with me, build evals, build synthetic data—”
Yeah. The more forward-deployed solutions architects.
That's what we're doing. As more things transition from being custom to not, that's sort of how it is today.
Going back to the original question, I think one of the theses we have is that, once you can get the data in the right place, the AI models are becoming pretty good. The generic agents are fairly good. I mean, I think I heard you talking about AGI already being here. They have pretty good reasoning capabilities.
Actually, I think many of the traditional software systems will be rewritten with this new paradigm, which is just getting the data to be there. Then they slap some agent on top. Magic will come out.
Yeah. But without the right data, you can't really do that. And it's actually our approach to going into security and our approach to going into the customer data platform space.
We launched 2 products at Data + AI Summit, one targeting security teams and the other targeting marketing teams. Those all have a lot of existing technologies out there. I think our approach is just, “Hey, once you get the data in, everything is a lot easier with agents on top.”
Yeah. Yeah. Well, you guys have been fantastic guests. I just love this discussion. I love the ability to dive in on the tech side, but also culture and strategy. I hope this isn't the last time we chat. Congrats on all the success so far.
Thank you. Congrats on your success also. [clears throat]
Yeah.
Databricks is actually supporting my event. I run a conference. I've been an attendee of Data + AI Summit for a long time, and I noticed that it was kind of—this is back in 2022—90% data and then 10% AI. I thought, “Well, okay, we need a community thing that's just 90% AI.”
Ion Stoica
Yeah, yeah, that works.
So Databricks will be at the conference, and it's just amazing to see you guys build out the most interesting cloud that I have ever seen outside of the Big 3. It's amazing how far you've grown.
One of the most insightful things—I don't know, I'm not a VC, but I play one on TV—was when Ben Horowitz was talking to you guys, advising you on where this company was going. He was like, “Don't sell until $100 billion,” or some version of that story, right?
It was like, “The company should be worth a trillion dollars. You're underselling it for $10 billion.”
And he doesn't do that for everyone.
[laughter]
For some reason, I think he saw the vision, but also the infinite runway that you have.
We're lucky to have Ben. Yeah, he's a big supporter.
Yeah, amazing. Okay, well, thank you so much.
All right, thank you so much, swyx.