For teams already on Palantir Foundry — deploy the Prometheux engine as a Compute Module that runs entirely within your enrollment, with full data sovereignty.

Overview

Prometheux runs natively inside Palantir Foundry as a Compute Module. The full engine is replicated in each Foundry pod and exposed as callable Functions, so your OSDK/TypeScript code, Workshop, and Ontology Actions can invoke live Vadalog reasoning — recursion, transitive closure, incremental updates, graph analytics — without any data leaving your environment. Unlike a batch container transform, the engine stays warm and in-process: each call reuses the running engine for low-latency, per-query reasoning, and predicates bound to Foundry datasets run directly against Iceberg-backed storage. Key advantages:
  • Data sovereignty — the engine runs inside your enrollment; data never leaves Foundry
  • Foundry-native security — invoked through Functions, Workshop, and Ontology Actions
  • Warm, in-process reasoning — per-query latency, not batch job startup
  • Build anything on one primitive — every capability is a Vadalog program passed to a single function

How it works

Everything is built on one primitive: evaluateWithParams. You hand it a Vadalog program (plus optional runtime params) and it returns the result set as JSON. Any higher-level capability — a reachability query, an ontology-backed lookup, an incremental update — is just a Vadalog program passed to this one function. You build what you want on top of it. Around that primitive, Prometheux already exposes a small function pool to manage live runs, so you don’t have to build run orchestration yourself: All inputs and outputs are strings (payloads are JSON strings) for maximum compatibility with the Foundry Functions type system.
The engine image is distributed privately. Your Prometheux contact provisions a short-lived pull token for the Prometheux registry. Nothing is published publicly, and once the image lives in your Foundry Artifacts repository the engine runs entirely within your environment.

Deploy

1

Get the engine image

Your Prometheux contact provides a registry host, image name, and a short-lived pull token. Log in and pull the image:
The image is built for linux/amd64, runs as a numeric non-root user, and exposes ports in the allowed range — the three requirements Foundry enforces on container images.
2

Push it into your Foundry Artifacts repository

In Foundry, create an Artifacts repository (Docker) in your project and open Publish to Docker to read your repository RID and a push token. Re-tag the image for your stack’s registry and push with a tag other than latest:
The artifact appears in your repository within about a minute.
3

Create the Compute Module

Create a Compute Module in Functions execution mode and add a container pointing at the image you just pushed. A typical sizing is 4–8 CPU and 8 GB memory; set minimum replicas to 1 to keep the engine warm. Start the module and confirm from the logs that the engine banner appears, followed by the function poller starting.
4

Register the functions

Under Define functions, choose Detect with SDK at runtime. Once the module is active, the five functions above are discovered automatically — no manual schema declaration needed. Give evaluateWithParams an API name (for example runPX) to make it callable from pro-code contexts.
5

Call it from OSDK / TypeScript

Import the query function into a TypeScript Functions repository via the Resource Imports sidebar, then call it through the generated SDK:
From here the engine is a super-efficient reasoning backend for your Ontology: wire it into Workshop, back an Ontology Action with it, or call it from any pro-code Function.
Prefer a managed option? The same engine is also available as a cloud deployment and on-premises install — see Installation.