3c.1 PAL AI usage strategy

Perhaps the most important thing to understand when working in PAL Foundry is how to use 2 sources of PAL help

to do the following:

solve problems
get general workflow directions
led you by the hand step by step through complicated tasks (using FDE with screenshot recognition)

1 Summary of AIP/FDE combined usage

I spent several weeks doing PAL demos (on a trial account that PAl so graciously offers) to get a grounded understanding of what PAL does (of course, PAL does much more, but this to me is the core ability, where it all started, the haystack needle search algorithm). After a little over 2 weeks I finally got the gist. I suggested to PAL AI that we create a demo that I thought would reveal the gist of the needle in the haystack search (this demo was my original idea). The built-in PAL AI (AIP) chatbot agreed “whole-heartedly”. AIP and I were able to create a demo that showed by example the core of how PAL does the needle search.

(of AIP/FDE limits, and how they make up for each other). There are limits they dont make up for

Neither can see the dialogs

1.1 FDE confirms this

ME: the built in AI/help:

(1) you (FDE) 
(1.1) you can see pasted  screenshots (of dialogs). 
(1.2) but you dont have access to the current tool i am in.
(1.3) you seem to have been trained on really useful data and workflows. 
(2) AIP
(2.1) cant see pasted screen shots
(2.2) has access to tool i am in.
(2.3) seems to only scan the (somewhat oudated and in complete) docs for info. often not correct.

FDE: Yes — that’s a good diagnosis.

The two assistants have complementary weaknesses:

Assistant	Strength	Weakness
Me / FDE	Can reason from screenshots, conversation history, workflows, and symptoms	I may not directly control or inspect the exact UI state unless you share it
AIP Assist in product	Knows current app/tool context and may offer UI-aware actions	Often cannot interpret screenshots you paste elsewhere and may rely heavily on docs/UI metadata

So the best practical workflow is:

Use FDE for reasoning, diagnosis, diagrams, and “what is happening?”
Use AIP Assist for “where is this exact button/control in the current app?”

For complicated UI, the ideal loop is:

Ask AIP Assist: “where is the setting for X in this current app?”
Screenshot the result/dialog.
Ask me: “what should I set here and why?”

That combines tool context with reasoning.

2 AIP usage

(seems to come mainly from PAL docs; good for workflows, but no screenshot recognition and not so good at solving complex problems)

AIP is “built into” the dialogs and seems to know where you are; it can show general directions well, but seems to be more limited in helping with problems (I think AIP primarily searches the docs, not a knowledge store of real world problems)
drones

2.1 AIP’s own summary of itself

ME: where are you getting your info? from training, from palantir docs, or ????

AIP: Good question. Here is exactly where my answers come from:

My Information Sources

Palantir Documentation (primary source) When you ask me something, I search the official Palantir/Foundry documentation in real time. Every claim I make that comes from those docs gets an inline citation like ABC1. You can see those throughout my previous answers.
My Training Data (fallback) For general coding questions (Python, SQL, etc.) with no Palantir-specific meaning, I may draw on general programming knowledge. I try to be clear when I am doing this versus citing docs.
Your Session Context I can see things you share with me directly — like the RID ri.eddie.main.pipeline.eedc60df-64da-475d-9a8b-1efaa4d9ce93 that was passed along with your message. I cannot access what is inside that pipeline — your actual data, transforms, or configurations. I only see what is explicitly shared in our conversation.

What I Cannot Do

I cannot browse the internet or Palantir’s website live
I cannot see inside your Foundry environment — your datasets, object types, or pipeline logic
I cannot guarantee my documentation search covers every Palantir feature, especially very new ones

The Honest Bottom Line. If I cite something, it came from the docs. If I do not cite it, ask me to verify — I should either find a source or tell you I am not certain. That is the standard I try to hold myself to.

3 FDE usage

(seems to have the hard core experience of human FDE’s embedded into it; can recognize screenshots (a critically important capability), and can lead accurately thru stepbystep processes, and can drill down into the backend code)

3.1 Example

I pasted the following screenshot into the FDE chat window (no text, just the screenshot). Just one screenshot in a long list.

Screenshot of the problem: I check only “HIGH_VALUE (right) but all values are shown (left)”
drones

FDE: The filter list is working, but the table is not using the same filter variable. In your earlier screenshots there were likely two similar variables:

Selected Anomaly Reason Filter
Selected Anomaly Reason Filter1

Your filter widget is probably outputting to one, while Filtered Anomaly Events is using the other.

Next step. Open the variable:

Filtered Anomaly Events

In its definition, check the Using a variable field. Set it to the exact same variable shown in the filter widget’s Output Data. From your recent setup, that is probably:

Selected Anomaly Reason Filter1

So the wiring must be:

Filter widget output = Selected Anomaly Reason Filter1
Filtered Anomaly Events uses = Selected Anomaly Reason Filter1
Object table input = Filtered Anomaly Events

Right now the table is still showing all rows because those two filter variables do not match.

Result: Problem solved”
drones

This was just the last step in a quite challenging configuration of the Workshop as summarized in the following diagram. I tried to do it myself, and could not get it right. FDE led me by the hand through a clean config step by step, with me pasting screenshots and FDE describing what to do. Once you get used to the terminology and the UI, things become much easier. But without FDE it would have taken a long time to track down the problem.

A rough diagram of all the setup”
drones

3.2 FDE’s own summary of itself

ME: where are you getting your information? from palantir docs or from an FDE database or ????

FDE: I’m using a combination of:

General model training
- Broad knowledge about Palantir concepts, software patterns, UI concepts, and data/ML/app-building workflows.
- This is not a live database.
Tool-provided context in this chat
- When you provide a Foundry resource, I can sometimes inspect it with available tools.
- Example: Workshop module definitions, Ontology object types, datasets, functions, etc.
- For your Workshop app, I inspected the actual Workshop DSL definition.
Screenshots and text you paste
- A lot of the practical troubleshooting came from reading your screenshots and inferring the UI state.
Documentation loaded into the chat
- Sometimes I can load or use relevant Palantir docs/tool documentation.
- Docs are useful for API/structure, but often do not explain the exact UI wiring clearly.
Reasoning from first principles
- For example, the Workshop filter/table issue was mostly reasoning about data flow:
```
source object set → filter criteria variable → filtered object set → table
```

So it is not one hidden FDE database. It is: model knowledge + live tool context + screenshots + docs + reasoning.

4 Future capabilities

Real world apps change quickly. This ZiptieAI site is constantly evolving. I can manage this task by myself thanks to the AI tools that vastly simplify website management. Its the same when creating apps with PAL tools. AI inside of PAL (and other apps) will vastly improve in the few years, and this will revolutionize end user programming (PAL’s built-in AI has made using PAL vastly easier already, but there is still much room for improvement). I see a time when you can chat or talk with the help system, and it can walk you thru entire processes, filling in required info, etc. This will revolutionize the use of such enterprise SW. PAL right now is quite close to that ability (needs to combine AIP and FDE into one unit that can see dialog and entere commands). This is just another example of how AI is not a tech bubble (its only getting started).

26.0725 (v1 26.0720)

TOC