[AMA] Learn from the Ontology Manager team about the application's history, and help us shape its future!

Hey community! Chris here from the Palantir product documentation team. We’re launching monthly AMAs with our product teams to share what’s happening behind the scenes and hear from you about your experiences with our products.

This AMA will run asynchronously from Wednesday, September 24 through Wednesday October 8, with Ontology Manager and Frontend team members monitoring this thread daily and responding to your questions and comments.

For our first AMA, I sat down with Tomasz, team lead for Ontology Frontend. We talked about performance improvements, surprising user creativity, and what’s coming next.

Feel free to drop your thoughts in the comments below, and know that we’re capturing your feedback to help shape what gets prioritized and built next. Without further ado, here’s Tomasz:

  • Hi Tomasz, how long have you been at Palantir, what is your team, and what do you do within your team?

    • I’m currently a team lead of Ontology frontend. By next month, I’ll have been at Palantir for 4 years. Our team manages the Ontology Manager application and how frontend ontology components work across the platform. We guide where ontology primitives are headed, striving to keep them useful for developers. I do a bunch of things - manage feature prioritization and help other teams contribute to the ontology, as well as mentor junior devs on the team, make contributions to the product, and finally, I try to do some coding if I find time.
  • What is the main problem Ontology Manager aims to solve?

    • Ontology Manager is meant to be a default home for management, editing, and discovery of your ontology. It also serves as the exhaustive source of truth for the ontology, since you can also use other Palantir platform applications to interact with the ontology, such as editing it through Pipeline Builder, installing it through Marketplace, and more. In short, you’re meant to be able to edit and visualize your ontology in Ontology Manager.
  • How did Ontology Manager change from its initial design (story from development)?

    • It was largely different from when I joined. While I wasn’t on the team at the very beginning of the Ontology frontend team’s history, I can share that Ontology Manager was not accessible to customer users when I was interning here. At that time, the ontology was managed by Palantirians only. Similarly, it only supported object types and link types back then, with the linkage being called “relations”. There was also only one ontology. This meant that you had no option of having multiple ontologies within a single enrollment to organize and separate different use cases. And lastly, the ontology was loaded at the time of the application start up - as at the time, ontologies were super small and not as in wide use as today. To scale up both in number of ontology resources, and different primitives that ontology have (actions, interfaces, shared properties, etc), different data source types, and storage - the scope of the application has grown a lot since then.

    • You can see some old screenshots of the Ontology Manager below (The Object type panel and Sync management screen):

  • Can you share a real-world success story where a developer or team achieved something notable using your product?

    • While I’d say that Ontology Manager is not that ground breaking as a part of the Foundry suite of applications, Palantir’s ethos is that the ontology is the crux of an organization, and we do see that 99% of the problems solved in-platform are solved through the ontology.

    • One funny story I can share about how far we’ve come: A developer at a client site told us he used to treat himself to a cup of coffee with every Ontology Manager edit. It was his way of staying productive while the system processed his changes. As much as we love coffee ourselves (and trust me, we do), this feedback drove us to prioritize major performance improvements:

      • Rebuilt the architecture for scale: Ontology started small, but as usage grew, we realized the original design couldn’t handle loading large amounts of information to the frontend. We re-architected the application to use lazy loading and strategic pre-loading for optimal performance.

      • Moved processing to the backend: We invested in improved APIs to handle heavy operations on the backend instead of burdening the frontend, creating a smoother user experience.

      • Ongoing optimization: We continue identifying and addressing performance bottlenecks as the product evolves.

  • What’s the biggest technical challenge your team has solved in the past year, and what did you learn from tackling it?

    • We’ve tackled some major architectural challenges recently. The biggest one was our lazy loading migration last year. We completely changed how Ontology Manager handles data, moving from fully loading everything upfront to only loading what’s actually needed for display. This sounds straightforward. Spoiler: It wasn’t. It broke a lot of fundamental assumptions in our codebase. Historically, ontologies were small enough that we could just load everything at once, so developers wrote code assuming all data was already available. We had to go through the entire system and convert synchronous operations to asynchronous ones, which was a massive undertaking.

    • Another significant project was migrating type groups from being type classes to becoming first-class features. This was a large-scale migration, but it was worth it because it enabled us to use search effectively and improved performance across other applications like Object Explorer. The tricky part was making this an automatic migration while preserving security. We wanted users to seamlessly transition without any manual work, but we had to ensure that type groups maintained exactly the same restrictive security domains as the old system. There were significant security implications to consider, so we had to be extremely careful about how we handled that migration.

  • What’s the most creative way you’ve seen developers use our product that made you think “wow, we never intended that, but that’s cool”?

    • People are building meta-ontologies, essentially creating ontologies about their own ontologies. They’ll create object types that represent “all object types” or “all objects on the platform” and then push this metadata to Workshop for analysis. This gives them insights into their own Foundry system: how many object types they have, who owns them, and usage patterns. It’s fascinating, almost like building a programming language and then creating a compiler for that same language. What surprises me is how often this happens. Clients are building sophisticated apps that no longer rely on our standard ontology creation tools. For example, while Foundry has built-in access request workflows, one client’s needs were so advanced that they built their own custom workflow and Workshop app to handle access requests. They’ve essentially created their own system within our system. And we love to see inspired usage like this.
  • What’s something that really shows you how passionate developers are about building on our platform?

    • Often when we get feature requests, we also hear about the ingenious problems-solving approaches they’ve developed in the meantime. One of the most impressive examples, shared with me by another peer, goes back about 8 years when we didn’t yet support array properties (the “allow multiple” feature). There were developers who built an incredibly sophisticated product that not only used arrays extensively but even had support for nested arrays by creating an elegant encoding system. They developed a method where they’d encode specific IDs to indicate array types, essentially building their own array infrastructure on top of our platform. That’s probably the most foundational feature I can think of where users managed to architect their own solution. It really showcases the resourcefulness and technical creativity of our developer community.
  • Which feature do you think is most underutilized, and what’s your elevator pitch for why developers should give it another look?

    • I think object type groups, statuses, and visibility settings are hugely underutilized. Most developers don’t realize how much these features can transform their search experience and help them find the right resources quickly. I get it, setting up metadata isn’t exactly thrilling, but hear me out… You’re already creating metadata for your objects anyway, so why not leverage that existing work to dramatically improve discoverability? By properly setting up object type groups, statuses, and visibility, you’re essentially creating a smart filtering system that makes search results actually useful. Instead of wading through hundreds of irrelevant results, you get exactly what you need. The best part is how easy it is to implement. You can set this up directly from the overview page and apply it immediately. There’s no complex configuration or additional tooling required. Really, it comes down to discipline. If teams just make it a habit to set statuses and organize their object types properly, they’ll save themselves countless hours of searching through cluttered results. It’s one of those small investments that pays big dividends.
  • Can you share an example where community feedback was positively enacted?

    • Honestly, there are tons of examples. We work hard to capture the issues reported by our users, with the developer community being one form of input, which is then documented into a list and we work on fixing them on company-wide allocated “hack days”. We also capture feature request information from the community to understand what features we can introduce to benefit the most users. We keep our eyes on the community for the most part, and we’re grateful to be recognized for our speed in providing fixes by the public, sometimes through a tweet!
  • Can you tell me about a time when user feedback challenged your assumptions about what would be valuable to them?

    • Here’s a story that initially felt counterintuitive but made perfect sense once I understood the user perspective. When we rolled out our new link type creation wizard and demoed it to customers, we expected positive feedback on the clean, polished interface. Instead, users told us they’d never actually use it. Their reasoning was brilliant: “If the configuration page still uses the old UI, there’s no point learning this new wizard since we’ll only see it once. We’d rather just go straight to the configuration page and learn that interface instead.” This feedback was a lightbulb moment for our design team, who immediately worked to bring the new UI to the configuration page as well. It taught me that what seems like a simple improvement (adding a nice wizard) isn’t valuable to users unless the entire workflow is consistent. Users think holistically about their experience, not just individual touchpoints.

And finally, our Ontology Frontend team wants to hear from you! Help us shape the future of Ontology Manager by sharing your thoughts on these questions:

    • Where should the Ontology Manager team focus its energy? Right now, Ontology Manager is the source of truth for ontology management, but Workflow Builder handles graph views and Object Explorer is great for exploration. What do you think Ontology Manager should own versus what other applications do better? Tell us where you want us to double down, or whether you want us to smoothly transfer you to the other applications that are specialized for certain applications.

    • How should we handle feature overlap? When Ontology Manager shows object type dependencies and Workflow Builder shows the same info as a graph with lineage, should we build lightweight or full versions of the same feature in Ontology Manager for quick reference, or should we focus on seamless navigation between apps? Do you prefer having everything in one place or specialized tools that work well together?

    • As ontologies get more complex, how can we help you succeed? With shared value types, interfaces, and growing feature sets, are the concepts clear when you’re setting things up? Should Ontology Manager be more educational and guide you through best practices, or do you prefer learning through our documentation and Palantir Learn? What kind of in-app guidance would help you best to reach your goals?

Drop your thoughts in the comments below - your real-world experience using these tools is exactly what we need to hear to build better products for everyone!

13 Likes

For ontology creation, maybe I have missed it but is there some programmable way (IAC)?
When I’m doing ontology work it feels very ClickOpps

2 Likes

Thank you a lot for the insight. One thing that comes to my mind is that I have to reload the ontology manager each time I published a new function e.g. backing an action type. When loading the data on demand it would be nice to always get the latest version info when choosing from the respective dropdowns. This would greatly improve the workflow. I actually did not think that the data was not loaded upfront since I always had to reload if there was new info.

Another thing that would be awesome: Check action permissions with example settings / objects for other users. When having complex validation logic it would be great to test this by putting the hat on of another user end trying to execute the action e.g. in a scenario environment.

For the interoperability with other ontologies e.g. OWL-based that are external to Foundry, it would be great to have more export-options or query endpoints. While it is appreciated that one can get the “complete” ontology metadata via a single get endpoint, it lacks a lot of information. While the type classes are only a sidenote compared to how the ontology manager worked a few years ago, they could be an extremely useful way of assigning object types and relations e.g. to OWL concepts for integrating Foundry with other knowledge management systems.

Furthermore, there are several things that are not "complete” when it comes to the OWL syntax. Link types do not have an “inverseOf” property - pointing to the exact inverse of a relationship. This can be useful for object traversal back and forth, if there are multiple link types between to object types (or one object type itself).

Having some experience with open source ontology frameworks, I do appreciate the easiness of use in the ontology manager and also the possibility for having pullrequests to seamlessly evlove the ontology. You do not have to understand triple syntax or how SPARQL works as it is required when looking at ontology languages like “foaf” or “OWL”. More compatibility with those frameworks would be really nice, though :wink:

There are several threads regarding those topics in this forum and I am looking forward to having more discussions - how to integrate the ontology in a highly diversified enterprise landscape.

Best,

Florian

1 Like

Here are the related threads that I am aware of in this forum that involve the ontology manager one way or the other and are probably still of relevance.

True Knowledge Graph Capabilities - Product Feedback - Palantir Developer Community

Improvements to Ontology Information via Foundry API - Product Feedback - Palantir Developer Community

Can a link that’s effectively many-to-many be implemented by a many-to-one link that uses an array of pks to link? - Ask the Community - Palantir Developer Community

External LinkTypes in Ontology Manager - Product Feedback - Palantir Developer Community

Enums and String literal union types as arguments in Functions on Objects - Product Feedback - Palantir Developer Community

Set optional Webhook parameters to empty - Product Feedback - Palantir Developer Community

Use Webhooks with Outbound Application(Oauth2 code grant) - Product Feedback - Palantir Developer Community

1 Like

I believe there is development work being done on something very similar, as we want to encourage both procode and nocode ways of working with the ontology!

Thank you a lot for the insight. One thing that comes to my mind is that I have to reload the ontology manager each time I published a new function e.g. backing an action type. When loading the data on demand it would be nice to always get the latest version info when choosing from the respective dropdowns. This would greatly improve the workflow. I actually did not think that the data was not loaded upfront since I always had to reload if there was new info.

I believe this already happens if you don’t have any edits made to the Ontology, when we update your version every 30 seconds. I agree that we could be smarter about this if there were some edits made!

Another thing that would be awesome: Check action permissions with example settings / objects for other users. When having complex validation logic it would be great to test this by putting the hat on of another user end trying to execute the action e.g. in a scenario environment.

It’s worth tagging @mrauen here, as he owns this actions piece, but completely agree that testing security is very critical (and we already offer testing workflows for things like Restricted Views, where data security is critical, so we should definitely offer them for this workflow as well!)

For the interoperability with other ontologies e.g. OWL-based that are external to Foundry, it would be great to have more export-options or query endpoints. While it is appreciated that one can get the “complete” ontology metadata via a single get endpoint, it lacks a lot of information. While the type classes are only a sidenote compared to how the ontology manager worked a few years ago, they could be an extremely useful way of assigning object types and relations e.g. to OWL concepts for integrating Foundry with other knowledge management systems.

Yes, I believe @tmiskow will have the most relevant take on this.

Furthermore, there are several things that are not "complete” when it comes to the OWL syntax. Link types do not have an “inverseOf” property - pointing to the exact inverse of a relationship. This can be useful for object traversal back and forth, if there are multiple link types between to object types (or one object type itself).

I’d be curious to know where this falls short. If you have one object with multiple links to other objects, it should be easy to traverse the link in both directions, in an app like Vertex for example.

Having some experience with open source ontology frameworks, I do appreciate the easiness of use in the ontology manager and also the possibility for having pullrequests to seamlessly evlove the ontology. You do not have to understand triple syntax or how SPARQL works as it is required when looking at ontology languages like “foaf” or “OWL”. More compatibility with those frameworks would be really nice, though :wink:

I think @tmiskow is still best placed to talk about Ontology interoperability and future plans in this direction, but completely agree that compatibility is very useful here.

Thank you for your thoughtful comments and we look forward to incorporating them into our planning sessions!

1 Like

The issue arise if you have schema-agnostic code and you or a model takes a “walk” through the ontology. I am primarily using the Foundry API to get the ontology metadata. The LinkType information, however, is not complete in the sense that you cannot get the “inverseOf” according to this definition from the “web ontology language” - OWL:


4.2.2 owl:inverseOf

Properties have a direction, from domain to range. In practice, people often find it useful to define relations in both directions: persons own cars, cars are owned by persons. The owl:inverseOf construct can be used to define such an inverse relation between properties.

Syntactically, owl:inverseOf is a built-in OWL property with owl:ObjectProperty as its domain and range. An axiom of the form P1 owl:inverseOf P2 asserts that for every pair (x,y) in the property extension of P1, there is a pair (y,x) in the property extension of P2, and vice versa. Thus, owl:inverseOf is a symmetric property.

An example:

<owl:ObjectProperty rdf:ID="hasChild">
  <owl:inverseOf rdf:resource="#hasParent"/>
</owl:ObjectProperty>

Since the LinkType metadata endpoint (/api/v2/ontologies/{ontology}/objectTypes/{objectType}/outgoingLinkTypes/{linkType}) only provides your view in a single direction, you do not know if that link is a many-to-many, or many-to-one. Your cardinality property only states “MANY” on your current side, and there is no way to look on the other side of that link type from an API perspective - let alone get the info how the data should be joined.

I hope this helps :smiley:

Hey Florian! Thanks for the feedback!

Interesting. Generally, the way Ontology Manager works is we cache data from external systems (e.g. Functions) on the first load so we can then skip refreshes when you open dropdown selectors again, and only the ontology-specific data is refreshed regularly. I will pass the signal, though, and maybe something could be done about function versions specifically.

Separately, I would want to work on making Ontology Manager load faster and make these page refreshes a bit less painful for you :sweat_smile:

Curious if you are looking for compatibility with specific framework because you sync data between two systems or rather just having a documented and consistent import/export format you can use for your ontology?

I think “Webprotegé” is pretty common for editing OWL ontologies etc. If you don’t run a triple store database like Virtuoso, most of the exchanged ontologies follow the RDF (resource description framework) format either in XML or turtle (.ttl) files.

If someone would like to integrate the Foundry Ontology somewhere else, this could look like:

  1. Query the respective ontology from foundry to be received in the RDF

  2. Use an RDF-based translation-ontology to integrate the foundry concepts into your bigger knowledge architecture.

Anyways, one can also consider a much simpler case: You use the Foundry API together with the foundry-platform-sdk to create a great custom app that integrates with your ontology and other business components. The behavior is largely depending on your ontology. Some of these parts of this app need special metadata that goes beyond rendering hints e.g. whether a property is on a categorical or ordinal scale (important for visualizations). With type classes you could assign this behavior directly to the ontology using the ontology manager implementing a pattern like ‘app/domain : custom property ’ (awesome!). Unfortunately, this metadata is not transparent outside of the ontology manager, if you try to access it through the Foundry API. Hence, everything that you build custom has to be manually adapted to changes in the ontology which potentially leads to double book keeping and less time spent curating the ontology using the ontology manager.

Agreed that this would be really cool! We’ve discussed some versions of this internally, but don’t have anything that we’re ready to commit to quite yet. There are some explorations happening across Foundry of what it would look like to be able to view apps from the perspective of another user, and I’d expect will see more investment in that space in 2026.

With that said, we are already building (to be shipped this year) the ability to simulate an action execution and get a full readout of the generated ontology edits, any side effects, and the object types and link types that were read from. That should make it a bit easier to debug why a user might not have the experience you expect (e.g. there was a broad regression in the action type that you can reproduce, or the action type has started filtering by a link type that this user can’t access).

1 Like

Thanks to everyone who participated in our first AMA! We really appreciate the questions, feedback, and insights you shared. This kind of engagement helps product teams understand what matters most to you. :partying_face:

I hope you found the behind-the-scenes look at Ontology Manager valuable.

If you have more questions for the Ontology team, simply create a new post and tag it with ontology-management.

Stay tuned for next month’s AMA featuring a different product team!

Also, not sure if Ontology related - When you materialize an object I think its a snapshot? I think it would be useful to allow an incremental? (FWIW chatGPT think it does already LOL)

1 Like

I think GPT may have something close to the truth, our materializations use incremental snapshots wherever possible to avoid increasing cost for the customer, though this is not always guaranteed

Hi @mellerbeck , as the AMA has finished, I’d like to welcome you to create a new thread if you have any additional comments for our Ontology team from here on out. Thank you for being engaged!