Ontology MCP | Ontology-Powered Tools for Internal Planning

频道: Palantir
视频: https://www.youtube.com/watch?v=bJsHKMUqCvg
原文语言: en
统计: 共 37 轮

[0:00]

Hi, I'm Chad Wahlquist, I'm an architect at Palantir. Today I've got Mike, who leads one of our internal teams that drives Foundry use inside of Palantir. Thanks for joining me, Mike.Thanks, Chad. Excited to be here.So we've got a fun topic. This is something we hear a lot about with MCP. We've got the Platform MCP, Ontology MCP, all this use, and I think no one better to describe kind of some really cool use cases of this than you and how we're doing it.So maybe you just can give a riff on what your take is on like specifically like the Ontology MCP and then we can get into how we're using it.Yeah, definitely. Yeah, so as you mentioned, I've been focusing on our internal use of Foundry for quite a while here at Palantir.And we've built at this point a pretty large, robust Ontology that covers basically all of our connected internal systems and Foundry itself has become the source system for a lot of our workflows here.So we have a pretty good baseline to work from. We've got a large set of internal apps that people have built and Workshop and custom apps and OSDK and all kinds of other things going on.And, you know, in the last couple of years, obviously, we've onboarded several AI tools in addition to everything that we've been doing in Foundry.

Chad： 大家好，我是 Chad Wahlquist，Palantir 的架构师。今天请到了 Mike，他带着我们内部的一个团队，专门推动 Foundry 在 Palantir 内部的使用。Mike，谢谢你来参加。

Mike： 谢谢 Chad，很高兴来到这里。

Chad： 今天这个话题挺好玩的。这是围绕 MCP 我们经常听到的话题——我们有 Platform MCP、有 Ontology MCP，各种用法都有。要讲讲这里面一些真正很酷的用例、讲讲我们自己是怎么做的，我觉得没人比你更合适了。要不你先随便聊聊你的看法，具体说说 Ontology MCP，然后我们再展开讲我们是怎么用它的。

Mike： 好，没问题。就像你说的，我在 Palantir 专注做 Foundry 的内部使用已经有好一阵子了。到现在，我们已经建起了一个规模相当大、也相当扎实的本体（Ontology），基本覆盖了我们所有接入的内部系统；而且 Foundry 本身已经成了我们这里很多工作流的源系统。所以我们的底子相当不错。大家已经做了一大批内部应用——有用 Workshop 搭的，有自定义应用，有基于 OSDK 的，还有各种各样别的东西在跑。另外你也知道，过去这两年，除了在 Foundry 里做的这些事，我们显然还引入了好几款 AI 工具。

[1:23]

So this year we rolled out OMCP, basically the Ontology MCP server, to connect all of those workflows that were happening in our AI tools with our internal Foundry instance.And so far, it's been really valuable.We have basically started using it for a bunch of internal use cases.The one that I'm going to talk about today is more on the internal planning side.And some of the stuff we're going to cover is basically how you set it up, a little bit about how it works generally, and some of the benefits of it.And then I'll actually run through like what planning looks like notionally internally here.So we do this three times a year.And yeah, it's been made a lot easier with OMCP.Yeah, I think it's cool because like, you know, we talk about how we help customers and how we want to ontologize their business.Like, we have ontologized and we build our entire business in Ontology.So kind of this is the North Star of like, if you have everything ontologized in your business, these are the cool things you can go do, like have an MCP server for your entire business.You know, so I think it's pretty cool to get into it.So, all right, let's just jump into the demo.Let's show some cool stuff here.Yeah, let's do it.

Mike： 所以今年我们上线了 OMCP，也就是 Ontology MCP 服务器，把大家在各种 AI 工具里跑的那些工作流，跟我们内部的 Foundry 实例连通起来。到目前为止，它真的非常有价值，我们基本上已经把它用到了一大堆内部场景里。今天我要讲的这个偏内部规划这一块。我们会讲到的内容大致包括：怎么把它配置起来、它总体上是怎么运作的，还有它能带来的一些好处。然后我会实际走一遍，示意性地展示我们内部做规划大概是什么样子。我们一年要做三次规划。嗯，有了 OMCP 之后，这件事轻松了很多。

Chad： 对，我觉得这件事很酷，因为你知道，我们平时总在讲怎么帮助客户、怎么把客户的业务本体化。而我们自己就已经本体化了——我们整个公司的业务都建在本体上。所以这某种程度上就是一个北极星：如果你把业务里的一切都本体化了，你就能去做这些很酷的事，比如给你的整个业务配一个 MCP 服务器。所以我觉得深入聊聊这个挺有意思的。好，那我们直接进入演示吧，给大家看点酷东西。

Mike： 好，开始吧。

[2:38]

Yeah, I mean, one of the big benefits here is that, I mean, as we've explored with our sort of other internal AI tools, it's very easy to get into this kind of nest of MCP servers and individual connections to things.And going, you know, you're going to Slack, you're going to this and that.And it gets, it's very sort of bespoke per user.A lot of people don't engage with it at all.And what OMCP is letting us do is just have them connect to one thing.All the data they need is already there.It's already modeled.They can just start making use of it.And they can start writing back to it as well.So what I'll start with here.On that thread real quick, though.So, like, I think what you're saying here is important because instead of having an MCP server for every different kind of system, by modeling all of that into the ontology and then giving them one MCP server, that means I not just encode the system pieces, but the actual business processes across those systems and how they interact.So they're much more useful.So, like, I think really the thought here is one MCP server model and the business process backed by systems rather than 20 different MCP servers on each system is far more effective for the end users because of that business process modeling on top of it.

Mike： 嗯，我是说，这里一个很大的好处是——我们在摸索内部其他那些 AI 工具的时候发现，很容易就陷进一团乱麻：一大堆 MCP 服务器，各自单独连着各种东西。你要去连 Slack，要去连这个、连那个。结果就变得非常因人而异，每个用户都是自己定制的一套。很多人干脆完全不去碰它。而 OMCP 让我们做到的，就是让大家只连一个东西就行。他们需要的所有数据都已经在那儿了，而且已经建好模了，拿来就能开始用，还能往回写数据。那我这里先要讲的是——

Chad： 等等，顺着这个话头我先插一句。我觉得你说的这点很重要：不是给每一种系统各配一个 MCP 服务器，而是把这些全都建模进本体，再只给大家一个 MCP 服务器——这意味着我编码进去的不只是各个系统本身，还有横跨这些系统的真实业务流程，以及它们之间是怎么相互作用的，所以会有用得多。我觉得真正的思路是：一个 MCP 服务器，建模的是由各个系统支撑起来的业务流程；而不是每个系统上各挂一个、总共 20 个不同的 MCP 服务器。正因为上面多了这层业务流程建模，前者对终端用户来说要有效得多。

[3:49]

Yeah, exactly.And I think where you feel it the most is the way that you model all the interconnections between different object types.So if you have five different MCP servers and you just throw your AI tool of choice at it and say, like, deconflict all these things, find patterns, it's going to do it a little differently every time.It's going to be pretty error prone.It's going to take a lot of time.It's going to burn a lot of tokens.But having it all modeled in the MCP is, let us say, like, get a lot closer to kind of one-shotting these analyses, getting data back in a way that it can actually work with.And you end up with some pretty nice output at the end of it.All right.Cool.Let's get into it.All right.Great.Yeah.So to start, let's talk about how we set this thing up.As someone that's sort of administrating this, it's really exciting and easy for me.Basically, all this happens out of a Foundry dev console.This is the same place that you would go if you were building, like, a custom OSDK app or something like that.So we have a demo one here.The first step is you have your Ontology SDK.This is where you're actually going to define what objects you want to make available to your MCP server.

Mike： 对，完全是这样。我觉得感受最明显的地方，在于你怎么去建模不同 object type（对象类型）之间的所有相互关联。假如你有五个不同的 MCP 服务器，随手丢给你惯用的某个 AI 工具，跟它说「把这些东西之间的冲突理清楚、找找规律」，它每次做出来都会有点不一样，很容易出错，要花很多时间，还会烧掉大量 token。而把这一切都在 MCP 里建模好之后，我们离「一次就把这些分析做对」近了很多，拿回来的数据也是它真正能直接处理的形式。最后你会得到相当不错的产出。

Chad： 好，酷，那我们开始吧。

Mike： 好的，很好。那首先来讲讲我们是怎么把这套东西配置起来的。作为管理这套东西的人，我觉得这事真的很让人兴奋，而且对我来说很简单。基本上所有操作都在 Foundry 的 dev console（开发者控制台）里完成——如果你要做一个自定义的 OSDK 应用之类的东西，也是来这个地方。我们这里有一个演示用的。第一步是你的 Ontology SDK，你要在这里真正定义好，想把哪些对象开放给你的 MCP 服务器。

[4:54]

So you can, and we do use these in a couple of different ways.You can either go for breadth and you just add sort of everything you've gotten here.Or you can do more use case specific ones if you wanted to have more, like, very targeted use case MCP servers.For this case, we tend to bias more towards the broad ones.And it does a good job of actually, like, navigating all those objects.So in this case, we have, as I mentioned, we're sort of focusing on planning here.So this is sort of a minimized version of the Ontology that we have internally.We've got a few object types that sort of represent the org.We've got developers.We have some teams in here.We have some objects that represent our actual plans.So we have planned objects, objectives, key results.And then we have some of our source systems.So we've got, like, you know, chat messages, support tickets.And then a few things from, like, you know, GitHub pull requests, GitHub issues.These are, you know, a subset of the things we would use in the real world.But they're pretty representative of the type of data that we would rely on if we were trying to retrospect on how our team was doing or start to plan or anything like that.But I think the other piece here you kind of briefly hit on was, like, it's not just the data, though.

Mike： 这里你可以——我们自己其实也有好几种不同的用法。你可以追求覆盖面，把你手头有的东西基本全加进去；也可以做更针对具体用例的版本，如果你想要那种目标非常明确、专门服务某个用例的 MCP 服务器的话。在这个场景里，我们更偏向覆盖面广的那种，而它在这么多对象之间导航的表现其实挺好的。像我说的，这次我们主要聚焦在规划上，所以这里是我们内部本体的一个精简版。我们有几个代表组织的 object type：有开发者，有团队。还有一些代表我们实际计划的对象，也就是计划、目标（objective）和关键结果（key result）。然后是我们的一些源系统，比如聊天消息、支持工单，还有 GitHub 上的一些东西，比如 GitHub pull request 和 GitHub issue。这些只是我们在真实环境里会用到的数据的一个子集，但它们很有代表性——如果我们想复盘团队做得怎么样，或者开始做规划之类的，依赖的正是这类数据。

Chad： 不过我觉得你刚才顺带提到的另一点是——它不光是数据。

[6:04]

It's, like, the data, the logic, the actions, the connections between them, the security.You get all of that along with this, not just a data where I can do reg with MCP.This is, like, a full-fledged operational component where, like, we can actually take actions and we can navigate across links and we can do all sorts of things.Yep.Yeah, no, exactly.Yeah, you can kind of see a sense, get a sense of what all the links are here.And then at the bottom here is all the action types that I've made available.So you can do all kinds of things with this one.We can create issues in the real world.This would actually, like, go right back to the source systems if they were external ones here.And then, obviously, all of the, like, planning stuff for editing and creating your objectives and key results, all that's here, too.And these are just made available as basically tools in the, like, MCP tool chain for our AI agent.Cool.

Chad： 而是数据、逻辑、动作、它们之间的关联，还有安全，这些你是一并拿到的——不只是一堆数据、让我能拿 MCP 做个 RAG 而已。这是一个功能完整的运营组件：我们能真正执行动作，能顺着 link（链接）在对象之间跳转，能做各种各样的事。

Mike： 对，没错，完全是这样。你在这里大致能看出都有哪些 link。然后最下面是我开放出来的所有 action type（动作类型），所以用这个能做各种事。我们能在真实世界里创建 issue——如果这里接的是外部系统，这个操作其实会直接写回源系统。另外，显然所有跟规划相关的操作，比如编辑、创建你的目标和关键结果，也都在这儿。这些基本上就是作为工具，放进我们 AI agent 的 MCP 工具链里。酷。

[6:56]

So once you have your objects loaded in, it's pretty straightforward.There is another MCP tab over here and you just turn it on.And then you have an MCP server.So the kind of cool thing that I just wanted to point out here is this is pretty much agnostic to whatever tools that you use.I'm going to show an example with Claude code inside VS code.Plug in there and then also Codex and Terminal.But this can and has been used with Claude Desktop, with Gemini, with Copilot.All those things are possible.And it really doesn't matter.The point is you're connecting one thing to all of those and everyone's sort of speaking the same language.Yeah.I recently had hooked up Copilot on top of a MCP and the customer loved it that, like, all of a sudden their enterprise data was making sense inside of Copilot for them.So, like, I think it's pretty cool to be able to, you know, take this approach of this business process behind it and enable any of these tools that you have across your enterprise.So now, like, I can open up Word and I have the ontology-backed stuff as I'm writing documents or PowerPoints or other things that people are doing in their enterprise.So I think it's cool to be able to meet them where they are.

Mike： 对象加载进来之后，接下来就很简单了。这边还有一个 MCP 标签页，你把它打开就行，然后你就有了一个 MCP 服务器。这里我特别想指出一个挺酷的点：它基本上不挑你用什么工具。待会儿我会演示在 VS Code 里的 Claude Code 上接入，另外还有终端里的 Codex。不过它也能配 Claude Desktop、Gemini、Copilot 用，而且确实已经有人这么用了。这些都行，用哪个真的无所谓。关键在于，你是把同一个东西接到所有这些工具上，大家说的都是同一种语言。

Chad： 对。我最近刚在一个 MCP 上接了 Copilot，客户特别喜欢——一下子，他们的企业数据在 Copilot 里变得有意义了。所以我觉得这很酷：用这种背后有业务流程撑着的做法，让你整个企业里用的任何一个工具都能用上它。现在我打开 Word，写文档、做 PowerPoint，或者做企业里大家平时做的其他事情时，手边就有本体支撑的这些内容。所以我觉得，能到用户本来就在的地方去服务他们，这点很酷。

[8:01]

Right.I think that's the goal behind this is to bring the power of the ontology to where people are working already.Right.Yeah, exactly.And I have to say the first time I used this, I think the first time I used it was in Claude Code, and it just felt kind of magical.You, like, hook it up and you just start asking these, like, very generalized questions and it comes back with really, really useful stuff.And when your workflow is already in there, you're editing code, you're, you know, you're doing actual development, it's really pretty valuable to be able to have all this stuff sort of in there with you.And it's a really, like, nice enriched workflow.We've been getting a lot of good usage out of it.A lot of organic usage.People have really picked up this thing.Great.

Chad： 没错。我觉得这背后的目标就是：把本体的能力带到大家本来就在工作的地方去，对吧。

Mike： 对，完全是这样。而且我得说，我第一次用它的时候——我记得第一次是在 Claude Code 里——那种感觉简直有点神奇。你把它接上，然后开始问一些很宽泛的问题，它回给你的东西真的、真的很有用。而当你的工作流本来就在那里——你在改代码，在做实打实的开发——能让这些东西都在手边陪着你，价值真的挺大的。这是一种很好的、被充实增强过的工作流。我们内部用得很多，而且大量是自发使用，大家是真的用起来了。很好。

[8:43]

So just to, I think that's basically all that we've got in terms of setup here.Maybe one other thing to note is that everything that's coming through the MCP server, the, in your AI, you know, agent, client, whatever, you're basically just offing to Foundry.So you get, like, a scoped down token.You have the access that your user has.So you basically inherit all the access controls, row, column-based access controls, security markings.That all is reflected in the OMCP server.And then even cooler than that, this is exciting to me, is if you have one of your AI tools, maybe it's a cloud-based one, maybe it's a third-party one, the level of trust that you have in terms of the kind of data that it can store, if that's lower than what you have in Foundry, you can also do marking whitelisting.So you could just let a subset of data out dynamically.So you could say anything that's marked as PII don't allow through the MCP server, which has been really, really helpful for us.Oh, so even, this is, I'm learning stuff right now, too.So we've got the feature where now, like, if I have access to this in Foundry, great.But I don't want these external tools because I don't have control over how they're going to secure the data for PII, for example.

Mike： 那么……我想配置这块基本就是这些了。也许还有一点值得一提：所有经过 MCP 服务器过来的东西——不管是从你的 AI agent、客户端还是别的什么发起——本质上都是在向 Foundry 做身份认证。所以你拿到的是一个权限范围收窄过的 token，拥有的就是你这个用户本身的访问权限。也就是说，你基本上继承了所有访问控制：行级、列级访问控制，还有安全标记（security marking），这些在 OMCP 服务器里全都会体现出来。还有比这更酷、也让我很兴奋的一点：假如你用的某个 AI 工具——可能是云端的，也可能是第三方的——你对它能存储哪类数据的信任程度，比你对 Foundry 的要低，那你还可以按 marking 做白名单，只动态地放一部分数据出去。比如你可以规定：凡是标记为 PII 的数据，一律不许通过 MCP 服务器出去。这点对我们帮助真的非常大。

Chad： 哦，所以连……这个我也是现在才学到。也就是说我们有这么个功能：如果我在 Foundry 里有权限访问这些数据，没问题；但我不想让这些外部工具拿到它，因为我没法控制它们会怎么保护这些数据——比如 PII。

[9:55]

So even though, Mike, you have access to it in Foundry, I can only access that in Foundry in this secure Enclave, versus I can't export it out to one of these tools.Okay, that's pretty neat.I see I learned something new today.Yeah, it's very cool.And it makes it so that you can actually, like, with some confidence, hook this up to tools that, you know, I think it would have been tough to justify from, like, an InfoSpec perspective before.But then you can, you know, you can get 99% of the data that people really need out there and get yourself a little bit unstuck.So that was a big deal for us when we got that in here.That's awesome.Yeah, cool.So I think the next thing was just to maybe talk a little bit more about what was going on in the ontology here before we actually jump into the AI tools.I showed this a little bit in the OSDK tab above, but we have this use case kind of mapped out here.Basically, the objects that we've got are broken down into, like, organizational constructs, teams and developers.We have our planning objects, so plans, OKRs, and then our, like, signal here, GitHub issues, Slack messages, support tickets.So this is really common internally for us.Like, you know, we have internal engineers and developers.

Chad： 所以就算 Mike 你在 Foundry 里有权限，这些数据也只能在 Foundry 这块安全飞地（secure enclave）里访问，而没法导出到这些工具里去。好，这挺妙的。看来我今天也学到了新东西。

Mike： 对，这个很酷。有了它，你就能比较有底气地把这套东西接到一些工具上——放在以前，我觉得从信息安全（InfoSec）的角度恐怕很难说得过去。而现在，你可以把大家真正需要的 99% 的数据放出去，让自己不再那么卡着。所以这个功能上线的时候，对我们来说是件大事。

Chad： 太棒了。

Mike： 嗯，好。那我想接下来，在真正进入 AI 工具之前，再多讲讲这里的本体里都有些什么。刚才在上面的 OSDK 标签页里我稍微展示过一点，不过这里我们把这个用例大致梳理出来了。基本上，我们的对象分成几类：一类是组织架构方面的，也就是团队和开发者；一类是规划对象，也就是计划和 OKR；再就是信号类的，比如 GitHub issue、Slack 消息、支持工单。这在我们内部非常常见。你知道，我们内部有工程师和开发者。

[11:11]

They're doing their actual work in code in GitHub.They're committing code all day.They're submitting PRs.We're filing issues for things that need attention.We all have internal, like, chat channels where we do support.Very high volume.Lots of stuff coming in there.Very hard to keep track of.We also have a ticketing system.So we have, you know, and in real life, there's more than this as well.These are just some of the most common ways that we're getting requests, signal, whatever.And I'll show you a little bit about how sort of we're going to use OMTB to manage all this stuff.So when everyone requests features to me on X and then they end up here in the ontology and then we go build the feature that people want on X and release it an hour later, I think the flow there is tight.Yeah, exactly, exactly.And the thing that I think is really exciting in this whole flow is, you know, when you're integrating this into the place that people are doing their day-to-day work, you can go from synthesizing signal, like just the torrent of stuff coming in through Slack or whatever, into actual, like, issues that you file in GitHub, actual code.You know, you can do that whole flow sort of in one go here.

Mike： 他们真正的工作都是在 GitHub 上写代码：一整天都在提交代码、提 PR；遇到需要关注的事情，我们会提 issue。我们内部都有做支持用的聊天频道，量非常大，大量消息涌进来，很难跟得上。我们还有一套工单系统。所以我们有……当然，现实中的渠道还不止这些，这些只是我们接收需求、信号之类东西最常见的几种方式。接下来我会给大家展示一下，我们打算怎么用 OMCP 来管理这一大堆东西。

Chad： 所以当大家都在 X 上找我提功能需求，这些需求最后落进这里的本体，然后我们去把大家在 X 上要的功能做出来、一小时后就发布——我觉得这条流程是真紧凑。

Mike： 对，没错，就是这样。我觉得整个流程里真正让人兴奋的一点是：当你把它集成到大家日常工作的地方，你就能从汇总梳理信号——比如从 Slack 之类渠道洪水般涌进来的那些东西——一路走到在 GitHub 上真正提出的 issue、真正写出的代码。这一整套流程，在这里差不多能一气呵成。

[12:18]

And it's really convenient.I've been doing that a lot, a lot internally lately.And it's just such a more pleasant flow than anything I'd done before.And yeah, and I think the last thing here is that I have added a few actions in here that are sort of core to this workflow.And this is all the stuff for actually creating and codifying your plan.So right now we've been using Foundry to do internal planning and actually a lot of product planning for years at this point.And it's a great use case.It's really valuable to have everything stored in like a really well-structured way on the ontology.We have, you know, the OKRs are all really discoverable by Teams.It makes it easy to deconflict and understand what other people are working on and when they're delivering it.But it's labor intensive to actually codify all that stuff.So I'll show a little bit about like this is a sort of simplified version of what our internal planning app looks like.But if you go into these, you can kind of see it's nice for reading.You can go in and look.It's a workshop app.It looks fine enough.It's easy to digest.You can peruse through people's plans and get a sense of what's going on.If you want to add plans, it's form-based.

而且真的很方便。最近我在内部经常这么用，用得特别多。比起我以前试过的任何做法，这个流程都要顺手得多。嗯，我想这里最后要说的一点是，我在这里加了几个 action，它们算是这个工作流的核心——全都是用来真正创建规划、把规划固化成结构化记录的。其实到现在，我们用 Foundry 做内部规划、而且做大量产品规划，已经有好几年了。这是个很好的用例。把所有东西以结构非常清晰的方式存在本体上，价值非常大。比如各个团队都能很方便地查到所有 OKR，这样就很容易消除冲突，搞清楚别人在做什么、什么时候交付。但要把这些东西真正整理录入成结构化数据，是很费人力的。我稍微展示一下，这是我们内部规划应用的一个简化版。你点进去就能看到，它读起来挺舒服的，可以进去翻看。这是个 Workshop 应用，看着也还行，内容很好消化。你可以浏览大家的规划，大致了解各处在做什么。但如果想添加规划，就得靠填表单。

[13:26]

So, you know, you're adding OKRs one by one to get that structure.And historically, that's been fine, but it's kind of painful and time-consuming and someone has to go in and do all that.The nice thing with OMCP is you can just feed, you know, an LLM your sort of rough plan or just like, you know, a text plan.And it figures out all the objects for you.It navigates all that and it submits all of it.So it's taken what was like a valuable and useful but time-consuming flow into something that you basically don't think about anymore.You just write the plan and it figures it out for you and gets it all in here.That's very slick.Yeah.So that as one of the authors of our internal planning app, the streamlining here has been very helpful for me because I had to feel a lot of questions about it.So cool.So I think that's about the whole stage before we get into actually looking at what this thing can do.Any other questions or anything before we move over to VS Code here?

也就是说，你得一条一条地加 OKR，才能搭出那套结构。过去这样也还凑合，但挺痛苦、挺耗时的，而且总得有人专门进去把这些活都干了。OMCP 的好处在于，你可以直接把一份粗略的规划、或者就是一份纯文字的规划丢给 LLM，它会帮你把所有对象都理出来，自己在这些对象之间穿梭导航，然后把所有内容都提交上去。这样一来，一个原本有价值、也有用、但很耗时的流程，就变成了你基本不用再操心的事。你只管写规划，剩下的它帮你搞定，全都录进这里。Chad： 这个太丝滑了。Mike： 是啊。作为我们内部规划应用的作者之一，这里的流程简化对我帮助很大，因为以前关于它的问题，我得应付一大堆。很好。那在真正看它能做什么之前，铺垫部分大概就这些了。在切到 VS Code 之前，你还有什么问题或者想补充的吗？

[14:32]

No, let's go see how it works.I think that's really the key.So we got some ideas of how these fit together.But, you know, like what can we do with it?Yeah, for sure.All right.So in this flow, I think a really common thing to do as we're getting into our seasonal planning, we do this three times a year.The first step is usually some kind of retrospective, right?

Chad： 没有，咱们直接去看看它怎么运作吧。我觉得这才是真正的关键。这些东西怎么拼到一起，我们已经大概有数了，但我们到底能拿它来干什么？Mike： 没问题。好。在这个流程里，随着我们进入新一期的规划——我们一年做三次——我觉得一个很常见的做法是：第一步通常先做某种复盘，对吧？

[14:51]

So you want to know how did the last period go?Did you accomplish your goals?Did it line up with the actual like support things that were coming in?How are you doing on some key metrics?This kind of stuff is very labor intensive to pull together.This could easily take several days of someone's time just to get all the chat data and, you know, peruse issues and tickets and filter all that stuff.So what we're doing here is we're just basically using OMCP to speed up this whole process.So I have a simple code workspace up here.In real life, we would have, you know, this you would probably integrate this with whatever your actual repo is.You see a lot more here.For now, what I've done was I ran a retrospective for our tech support team.This is all notional data, but basically asked it to take a look at all of our historical data from Slack, from tickets, from GitHub and run a retrospective for tech support.So it comes it came back with a markdown file.I just wrote it locally for me so I can edit it and do whatever I need to with it.But you see the kind of stuff that it comes up with is like it's actually really nice.And if you don't like the format, it's very easy to iterate on it.And then it becomes very easy to go ahead and do additional ones.

你会想知道上一期进展如何？目标达成了吗？和实际涌进来的那些支持请求对得上吗？几个关键指标表现怎么样？这类东西要汇总起来非常费人力，光是把所有聊天数据拉出来、翻 issue 和工单、再把这些统统过滤一遍，很容易就要占掉一个人好几天的时间。所以我们在这里做的，基本上就是用 OMCP 给整个流程提速。我这边开了一个简单的代码工作区。实际使用时，你大概会把它和你真正的代码仓库集成起来，这里能看到的东西也会多得多。目前我做的是，给我们的技术支持团队跑了一次复盘。这些全都是示意数据，但基本上就是让它去看我们在 Slack、工单系统和 GitHub 里的所有历史数据，然后给技术支持团队做一次复盘。于是它交回来一个 Markdown 文件。我直接让它写到本地，方便我编辑、想怎么处理都行。你可以看到，它整理出来的这些内容其实真的很不错。而且如果你不喜欢这个格式，要迭代修改也非常容易。之后再接着多做几份，也会变得非常轻松。

[16:08]

So like for me as one of the leads of our org, like it's it's very common that as you know, everyone else is planning, I'll want to go through and do a little bit of my own homework.So I could just say like, OK, now show me a similar retrospective for the network engineering team.And it'll just cook for a while.

比如对我来说，作为我们部门的负责人之一，很常见的情况是，在其他人都忙着做规划的时候，我也想自己过一遍，做点功课。所以我可以直接说：好，现在给我出一份类似的复盘，这次针对网络工程团队。然后它就会自己跑上一阵子。

[16:31]

It'll start looking through all of that additional data.It knows what it pulled before, which was basically, you know, an amalgamation of signal from our plans and our support data.And it's just going to start doing that so I can keep writing these things.And I think the spoiler is that like after this is done, you can then take that retrospective and say like, all right, this is great.Take some of those learnings.Look at the stuff that was in the plan last time.Look at the stuff that came in from our support data, common trends.And now make me a plan, which is which is cool.I think in in the real world, obviously, you have it make you a draft.It's based.It's anchored in real life data.And then you go and iterate on it.We're going to show sort of like a compressed version of that here, where I think we mostly one shot the plan, which I don't wouldn't necessarily advise.But we get pretty close.So, yeah.So you can kind of see what it's doing here.It's like, OK, we have a good format for reference.It found the network engineering team, found the lead of the network engineering team.It's pulling up the objectives, key results, GitHub issues.And now it's basically just doing its analysis here.

它会开始把那些新增的数据全都过一遍。它知道自己之前拉过哪些东西——基本上就是从我们的规划和支持数据里汇集起来的各种信号。它会直接开始干活，这样这类复盘我就可以一份接一份地写下去。我先剧透一下：等这一步做完，你就可以拿着这份复盘说：好，这份很棒，从里面提炼一些经验教训，看看上一期规划里都有什么，再看看支持数据里进来了哪些东西、有哪些共性趋势，然后给我做一份规划。这就很酷了。当然，我觉得在真实场景里，你会让它先给你出一份草稿——它是有依据的，是扎根在真实数据上的——然后你再去反复迭代。我们这里演示的算是个压缩版，基本上是一次就把规划生成出来，我其实不一定推荐这么做，但效果也挺接近了。好，你大概能看到它在这里做什么：它在想，好，我们有一个不错的格式可以参考；它找到了网络工程团队，也找到了网络工程团队的负责人，正在调取目标、关键结果和 GitHub issue，现在基本上就是在做分析了。

[17:40]

So in a minute, it'll come back with another markdown file and it'll have an additional retrospective for network engineering.So we'll let that cook for a little bit.And while it's doing that, I'll give a little bit of a spoiler for what's coming next.There it is.OK, here we go.Which is basically we're going to check Claude's work.Yeah, I think I can't understate or I can't overstate how cool it is.Because our ticketing system is based in ontology and foundry and everything else.So all of these are actually live system of records for us that are actually coming together.So the fact that I've got our ontology mapping out our ticketing process mapped into our product pieces, mapped into all these things.That's actually the ontology of how Palantir runs.And now I can have these AI agents or components wherever I'm working.Like this example in Claude Code.We'll look at others as well.But like how cool it is that I actually have all of that in a live system that I can now interrogate, build plans, iterate over.Like, I don't know.It's just cool to me.Yeah.No, it's like, yeah, I'm like used to it at this point.The first time I did this, I was actually blown away.I was just asking questions all day about like, what's going on this team?

所以过一会儿，它会交回来另一个 Markdown 文件，里面是给网络工程团队新做的一份复盘。我们先让它跑一会儿。趁它在跑，我先稍微剧透一下接下来的内容。出来了。好，开始吧。其实就是，我们接下来要检查一下 Claude 干的活。Chad： 是啊，我觉得这有多酷，怎么强调都不为过。因为我们的工单系统就是建在本体、Foundry 这一整套东西之上的。所以这些其实都是我们实时在用的记录系统（system of record），如今真正汇聚到了一起。我们的本体把工单流程梳理清楚，映射到各个产品模块，映射到方方面面——这其实就是 Palantir 如何运转的本体。而现在，不管我在哪儿工作，都能用上这些 AI agent 或组件，比如这个 Claude Code 的例子，后面我们也会看看别的。你想想，所有这些都在一个实时运转的系统里，我现在可以随时向它发问、拿它做规划、在上面反复迭代——这多酷啊。怎么说呢，我就是觉得太酷了。Mike： 是啊。确实，我现在已经有点习惯了。但第一次这么用的时候，我真的被震撼到了。我一整天都在不停地问：这个团队在忙什么？

[18:58]

What's going on this team?It was like a level of visibility I just had never had before.And, you know, this is just what I would do as sort of like a manager here.Like if I was on the network engineering team and I saw this, I could go here and say like, oh, it's like, you know, we have like Terraform issues.It's like you could literally paste this in and just say like, go look at all of my config files.Like actually help me fix this thing.You know, and then, you know, you basically pick up your normal Claude Code workflow from there.So it's really great for jumping off and, you know, getting actual work done outside just planning.So in this case, yeah, it came up with, you know, it looked at the template, came up with a new version for the network engineering team.It's a good jumping off point for actually getting a plan going.So I could say like, okay, you know, this is very interesting.Make it into our T3 plan.

这个团队在忙什么？那种对全局的掌握程度，是我以前从来没有过的。而且这还只是我作为管理者会用的方式。比如说，假设我在网络工程团队，看到了这个，我就可以直接到这里说：哦，看起来我们有些 Terraform 的问题。你完全可以把这段直接粘贴进去，然后说：去把我所有的配置文件都看一遍，真正帮我把这个问题修好。接下来，你基本上就能从这里接上你平时的 Claude Code 工作流。所以它特别适合当个起点，让你去把真正的活干完，而不只是停留在做规划上。那么在这个例子里，它参照了模板，给网络工程团队出了一个新版本，拿来当真正启动规划的起点挺好。所以我可以说：好，这个很有意思，把它做成我们的 T3 规划。

[19:56]

And it'll do the same kind of thing.It'll come back and it'll draft up another markdown output.I'll show just an example of what that looks like.So this is one that I had it pull together a couple hours ago for tech support.And this one, you know, it gives sources of where it found things.It sort of says what the general plan is based off of, what are the main themes.And then it just gets right into OKRs.You're going to toggle it into a nice rendered mode.So you can come and see like, here's the, you know, first objective, stop IT automation from failing silently.So, you know, it does a pretty good job of synthesizing these things.And, you know, if I were the lead of this team, I would read through this.I would share it with the team.I would iterate on a little bit.Make sure that we were kind of all in sync with the actual work.Obviously, it's, you know, we're still talking LLens here.It's never going to be perfect.But like the amount of time that you save from just trolling through all that information and synthesizing it into something useful is like, it's hard.It's hard to overstate.Well, I think now, too, like the way that it did all that work.So you can really focus on the strategy, the real, the thinking part, right, is what we don't push out to the LLens.

它会做同样的事，交回来再起草一份 Markdown 输出。我先给大家看个例子，看看出来是什么样子。这份是我几个小时前让它给技术支持团队整理的。你看，这份里它会给出信息来源，标明是在哪儿找到的；大致说明整体规划是基于什么做出来的、主要主题有哪些；然后就直接进入 OKR。我把它切到渲染好的预览模式，这样就能看到，比如第一个目标：别再让 IT 自动化悄无声息地失败。可以看出，它把这些内容综合得相当不错。如果我是这个团队的负责人，我会把它通读一遍，分享给团队，再稍微迭代一下，确保大家对实际要做的工作步调一致。当然，我们说的毕竟还是 LLM，它永远不可能完美。但光是省下来的时间——不用再把所有信息翻个底朝天、再综合成有用的东西——真的，怎么强调都不为过。Chad： 嗯，我觉得现在还有一点：它把这些活都干完了，你就能真正专注在策略上、专注在真正动脑子的那部分——对吧，这部分我们是不会甩给 LLM 的。

[21:14]

It's really around, can it bring all the data together, come up with kind of the basis point.Now I can think strategically about it instead of figuring out where do I find this thing and where is this piece, right?

关键在于，它能不能把所有数据汇到一起，拿出一个打底的基础。这样我就能从战略层面去思考，而不是忙着找这个东西在哪儿、那块内容又在哪儿，对吧？

[21:23]

I think that's, that's probably like allows us to prototype our plans in this case, you know, as we go through and kind of iterate on the product.I think it's very common to sit to have these feelings about like, this is the stuff that people were complaining about.This is the stuff that was causing a lot of pain.But having a real data back view makes those conversations so much easier and you can just get down to it.So cool.All right.So from here, we'll just let, let Claude keep drafting the network engineering one in the background.I'm going to pivot over to kind of my next step here, which is we have a draft.Again, in the real world, we iterate on it with our team a little bit.Something that I always find really helpful though, both when doing, you know, like AI driven coding and development, but also for written documents like this is I'll have a different, a different agent kind of check the work.So all this is gone.I'm going to move over to my other window here where I have codecs open.Um, so I'd been doing some other, some other planning work in here with codecs.Um, and it has access to the same files that, that, uh, Claude was writing.So I could say, you know, let's, uh, take a look at the draft, um, plan and me some feedback.

Mike： 我觉得这样一来，在这个场景里我们大概就能先给规划做个原型，一边推进一边迭代产品。我觉得很常见的情况是，大家坐在那儿凭感觉说：这些是大家一直在抱怨的问题，这些是让人很头疼的问题。但有了真正以数据为依据的视角，这类讨论就容易太多了，能直接切入正题。很好。好，接下来就让 Claude 在后台继续起草网络工程团队那份。我要转到下一步了：我们现在已经有了一份草稿。还是那句话，在真实场景里，我们会再和团队一起稍微迭代一下。不过有个做法我一直觉得特别有用——不管是做 AI 驱动的编码和开发，还是写这种书面文档——就是换另一个 agent 来检查一遍。这边先这样。我切到另一个窗口，这里开着 Codex。我之前一直在这里用 Codex 做别的一些规划工作，它能访问 Claude 刚才写的那些文件。所以我可以说：来，看一下这份规划草稿，给我一些反馈。

[22:43]

Is it realistic?Is it realistic?Is it too ambitious?Ambitious.Um, and it'll, it'll take a look at it and, uh, and sort of proofread the work.And, and I've found that even when, you know, the first draft looks pretty sane, it actually comes back with really, really good feedback.Um, and usually it has access to the file.It has access to the ontology as well.Yep.Yep.Exactly.And you can see it's doing all kinds of ontology calls here.It's doing a whole bunch of stuff.Um, so it's, uh, it, it does, it does a good job of kind of fetching the right information.All right.So I think this is like, so like the fact that I have one ontology, I can use Claude code codecs copilot.I can use our AI FD.You can do it in platform.Like the goal is not one platform.The goal is like, we meet you where you are with the right intelligence.And, and that's really the ontology is kind of play here is bringing all of that together.No matter what environment you're in.Yeah, exactly.Now there's, uh, there's an important point there, which is that for people that have beendoing a lot of AI workflows that are watching this, like they'd probably say, this is nice,but like you could automate a lot of this.And I think that's exactly right.

Mike： 切不切实际？切不切实际？是不是太激进了？激进。嗯，然后它会、它会看一遍，呃，相当于帮你审审稿。而且、而且我发现，哪怕初稿看起来已经挺靠谱了，它其实还是能给出非常、非常好的反馈。嗯，而且它一般也能访问到那个文件。它也能访问本体。对，对，没错。你看，它在这儿做了各种各样的本体调用，干了一大堆事。嗯，所以它、呃，它、它在抓取正确信息这方面，做得、做得挺好的。

Chad： 好。所以我觉得这就是——就是说，我只有一个本体，却可以用 Claude Code、Codex、Copilot，也可以用我们自己的 AI FDE，还可以直接在平台里做。目标不是押宝某一个平台，而是你在哪儿，我们就带着合适的智能去哪儿配合你。而、而本体在这里真正扮演的角色，就是把这一切汇聚到一起，不管你身处什么环境。

Mike： 对，没错。不过这里有、呃，这里有个很重要的点：看这期视频的人里，那些已经跑过大量 AI 工作流的，大概会说：「这挺好的，但其中很多步骤完全可以自动化啊。」我觉得这话说得完全对。

[23:54]

Um, and what I would, what I would do going forward from here is use our learnings fromgoing through this process manually with a few different AI tools.And I think the next step here would basically be once we like that workflow, we can use theother foundry MCP preserve more for building stuff or do it in foundry.And AI FD and actually codify this whole workflow.So like we shouldn't in theory have to do any of this stuff, right?

嗯，那我接下来、接下来会怎么做呢？就是把我们用几个不同的 AI 工具、手动把这套流程走一遍攒下的经验用起来。我觉得下一步基本上就是：一旦我们认可了这个工作流，就可以用另一个 Foundry MCP——那个更偏向用来构建东西的——或者直接在 Foundry 里用 AI FDE，把整个工作流真正固化下来。所以理论上，这些事我们本来一件都不用亲手去做，对吧？

[24:18]

Like once we've learned the most valuable version of this process, it should just happen.Um, and it's pretty easy to go from prototyping here, working through this manually with a fewAI agents to we've now built this thing in foundry.It happens every couple of months automatically sends you a retrospective.You can go back and forward on it.You give it a final draft.It publishes it for you.You're done.And then you can run further automations to say, you know, the kind of D confliction thatI ran manually here.It could do, um, uh, sort of like on a weekly basis, right?

就是说，一旦我们摸清了这套流程最有价值的版本，它就应该自动发生。嗯，而且从现在这样做原型——拿几个 AI 智能体手动一步步走——过渡到「我们已经在 Foundry 里把它建好了」，其实挺容易的。它每隔几个月就自动给你发一份复盘；你可以跟它来回推敲，把定稿交给它，它帮你发布，就完事了。然后你还可以再跑更多自动化，比如我刚才手动做的那种跨团队冲突梳理，它可以，嗯，呃，差不多每周跑一次，对吧？

[24:52]

Like you don't necessarily need to wait until you're doing planning to get trends from yourchat data and support channels and things like that.Um, that should happen all the time.So what we're using this increasingly for is, is that discovery part.So when you're off-roading and you need to do one-off things, this is like, it's toughto beat.Um, but obviously you want to have some consistency in how these things are done.And this is just a great first step to actually launch off into that and like really build theworkflow in foundry.So it's a nice play back and forth between tools that people are used to getting it backinto platform, iterating again.Um, it's been very, like very useful for us.Cool.So it looks like it finished here.Um, and it actually said this one was realistic.Uh, I had to draft another one yesterday and it said it was wildly unrealistic.So this is actually, I guess we're getting better at it.Um, so from here, yeah.Yeah.So what, what do we, what do we do for you?

Mike： 就是说，你不一定非要等到做规划的时候，才去从聊天数据、支持频道这些地方挖趋势。嗯，这件事应该时时刻刻都在发生。所以我们现在越来越多地把它用在「探索发现」这个环节。当你要偏离常规路线、做些一次性的事情时，真的很难找到比它更好用的。嗯，不过显然，这些事怎么做，你还是希望保持一定的一致性。而这正好是很棒的第一步，可以从这里起步，真正在 Foundry 里把工作流建起来。所以这是一种很顺的来回配合：先在大家用惯的工具里做，再把它带回平台，接着迭代。嗯，这对我们来说非常、非常有用。好，看起来它这边跑完了。嗯，它说这一份其实是切合实际的。呃，我昨天起草了另一份，它说那份完全不切实际。所以这其实说明——我猜我们是越做越好了。嗯，那接下来，对。

Chad： 对。那、那我们、我们接下来要做什么？

[25:45]

So like, as I get it, we, we can, we can use different ones.We can interact with ontology, even across different agenda coding tools.Like, so now when we talk about codifying it or like, how do I write back or how do I makethese plans?

就是说，按我的理解，我们、我们可以、我们可以用不同的工具，哪怕跨不同的智能体编程工具，也都能和本体交互。那么现在，说到把它固化下来，或者说，我要怎么写回、怎么把这些规划真正建出来？

[25:59]

Like what's the next step?So I can do all my typos and flubs as I want to figure it out.Um, so from there, then, you know, we are basically at the end of the planning workflow.We say like, okay, we're good with it.Let's actually publish this thing.Um, it's going to make a bunch of, uh, um, OMCP calls to all those actions that I showedearlier.Oh, I found a T3 plan.Oh, it belongs to network engineering.Okay, cool.So there's no tech support T3 plan yet.Um, so let's go ahead and draft it up.Okay.No clear.Okay.All right.So pull the markdown file for T3 and publish that.All right.So I need a little bit of supervision here.Um, but, uh, it will get there.Cool.Cool.So, yeah, I mean, from here, we're just letting it kind of do its thing, publish it.And then it would show up, uh, back in that workshop app.This is where the rest of the company would consume it.Um, or if they're doing other workflows, like in, um, in their AI tools, they can referencethem there too.This is nice if you're just doing a general peruse of like, Oh, what's going on in techops.Um, but, um, if you need more tactical information or it conflicting, you'd probably go back to the,go back to the, go back to the AI tool.Um, so like, I think that like important parties, you're talking about I'm collaborating across

Chad： 就是，下一步是什么？

Mike： 反正我打字随便出错、手滑都没关系，它能看明白。嗯，那从这儿开始，你知道，我们基本上就到了规划工作流的最后一步。我们会说：好，这份没问题了，正式发布吧。嗯，它会发起一大串，呃，嗯，OMCP 调用，去调我前面展示过的那些 action。哦，找到一个 T3 规划。哦，是网络工程团队的。好的。所以技术支持团队还没有 T3 规划。嗯，那就先把它起草出来吧。好。不太明确。好。行。那就去把 T3 的 markdown 文件拉出来，发布它。好。看来这里还得我稍微盯着点。嗯，不过，呃，它最后能搞定。好，好。所以，嗯，我是说，从这儿开始我们就让它自己干活、把规划发布出去。然后它就会，呃，重新出现在那个 Workshop 应用里，公司里其他人就是在这儿看这些规划的。嗯，或者如果他们在跑别的工作流，比如在，嗯，在他们的 AI 工具里，也可以在那边引用这些规划。如果你只是想大致翻翻，比如「哦，tech ops 那边在忙什么」，用这个就挺好。嗯，但是，嗯，如果你需要更偏战术层面的信息，或者要做冲突梳理，你大概还是会回到、回到、回到 AI 工具里去。

Chad： 嗯，所以我觉得这里重要的一点是，你讲的是我可以跨

[27:21]

teams across an entire organization.The ontology is at the center, no matter which tool.So one team might like using cloud code.One might be using AI FD one might be using codex and other using copilot.I don't care.The ontology is that single back end layer across the enterprise and workflows, not onlyfor that interactive kind of, you know, agentic kind of coding, uh, pieces here.But if I then want to codify it into a workflow, that's just happening automatically, you cando that inside of Palantir.You could do it outside that interoperability and openness is really what I'm trying toget at is like, I don't care.It really comes back to what is the right thing for your organization?

团队、跨整个组织去协作。不管用哪个工具，本体都处在中心。比如一个团队可能喜欢用 Claude Code，一个在用 AI FDE，一个在用 Codex，还有一个在用 Copilot——我无所谓。本体就是贯穿整个企业、贯穿各个工作流的那一层统一后端，而且不只是服务于这里这种交互式的、你懂的，智能体编程之类的，呃，环节。但如果我接下来想把它固化成一个自动运行的工作流，你可以在 Palantir 里面做，也可以在外面做。我真正想说的就是这种互操作性和开放性——用什么我都无所谓。说到底还是要回到：什么才是最适合你们组织的？

[27:56]

How do you get the most value out of it?And using that ontology to orchestrate all of that.Right.Yeah.And I think maybe another point on top of that is like, we've been very fluid with the toolsthat we use.Um, this is obviously a very dynamic industry.There's, you know, new things are landing constantly.Um, the, the preferences for which tool developers like to use changes on a near daily basis.Um, not feeling stuck with any particular configuration or set of tools has been very liberating.Um, you can jump again from, you know, cloud code to codex to copilot to whatever, depending on what you need.Uh, depending on what latest version happens to have the features that people want or the latest models or whatever.Um, be able to have that fluidity has been, has been really helpful.Um, and you know, again, a lot of times the best thing will be doing it inside foundry itself.Um, but other times, you know, meeting users where they are in whatever tool happens to be the best today.Yeah, no, this is awesome.I think the, the, the kind of openness, because I think we, we hit on the ontology MCP where I'm having MCPs are on that ontology.piece, but like we also have the platform MCP, so you can actually interact and build stuff in the platform through MCP and then consume it through the ontology, you know, MCP as well.

Chad： 怎么从中拿到最大的价值？再用本体把这一切编排起来。

Mike： 对，是的。我觉得在这之上或许还能再补一点：我们在工具的选用上一直非常灵活。嗯，这显然是个变化极快的行业，你知道，新东西不断冒出来。嗯，开发者偏爱用哪个工具，几乎每天都在变。嗯，不被任何特定配置或某一套工具绑死，这让人感觉非常解放。嗯，你可以根据需要，从 Claude Code 跳到 Codex，再跳到 Copilot，或者随便什么别的。呃，看哪个最新版本刚好有大家想要的功能，或者用上了最新的模型之类的。嗯，能有这种灵活性，真的、真的很有帮助。嗯，当然，你知道，还是那句话，很多时候最好的做法就是直接在 Foundry 里做。嗯，但另一些时候，就是，你知道，去用户所在的地方配合他们，用当下恰好最好用的那个工具。

Chad： 对，真的，这太棒了。我觉得这种、这种、这种开放性……因为我们、我们前面讲的是 Ontology MCP，也就是在本体那一块上开放 MCP，但其实我们还有 Platform MCP，所以你其实可以通过 MCP 在平台里交互、搭建东西，然后再通过 Ontology MCP 去使用它。

[29:09]

So it really is fully like dynamic from that standpoint of having MCP integration, SDK integration.Like that really is kind of the core across everything we're doing on the Houndary, a single ontology for that business process.But then you can interact with it in all the different ways that you need to, to kind of meet your needs.Mm-hmm. Yep. Yeah, exactly.It's like, this would be such a cool workflow to actually do this manually once and just say, connect to the other MCP server and start building it in Foundry.And it just would take off. It would have all the context from your discovery here.It would distill it. And then you would be on your way to a new use case.And there's, there's something, there's something quite powerful about that.You get, you really like raise the competence bar every time you go through the process.Yeah. All right. So it looks like it submitted the plan.It's an ontology.Looks like it did. Yep.Very cool.So let's, let's take a look. It should be one of the few T3 plans here.There we go. Text apart. All right. So yeah, it looks like it navigated the ontology, made all the key results and objectives correctly, published it all, did a really nice job.Uh, I didn't have to click through a bunch of forms and things.

Chad： 所以从这个角度讲，它真的是完全灵活的：有 MCP 集成，也有 SDK 集成。这真的可以说是我们在 Foundry 上所做一切的核心——为那套业务流程建立单一的本体。然后你可以用各种你需要的方式跟它交互，来满足你的需求。

Mike： 嗯嗯。对。是的，没错。就是说，这会是个特别酷的工作流：先手动把这件事做一遍，然后直接跟它说「连上另一个 MCP 服务器，开始在 Foundry 里把它建起来」。它一下子就能跑起来，因为它手里有你在这里做探索时积累的全部上下文。它会把这些提炼出来，然后你就踏上了通往一个新用例的路。这里面、这里面有种、有种相当强大的东西。每走一遍这个流程，你的能力水准都会实实在在地往上抬一截。好。行。看起来它已经把规划提交了。已经进本体了。看起来是成功了。对。很酷。那我们来、我们来看一眼，它应该是这儿为数不多的几个 T3 规划之一。找到了，Tech Support（技术支持）。好。所以没错，看起来它在本体里一路都找对了地方，所有目标和关键结果都建对了，全部发布完毕，干得非常漂亮。呃，我都不用去一张张点表单什么的。

[30:15]

Um, it was easy.Um, and I spent zero time on publishing and sorting out the formatting of the plan and all of my time actually planning.And now you have a structured plan that integrates with the rest of your product pieces or other information in your business.And now I have the ways I can compete against it and do whatever I want. Like pretty cool.I think, um, having that piece of structured component that allows me to process unstructured data, right?

Mike： 嗯，很轻松。嗯，我在发布规划、整理规划格式上花的时间是零，所有时间都用在了真正做规划上。

Chad： 而且现在你拿到的是一份结构化的规划，能跟你其他的产品模块、或者业务里的其他信息打通。现在我就有各种办法基于它做计算，想怎么用就怎么用。挺酷的。我觉得，嗯，有这样一块结构化的组件，让我能去处理非结构化数据，对吧？

[30:43]

I think that's back and forth of, of how organizations really work is pretty neat. So awesome.So now, yeah, so I'm just throwing a question in here, a typical kind of thing that you might want to know is like, where's the tech support team blocked on the network engineering team?

Chad： 我觉得这种来来回回，恰恰、恰恰就是组织真实运作的方式，挺妙的。太棒了。

Mike： 那现在，对，我就在这儿随手抛个问题——一个你很可能想知道的典型问题：技术支持团队在哪些地方被网络工程团队卡住了？

[30:56]

So now it can then, now that all that is published, it can peruse all that and, um, start to understand where these teams have interdependencies, where they need to, you know, file work and issues on each other.Um, and where they are and are not on block or blocked and where they can make progress.Um, so, you know, came back pretty quick with that one. I came up with a short list of areas where they have dependencies on each other.Again, this kind of stuff is just so tedious normally and being able to just ask these free form questions and then just use that as a launching point to actually do the work really, really helpful.Yeah. And I know like we're a technology company showing how we can, you know, build different products and these things, but like, as people think about this in their organizations, whether that's planning out business events or other components, or, you know, how am I actually going to run my business?

所以现在，既然这些内容都已经发布了，它就能把这些通读一遍，开始弄清楚这些团队之间在哪些地方相互依赖、在哪些地方需要互相提工作项和 issue，还有哪些地方已经畅通、哪些地方被卡住了，以及哪些地方可以往前推进。这个问题它很快就给出了答复，列出了一份简短清单，都是这些团队之间互相依赖的方面。还是那句话，这类事平时真的特别繁琐，而现在能直接抛出这种开放式的问题，再以此为起点真正去推进工作，真的非常非常有帮助。Chad： 是啊。我知道，我们是一家科技公司，展示的是我们怎么打造各种产品之类的，但大家在自己的组织里思考这件事的时候，不管是规划业务活动、其他环节，还是说“我到底该怎么经营我的业务？”

[31:43]

This same kind of thing could be applied across your sales data with your business, you know, your business and supply chain and other things like that same concept on planning can be happening in a lot of different ways, whether that's software, supply chain, manufacturing, whatever it is.Um, this same ability to have the agility and meet people where they are with the tools that they're using and making sense.Like that is truly kind of the Palantir way of being open and integrated across everything.Yeah, no, absolutely. I think this demo that the ontology that I showed was so like tiny compared to the one that we actually, uh, have at our disposal internally.I mean, the, the, the, the breadth of types of questions we've been able to ask and launch off from here is like, it's just pretty awesome.Like all kinds of, uh, our employee history data, the things they've worked on, like the types of skills that they have being able to do like really more intelligent resourcing, um, understanding the type, you know, for our developer, like what, what, what are they actually working on?

同样的做法也可以用到你业务里的销售数据上，用到你的业务、供应链等方方面面。同样的规划理念可以通过很多不同的方式落地，不管是软件、供应链、制造，还是别的什么领域。同样是这种敏捷的能力——直接在大家正在用的工具里满足他们，帮他们把事情理清楚。这才真正体现了 Palantir 的一贯做法：保持开放，把一切都打通集成。Mike： 对，没错，完全是这样。我觉得我演示的这个本体，跟我们内部实际能用的那个比起来，简直小得可怜。我是说，我们能问的问题类型之广、能从这里出发展开的事情之多，真的挺厉害的。比如各种各样的数据：员工的历史数据、他们参与过的工作、他们具备哪些技能，有了这些就能真正更聪明地做人员调配；还能了解，比如说我们的开发人员，他们到底在做什么？

[32:41]

What are their pull requests? Like what's the shape of things that they have expertise in?Like as someone who does a combination of technical work and operational work from planning, resourcing, hiring, stuff like that, just being able to have one place where I can ask general questions, build these analyses, uh, is really, really helpful.Um, and I have done a lot of cases where, you know, you'll, you'll ask a few questions, you get a sense of like, okay, these are the kinds of things that I want to keep an eye on.And then I'll go and I'll make that into like a workshop app that has like a dashboard or something like that.And that way I can just refer to it. So, you know, you have this nice promotion flow where you go from exploratory up to like a nice codified thing that you can just keep referring.Yeah. Yeah. Well, this is awesome. Mike, I really appreciate you taking the time to show everyone, like, this is pretty neat that I can really integrate with ontology MCP, um, across business workflows.Uh, I think it's good to get people thinking about how do we like think about what is this new world looking like?

他们提了哪些 pull request？他们擅长的领域大致是个什么轮廓？像我这种既做技术工作、又做运营工作的人——规划、人员调配、招聘之类的都要管——能有一个地方让我问各种宽泛的问题、搭建这类分析，真的非常非常有帮助。而且我有很多次都是这样：先问几个问题，心里大概有了数——“好，这几类东西是我想持续盯着的”。然后我就会把它做成一个 Workshop 应用，带个仪表盘之类的。这样我随时都能调出来看。所以你看，这就形成了一条很顺的升级路径：从探索性的提问起步，一路沉淀成一个规范、固化下来的东西，可以一直拿来参考。Chad： 对，对。这太棒了。Mike，非常感谢你抽时间给大家演示，能把 Ontology MCP 真正用到各种业务工作流里，这真的挺酷的。我觉得这很好，能让大家开始思考：我们该怎么去想象这个新世界会是什么样子？

[33:34]

You just gave a couple of exams of like resource planning. What are developed people working on?Like all these other business functions that you can now integrate with in all the different tools with one centralized knowledge base, which is the ontology. So very cool. Thank you.Yep, absolutely. Yeah. We're really excited about it. Um, I think people are going to love this thing. It's really cool.

你刚才举了几个例子，比如资源规划、开发人员都在做什么。还有其他各种业务职能，现在都可以通过同一个集中式知识库——也就是本体——在各种不同的工具里打通集成。所以真的很酷。谢谢你。Mike： 嗯，应该的。是啊，我们对这个真的很兴奋。我觉得大家会爱上这东西的，真的很酷。