Supervised Learning — The model learns from labeled data (input-output pairs). Used for classification (spam/not spam) and regression (predicting house prices). Examples: logistic regression, random forests, neural networks.

Unsupervised Learning — The model finds patterns in unlabeled data. Used for clustering (customer segments), dimensionality reduction (PCA), and anomaly detection. Examples: k-means, autoencoders.

Reinforcement Learning (RL) — An agent learns by interacting with an environment to maximize a reward signal. Key concepts: states, actions, rewards, policies. Used in game playing, robotics, and notably in RLHF for aligning LLMs.

A neural network is a computational model inspired by biological neurons. It consists of layers of interconnected nodes (neurons) that transform inputs through weighted connections and activation functions.

• Input layer — receives raw features
• Hidden layers — learn increasingly abstract representations
• Output layer — produces predictions

Deep learning = neural networks with many hidden layers. This depth allows the model to learn hierarchical representations (edges → textures → objects in images).

Key architectures: CNNs (images), RNNs/LSTMs (sequences), Transformers (everything modern).

Training is the process of adjusting model weights to minimize a loss function using gradient-based optimization.

• Loss function — measures how wrong predictions are (e.g., cross-entropy for classification, MSE for regression)
• Backpropagation — computes gradients of the loss w.r.t. each weight
• Gradient descent — iteratively updates weights in the direction that reduces loss
• Learning rate — controls step size; too high = overshoot, too low = slow convergence

Overfitting = model memorizes training data but fails on new data. Mitigated by regularization, dropout, early stopping, and more training data.

The Transformer (Vaswani et al., 2017 — "Attention Is All You Need") revolutionized NLP and now powers almost all modern AI systems.

Key innovation: Self-attention mechanism — allows each token to attend to every other token in the sequence, capturing long-range dependencies without the sequential bottleneck of RNNs.

• Encoder — processes the full input (used in BERT-style models)
• Decoder — generates output token by token (used in GPT-style models)
• Encoder-Decoder — used in translation (T5, original Transformer)

Other key components: positional encodings, multi-head attention, feed-forward layers, layer normalization, residual connections.

• Token — smallest unit of text processed by an LLM (roughly a word or sub-word)
• Embedding — dense vector representation of data (words, sentences, images)
• Inference — using a trained model to make predictions on new data
• Fine-tuning — adapting a pre-trained model to a specific task with additional training
• Transfer learning — leveraging knowledge from one task/domain to another
• Parameters — the learnable weights in a model (e.g., GPT-4 has ~1.8 trillion)
• Epoch — one complete pass through the training data
• Batch size — number of samples processed before updating weights
• Hallucination — when a model generates plausible but factually incorrect output
• Grounding — anchoring model outputs to factual, verifiable sources

LLMs are trained in two main phases:

1. Pre-training — The model learns language patterns from massive text corpora (books, web, code). The objective is typically next-token prediction: given a sequence, predict what comes next. This is self-supervised (no human labels needed).

2. Alignment — The pre-trained model is then aligned with human preferences through:

• Supervised Fine-Tuning (SFT) — trained on human-written examples of ideal responses
• RLHF (Reinforcement Learning from Human Feedback) — a reward model scores outputs, and RL optimizes the LLM to maximize that score
• Constitutional AI / RLAIF — AI-generated feedback guided by principles

Scaling laws show that model performance improves predictably with more parameters, data, and compute — which is why models keep getting larger.

The context window is the maximum number of tokens an LLM can process at once (input + output). Modern models range from 8K to 1M+ tokens.

Larger context windows enable: processing long documents, multi-turn conversations, and complex reasoning. But attention cost scales quadratically with sequence length (O(n²)), so various optimizations exist:

• FlashAttention — memory-efficient exact attention
• Sliding window attention — local attention patterns
• KV-cache — caches key/value pairs to avoid recomputation during generation

The art and science of crafting inputs to get optimal outputs from LLMs.

Key Techniques

• Zero-shot — ask the model directly, no examples
• Few-shot — provide examples of desired input/output pairs
• Chain-of-thought (CoT) — instruct the model to "think step by step"
• System prompts — set the model's role, constraints, and output format
• Structured output — request JSON, XML, or specific formats

Enterprise Considerations

• Prompt templates should be version-controlled
• Guard against prompt injection attacks
• Use output validation and structured schemas

RAG combines an LLM with an external knowledge retrieval system to ground responses in real, up-to-date data.

Key components:

• Vector database — stores document embeddings (Pinecone, Weaviate, Chroma)
• Embedding model — converts text to vectors for similarity search
• Chunking strategy — how documents are split into retrievable pieces
• Reranking — improves retrieval quality after initial search

Why RAG matters for SwissRe: Enables LLMs to answer questions grounded in proprietary insurance/reinsurance data without retraining the model.

Agentic AI refers to systems where LLMs autonomously plan, use tools, and take actions to accomplish goals — going beyond simple question-answering.

Key components of an AI agent:

• Planning / Reasoning — breaking down tasks into steps
• Tool use — calling APIs, querying databases, running code
• Memory — short-term (conversation) and long-term (persistent store)
• Reflection — evaluating and correcting its own outputs

Relevance to SwissRe: Their "Built to Lead" strategy explicitly mentions agentic AI that blends predictive and generative capabilities to redesign core processes and end-to-end workflows.

Evaluating LLMs is fundamentally different from traditional ML metrics:

• Benchmarks — MMLU, HumanEval, HellaSwag, etc.
• Human evaluation — preference rankings, Elo ratings (like Chatbot Arena)
• LLM-as-judge — using one model to evaluate another's outputs
• Domain-specific evals — custom test suites for your use case

Governance concerns in enterprise:

• Data privacy — what data goes to external APIs?
• Bias and fairness — especially critical in insurance
• Explainability — can you justify AI decisions to regulators?
• Audit trails — logging inputs, outputs, and model versions
• EU AI Act compliance — risk-based classification of AI systems

Palantir Foundry is the core data operating system for commercial enterprises. It provides end-to-end capabilities for:

• Data Integration — connects to virtually any data source (databases, APIs, files, streaming). Handles schema mapping, deduplication, and transformation.
• Data Pipelines — visual and code-based (Python, SQL, Java) pipeline builder for ETL/ELT workflows with full lineage tracking.
• Ontology — the semantic layer that maps raw data to real-world business objects (more on this below).
• Analytics & Dashboards — tools like Contour (data exploration), Quiver (dashboards), and Slate (custom apps).
• Operational Workflows — enables business users to build decision-making applications on top of the Ontology.

Key differentiator: Foundry doesn't just store data — it creates an operational layer where data drives real business decisions and actions.

The Ontology is perhaps the most important concept to understand about Palantir. It's a semantic layer that sits on top of raw data and maps it to real-world business concepts.

Think of it as a digital twin of the organization:

• Object Types — represent real-world entities (e.g., "Policy", "Claim", "Customer", "Risk Assessment")
• Properties — attributes of objects (e.g., policy number, premium amount)
• Links — relationships between objects (e.g., "Customer" → has → "Policy")
• Actions — operations that can be performed on objects (e.g., "Approve Claim")
• Functions — computed logic that operates on objects

Why it matters: The Ontology allows business users to interact with data using domain language, not SQL. It also provides the structured context that LLMs need in AIP to take real operational actions rather than just generating text.

AIP (Artificial Intelligence Platform) is Palantir's layer for integrating LLMs into enterprise operations. It connects AI with the Ontology.

Core AIP tools:

• AIP Logic — build AI-powered decision workflows that combine LLM reasoning with Ontology actions
• AIP Chatbot Studio — create chatbots grounded in organizational data
• AIP Evals — test and evaluate AI pipeline performance
• AIP Agents — autonomous agents that plan and execute multi-step tasks

Key architecture principles:

• LLMs are grounded in the Ontology — they can only access and act on data the user has permissions for
• Supports multiple LLM providers (OpenAI, Anthropic, open-source) — model-agnostic
• Built-in governance: access controls, audit logs, data lineage
• Designed for operational AI — not just chatbots, but real business actions

Gotham is Palantir's platform for government and defense/intelligence agencies. It handles massive, multi-modal datasets (satellite imagery, signals intelligence, text, geospatial data).

• Powered by the same Foundry-managed Ontology
• Specialized for intelligence analysis, counter-terrorism, and military operations
• Originally the core of Palantir (founded 2003 with CIA backing)

Less relevant for a SwissRe interview, but worth knowing to understand Palantir's full portfolio and data integration heritage.

Apollo is Palantir's continuous delivery and infrastructure management platform.

• Manages thousands of zero-downtime upgrades daily
• Deploys to any environment: public cloud, private cloud, on-prem, edge, IoT, air-gapped
• Abstracts infrastructure complexity — customers don't manage Kubernetes clusters
• Enables FedRAMP / IL-classified deployments for government

Why it matters: Apollo is what makes Palantir deployable in highly regulated environments like reinsurance (SwissRe), where data sovereignty and on-prem requirements are common.

The Knowledge Engine is Starmind's core AI that builds two interconnected graphs:

• Topics Graph — learns the language and knowledge domains of your organization. Automatically organizes knowledge into meaningful, searchable topics.
• Experts Graph — maps employees to their real expertise based on contributions, not job titles. Evaluates recency, depth, and context of expertise.

The system uses passive data collection — it analyzes emails, documents, project contributions, and support tickets without requiring employees to manually update profiles.

The more the organization uses it, the smarter it gets — continuously refining expertise profiles and recommendations.

The Expert Finder instantly matches employees to the right internal expert.

• Works directly in Microsoft Teams or Slack
• Users describe their challenge in natural language
• Experts are identified based on real work, not outdated directories or job titles
• Considers context, track record, and availability

Business value: Reduces time spent searching for knowledge, prevents knowledge silos, and ensures departing employees' expertise isn't lost.

Released in 2025, the Topic Explorer allows users to:

• Navigate organizational knowledge visually
• Discover related topics and trending discussions
• Find subject matter experts per topic
• Understand how knowledge domains connect across teams

Starmind is deeply integrated into the Microsoft ecosystem:

• Microsoft Teams — primary interface for asking questions and finding experts
• Microsoft 365 / Outlook — data sources for expertise signals
• Microsoft 365 Copilot — complementary AI integration
• Power Platform Connector — links to Logic Apps, Power Apps, Power Automate

SAP Migrations: Starmind helps preserve tribal knowledge during large SAP migration projects by identifying who knows what about legacy systems.

Starmind emphasizes a human-centered, privacy-first approach:

• Swiss origin — strong European data privacy heritage
• GDPR compliant
• Employees control what's shared and visible
• No monitoring of individual productivity — only expertise signals
• Data stays within customer's environment

SwissRe operates data-intensive applications spanning:

• Origination & Underwriting — risk assessment and pricing
• Treaty & Claims Management — policy administration and claims processing
• Actuarial Analysis — statistical modeling of risk
• Solvency Stress Testing — regulatory capital requirements
• Finance — treasury, asset management, statutory reporting

Palantir Foundry unified these data silos, allowing underwriters, actuaries, and data teams to collaborate on a single platform.

SwissRe's Palantir-powered platform combines:

• Automation — streamlining repetitive processes
• Ontologies — mapping reinsurance concepts as business objects
• Vector management — enabling RAG-style retrieval over proprietary data
• Simulation — scenario modeling and risk analysis
• Application building — business users creating their own operational tools
• Central governance — compliance, audit trails, access control

While there's no confirmed direct SwissRe-Starmind partnership, understanding Starmind is valuable because:

• Complementary to Palantir — Palantir handles structured/unstructured data operations; Starmind handles the human expertise layer that no database contains
• Knowledge management in reinsurance — reinsurance relies heavily on specialized expertise (catastrophe modeling, actuarial science, legal frameworks) that often lives only in people's heads
• Swiss ecosystem — Starmind is a Swiss company, and many Swiss enterprises (especially in financial services) have explored or adopted it
• The role may bridge both — the candidate might work on integrating knowledge management capabilities alongside the Palantir data platform

Sample answer: "Think of the Ontology as a live map of our business. Instead of looking at spreadsheets of policy numbers and claim IDs, you see actual Policies, Customers, and Claims as objects you can interact with — just like on a map you see cities and roads, not GPS coordinates. Each object knows what it's connected to: this Customer has these Policies, which have these Claims. And you can take actions on them — approve a claim, flag a risk — all while the system tracks who did what and why."

Sample answer: "RAG retrieves relevant documents at query time and includes them in the prompt — the model's weights don't change. Fine-tuning actually updates the model's weights on your data. Use RAG when you need up-to-date answers from a changing knowledge base (like our policy documents). Use fine-tuning when you need the model to consistently behave in a certain way — like always formatting risk assessments in our specific template. In practice, most enterprise use cases start with RAG because it's faster to deploy, easier to update, and you can trace exactly which documents informed each answer."

Sample answer: "Governance in regulated AI requires multiple layers: First, data access controls — Palantir's Ontology ensures the LLM only sees data the user is authorized to access. Second, audit trails — every AI-assisted decision logs the input, model version, retrieved context, and output. Third, human-in-the-loop — for high-stakes decisions like large claim approvals, AI recommends but humans decide. Fourth, evaluation pipelines — regular testing against known-good answers to catch model drift. And fifth, explainability — when a regulator asks 'why did the system flag this risk?', you need to show the data and reasoning chain, not just the answer."