← 3c Enterprise


TL;DR? Then skip to Demo D3 “Speedrun – Your First Agentic AIP Workflow”, a great example of the direction this part of ZiptieAI is heading.


These demos are not for show. They are for do-it-yourselfers. Those like myself who want minimal text/diagrams and maximum useful info for getting hands-on experience. The main focus is on

  • Organizing the demos into a series that intros Foundry in logical order.
  • Getting the workflows correct and explaining the big picture concepts.
  • (1) Creating ZAI versions of existing PAL demos and (2) creating (from scratch with AI assistance) original ZAI demos (such as “3.1 D9 Haystack needle demo”).
  • Generating the ZAI website docs from docx files (using GPT).

See also (these are outdated… I will update them later)


TOC:

  • 1 Basic demos with external AI models. This is the first set of demos because ZAI focuses primarily on AI and external models are simpler than internal models.
  • 2 Basic demos with internal AI models. Demos that show how to create and host internal models.
  • 3 Basic demos without AI. Palantir started out with no AI. And AI now is still just a helpful assistant. This section focuses on the core non-AI Foundry basics.
  • 4 Other demos. Duplicate or unimportant demos (or demos I could not get to work).


1 Basic demos with external AI models

This sections focuses on getting started (grasping core concepts via hands-on demos) with Foundry demos that use external AI models.

TOC:

  • 1.1 D1 = “Speedrun – Your First End-to-End Workflow”
  • 1.2 D2 = “Speedrun – Your First AIP Workflow”
  • 1.2b Both D2 and D3 send enterprise data to external LLMs — why does Palantir call D3 the first “agentic” demo?
  • 1.3 D3 = “Speedrun: Your First Agentic AIP Workflow”
  • 1.4 D3b (TODO) = D3 + PAL “crystal ball” controls FOR AGENTS + EXTERNAL AI MODELS


1.1 D1 = “Speedrun – Your First End-to-End Workflow” (26.0818)

Your first hands-on with the basics (pipeline, ontology, actions, UI).

  • D1 does not include AI, but its perhaps a required starter for understanding the Foundry basics.
  • A good demo (though a bit too complicated as an initial demo.. I would make something simpler). Plan on spending minimum a full day on this (the demo docs say you will need only 60 minutes).
  • The ZAI splits the demos into 3 phases (this makes the demo much easier to finish and understand).

Demo D1 first end-to-end workflow diagram (no AI) (WIP)
xxx


1.2 D2 (WIP) = “Speedrun – Your First AIP Workflow” (26.0828)

Your first app with AI.

  • Use AI (external models) to clean up extracted chunks of text from PDFs, to extract text keywords (“entities” in the demo) from the chunk, to match a question to chunks via embeddings (machine language representation of the question/chunks meanings (not keywords)), make a RAG call with the question/chunks to answer the question.
  • About half of the demo has nothing to do with AI (the ZAI version splits the demo into 3 phases; phase 3 is the no-AI part; you can skip it).

Demo D2 first AIP workflow (ZAI) diagram (26.0828) (3 different AI models are used)
xxx


1.2b Both D2 and D3 send enterprise data to external LLMs—why does Palantir call D3 the first “agentic” demo? (26.0902)

Follow the above header link for details. See also the complete chat with FDE/GPT.

My own simple explanation (refer to diagram below)

  • Demo D2 made calls to external LLM. That is (in my opinion)
    • an AI agent
    • that shares internal data with an external LLM.
  • However, D3 (the next demo) does several things that D2 did not:
    • (3)(4) Foundry AIP_Logic (a no-code function definition) calls an LLM like D2, but it also modifies the ontology (core objects)
    • (2) Foundry Automation (event-driven automation service) provides a main loop that automatically processes (in D3 this means calling API_logic) any incoming onotology data changes.

[3] Demo D3 Foundry agent
xxx


1.3 D3 (WIP) = “Speedrun: Your First Agentic AIP Workflow” (26.0902)

This demo builds the first autonomous operational agent in this sequence.

  • (1) A new Patient is added through the UI and written to the Ontology.
  • (2) Automate detects that the Patient entered the monitored object set.
  • (3)(4a) AIP Logic evaluates the Patient against the selected Clinical Trial.
  • (3)(4b) The governed Action automatically writes the initial eligibility decision and reasoning.
  • (5) Staff review the result and may manually adjust the eligibility decision through the UI. This last step is important: Automation makes the initial operational decision, but staff retain oversight and can override it through a governed Action.

Diagram of the workflows for the ZAI version of demo D3 “Speedrun: Your First Agentic AIP Workflow”
xxx


1.4 D3b (TODO) = D3 + PAL “crystal ball” controls FOR AGENTS + EXTERNAL AI MODELS)

Work with GPT/FDE to add Foundry safety rails to D3 to make using agents + remote LLMs and agents safer (finding an existing demo for this would be better).


2 Basic demos with internal AI models

My interpretation of the Palantir post below:

  • Frontier labs (OpenAI, Grok, etc; companies creating LLMs on the frontier, on the edge, of what is possible) are using prompts they get about sensitive topics to train their future models on (for example, GPT knows everything about ZiptieAI, although there’s not much super-secret in all that knowledge). I think this is what he means by giving up sovereignty.
  • These labs will take that knowledge and start to offer competing services based on their LLMs. Thats just the logical next step.
  • The solution: You use your own local models. No data goes outside the company. Your proprietary data stays in-house. You use RAG (you feed your data into LLMs that have not been trained on that data; basically the super-sensitive knowledge is not “baked-in” to the LLM).
  • How do you do that? First of all, you start off with a trial version of Palantir Foundry, you learn the basics doing the ZAI demos D1, D2, and D3 (based very much on original Foundry demos), and then you do the following D8 demo “Deep Dive: Model integration”. After that you truly understand the problem and the solution.

Alex Karp sounding the alarm about the risks of AI in the enterprise.
xxx


2.1 D8: Deep Dive: Model integration (26.0903)

Demo D8 explores how a traditional machine-learning model can be trained, deployed, and used for inference inside Palantir Foundry. The demo first examines Foundry’s Model Studio and model-management workflow, then creates a project and trains models using two approaches: Model Studio and a Jupyter notebook. Finally, the trained model is deployed and connected to an interactive application for inference. The demo therefore follows much of the model lifecycle: data → training → model → deployment → inference → application.

Training of the internal model
xxx


2.2 D3c (TODO) = D3(b) + D8 (local (maybe custom trained) models)

Locals models (+RAG) are probably the optimal solution (see D8 demo description below on this page).


3 Basic demos without AI


3.1 D9 (TO-UPDATE, DIY) = Haystack needle demo

What has interested me the most about Palantir for over a year now are “haystack needle” (HN) algorithms. This was the original reason for the founding of PAL. PAL’s job was to sift through vast amounts of data to flag potential threats (for the first decade or so without the help of AI). To find the needle in the haystack. Thats what this demo does. The demo is DIY (do it yourself), which means it was created from scratch with only FDE/GPT assistance.

xxx


3.2 D5 (TO-UPDATE): Speedrun: Mining Your First Business Process (26.0718)

FDE: The demo starts with claims, customers, and claim-history logs. After ingesting these datasets into Foundry, the data is modeled as Ontology objects such as Customers and Claims. Machinery then uses the process logs to reconstruct how claims move through the business process over time. Once the process map is built, you can inspect where claims get stuck, identify why some remain unresolved, and embed the process view into an interactive application.

xxx


4 Other demos


26.0904 (v1 26.0725)