> For the complete documentation index, see [llms.txt](https://help.delpha.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://help.delpha.io/use-cases/ultimate-parent/how-selection-works/understanding-the-ultimate-parent-analysis.md).

# Understanding the Ultimate Parent Analysis

### Overview

The **Ultimate Parent** process in Delpha consists of **two main steps**:

1. **Identification** — Delpha's AI Agent determines the Ultimate Parent of a given account using insights from its **trusted sources**. This runs on Delpha's side.
2. **Matching** — Delpha searches within **your Salesforce org** to find the existing account that best matches this Ultimate Parent. This runs **inside Salesforce**, on your data, which never leaves your org.

The result of this process is what you see in the **Score Meter** on the record page.

> **Note:** Each account is analysed **on its own**. Salesforce sends the identity of a single record (name, website, country) to the AI Agent and receives the analysis of that record back. You can therefore run the Ultimate Parent use case on one record, on a selection, or on your whole database — the mechanics are the same.

### The technical output of the analysis

The analysis writes to several fields on the Account. The two that carry the full story are:

* **D Ultimate Data** (`delpha__DDQ_QualityUltimateRecommendedData__c`) — the complete technical output, in **JSON**.
* **D Ultimate Parent Comments** (`delpha__DDQ_QualityUltimateComments__c`) — the human-readable explanation of the recommendation (or the error message when the record could not be assessed).

The JSON in **D Ultimate Data** is divided into two sections:

* **Common (`common`):** the raw analysis returned by the Delpha AI-Agent — who the Ultimate Parent is, why, and the evidence behind it.
* **Recommendations (`recommendations`):** the ranked list of accounts **found in your org** that match that Ultimate Parent, each with its own matching score.

Example:

```json
{
  "recommendations": [
    {
      "account_id": "001fo000009a6rSAAQ",
      "account_name": "Salesforce",
      "score": 100,
      "status": "Potential",
      "sources": [
        { "source": "Assessment", "score": 100, "timestamp": "2026-06-06 01:36:47" }
      ]
    }
  ],
  "common": {
    "id": "001cb00000rFWxfAAG",
    "subsidiary_commercial_name": "Heroku",
    "ultimate_parent_legal_name": "Salesforce, Inc.",
    "ultimate_parent_commercial_name": "Salesforce",
    "ultimate_parent_website": "https://www.salesforce.com/",
    "ultimate_parent_country": "US",
    "relationship_type": "Wholly Owned",
    "confidence": 1.0,
    "comment": "Heroku was acquired by Salesforce in 2010. Salesforce is a widely held public company.",
    "evidence_summary": "Identity: Heroku verified | Chain: Heroku -> Salesforce, Inc. | Protocol: Protocol 9 (Active Conglomerate) | Discard Check: None | GTM Selection: Salesforce is the active operating conglomerate that wholly owns Heroku.",
    "source_url": "https://investor.salesforce.com/",
    "ultimate_parent_source_level": "Securities Filing",
    "is_self_ultimate": false,
    "ownership_chain": "[{\"entity_legal_name\": \"Heroku, Inc.\", \"entity_website\": \"https://www.heroku.com/\", \"is_discarded\": false, \"is_ultimate_financial_parent\": false, \"comment\": \"Target entity, wholly owned subsidiary of Salesforce.\"}, {\"entity_legal_name\": \"Salesforce, Inc.\", \"entity_website\": \"https://www.salesforce.com/\", \"is_discarded\": false, \"is_ultimate_financial_parent\": true, \"comment\": \"Ultimate financial and commercial parent; widely held public company.\"}]",
    "lei_data": "{\"lei_number\": \"RCGZFPDMRW58VJ54VR07\", \"legal_name\": \"SALESFORCE, INC.\", \"legal_jurisdiction\": \"US-DE\", \"lei_source\": \"https://search.gleif.org/#/record/RCGZFPDMRW58VJ54VR07\"}"
  }
}
```

### Step 1 — Identify the Ultimate (Reference)

Determine the real-world ultimate parent entity for the account, independent of what exists in your CRM.

The **`common`** section is the Ultimate Parent identified by the Delpha AI-Agent from its **trusted sources**. The agent receives only the account's **name**, **website** and **country**, and returns:

| Key                                           | Meaning                                                                                                        |
| --------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
| `ultimate_parent_legal_name`                  | Registered legal name of the Ultimate Parent (e.g. *Salesforce, Inc.*)                                         |
| `ultimate_parent_commercial_name`             | Name the parent goes to market with (e.g. *Salesforce*)                                                        |
| `ultimate_parent_website`                     | Official website of the Ultimate Parent                                                                        |
| `ultimate_parent_country`                     | Country of the Ultimate Parent                                                                                 |
| `confidence`                                  | How certain the agent is, from `0.0` to `1.0`                                                                  |
| `relationship_type`                           | *Wholly Owned*, *Member Firm/Franchise*, *Portfolio Company*, *Brand/Division*, *Joint Venture*, *Independent* |
| `comment`                                     | Plain-language explanation of the relationship                                                                 |
| `evidence_summary`                            | Condensed audit trail: identity check, chain, protocol applied, discard check, final selection                 |
| `source_url` / `ultimate_parent_source_level` | Where the conclusion comes from, and how authoritative it is (e.g. *Securities Filing*, *Company Website*)     |
| `ownership_chain`                             | Every entity examined between the account and the top of the group                                             |
| `is_self_ultimate`                            | `true` when the account **is** its own Ultimate Parent                                                         |
| `lei_data`                                    | The Legal Entity Identifier record of the Ultimate Parent, when one exists (GLEIF)                             |

In the example above, Delpha recommends **Salesforce, Inc.** (website `https://www.salesforce.com/`) as the Ultimate Parent of Heroku, with a **confidence of 1.0 (100%)**.

#### The ownership chain

`ownership_chain` lists every entity the agent walked through, from the account itself up to the top of the group. Each link carries its own name, website, country, LEI and a short comment, plus two flags that matter:

* **`is_ultimate_financial_parent`** — this entity is the top of the *financial* ownership group (which is not always the entity Delpha recommends for go-to-market purposes).
* **`is_discarded`** — the agent considered this entity as a possible Ultimate Parent and **deliberately rejected it**. Discarded parents are used later to explain why your current value may be defensible even though it is not the recommendation (see *Accuracy and consistency*).

> **Note:** Delpha's Ultimate Parent model reflects how companies operate and present themselves in the market — not how they're legally registered. By focusing on brand and operating structure, Delpha captures real commercial relationships and group affiliations relevant to sales, marketing, and territory management. This is especially useful for franchise and multi-brand organizations.

### Step 2 — Link to Parent in CRM (Match)

Find and link the best-matching record in your CRM that represents that reference parent (names may differ; matching relies on evidence).

This step runs **entirely inside your Salesforce org**, using Delpha's **AccountMatcher** library. Delpha never receives your account list; only the record being assessed is ever sent out.

The result is the **`recommendations`** array — the ranked shortlist of your own accounts:

```json
"recommendations": [
  {
    "account_id": "001fo000009a6rSAAQ",
    "account_name": "Salesforce",
    "score": 100,
    "status": "Potential"
  }
]
```

The best recommendation (the first one) is the one surfaced in the Score Meter, and its `score` becomes the confidence you see on the record.

### How Matching Works

**Candidate Shortlist**

Delpha searches your org for accounts that could be the Ultimate Parent:

* When the recommended parent has a **website**, the shortlist is every account sharing its **root domain** (up to 200, the largest hierarchies first).
* When it has **no website**, Delpha falls back to a **name search** on Account (up to 1 000 suggestions).

The search is run **twice** — once with the parent's **legal name**, once with its **commercial name** — and the two result lists are merged, best-first, keeping up to **5 distinct accounts**.

**Support Fields**

Two data quality fields are used to evaluate each candidate:

* **`Account.DDQ_QualityWebsiteDomain__c`** (*D Website Domain*) — the root domain of the account website.
* **`Account.DDQ_QualityAccountHierarchyCount__c`** (*D Hierarchy Count*) — number of accounts in the hierarchy (`Account.ParentId`).

**Scoring**

Each candidate is scored on three criteria, each with its own weight:

| Criterion              | Field               | How it is scored                                                                                                                         | Weight |
| ---------------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ------ |
| **Name similarity**    | `Name`              | Fuzzy comparison against the recommended name: `1 − distance / length`                                                                   | 5      |
| **Domain match**       | `D Website Domain`  | `1` when it equals the recommended root domain, `0` otherwise — **mandatory** when a website is known                                    | 3      |
| **Hierarchy position** | `D Hierarchy Count` | Log-scaled ratio against the largest hierarchy in the shortlist — rewards accounts that sit higher in the tree, with diminishing returns | 10     |

The **Matching Score** is the weighted average of the three, as a percentage:

```
Matching Score = ( Σ score × weight ) / ( Σ weight ) × 100
```

Additional criteria can be configured per org (**Ultimate Settings → Account Mapping Extra Conditions**) — for example, requiring the country to match. They are appended to the three above and take part in the same weighted average.

**Selection Criteria**

* Candidates scoring **below 60** are discarded.
* The remaining candidates are ranked by score; the **highest Matching Score** wins.
* Up to **5** recommendations are kept, so a steward can pick a different one.
* If no candidate qualifies, Delpha recommends **creating a new Ultimate Parent** — the recommendation carries the parent's name with no account Id, and the account is created (with its website) when the recommendation is accepted.

***

**Final Confidence Score**

The confidence displayed in Salesforce, and stored in **D Ultimate Recommended Score** (`delpha__DDQ_QualityUltimateRecommendedScore__c`), is:

| Situation                                                | Final score                                          |
| -------------------------------------------------------- | ---------------------------------------------------- |
| A matching account was found in your org                 | the **Matching Score** of the best candidate (0–100) |
| No account qualified — a new Ultimate Parent is proposed | the agent's own **confidence × 100**                 |

> **Recommendation:** Since Ultimate matching relies on the support fields mentioned above, running a Data Quality Assessment before launching an Ultimate Parent analysis is highly recommended for better results.

### Self-Ultimate: when the account is its own parent

When the agent concludes the account has no parent (`is_self_ultimate: true`), Delpha does **not** search your org straight away. It first checks two things:

1. The identified entity has **no Legal Entity Identifier (LEI)** — an entity with a registered LEI is matched normally, like any other.
2. The account's **current** Ultimate Parent and the recommended parent share the **same root domain**.

When both hold, the recommendation **stays on the current Ultimate Parent** (which, for a record with no parent, is the record itself) with a score of **100**.

In every other case — an LEI is present, a website is missing, or the domains differ — the shortcut does not apply and the record goes through the standard org match described above.

### Accuracy and consistency

Beyond the recommendation itself, the analysis feeds the Ultimate Parent quality dimensions shown in the Score Meter:

| Situation                                                                                                                   | Accuracy | Consistency |
| --------------------------------------------------------------------------------------------------------------------------- | -------- | ----------- |
| The current Ultimate Parent **is** the top recommendation                                                                   | `OK`     | ✅           |
| The current Ultimate Parent is not the recommendation, but matches an entity the agent **discarded** (`is_discarded: true`) | `OK`     | ❌           |
| Anything else                                                                                                               | `No`     | ❌           |

The middle row is the important one: your current value is a **real** entity in the ownership chain — it is not wrong, it is simply not the entity Delpha selected as the Ultimate Parent. Accuracy stays `OK`, but consistency is flagged so the difference remains visible and the recommendation is still offered.

### When a record cannot be assessed

| Case                  | What it means                                                                           | Status      | Comments field shows                                             |
| --------------------- | --------------------------------------------------------------------------------------- | ----------- | ---------------------------------------------------------------- |
| **Delpha-side error** | Something failed during Delpha's processing                                             | `Failed`    | The technical error; all dimensions are left `Unknown`/unchecked |
| **Missing input**     | The account has no website (or no name) to analyse                                      | `Not Found` | A message asking for the missing field                           |
| **Input mismatch**    | The name and the website describe two different companies (e.g. *Delpha* + `volvo.com`) | `Not Found` | The agent's explanation of the contradiction                     |

### Example

Let's look at a practical example: the account **Heroku** (`heroku.com`).

**Delpha Reference Ultimate**

```json
"common": {
  "ultimate_parent_legal_name": "Salesforce, Inc.",
  "ultimate_parent_commercial_name": "Salesforce",
  "ultimate_parent_website": "https://www.salesforce.com/",
  "relationship_type": "Wholly Owned",
  "confidence": 1.0,
  "is_self_ultimate": false
}
```

Delpha identifies **Salesforce, Inc.** as the Reference Ultimate Parent, with a confidence of **1.0 (100%)**.

**Customer Org Candidates**

In the customer's Salesforce org, two accounts share the recommended root domain (`salesforce.com`):

| Account           | D Website Domain | D Hierarchy Count |
| ----------------- | ---------------- | ----------------- |
| Salesforce        | salesforce.com   | 12                |
| Salesforce France | salesforce.com   | 1                 |

**Matching Score Calculation** (against the commercial name, *Salesforce*)

**Item 1 — Salesforce**

* Name similarity = **1.0** (identical) → `1.0 × 5`
* Domain match = **1.0** → `1.0 × 3`
* Hierarchy = ln(1+12) / ln(1+12) = **1.0** → `1.0 × 10`
* **Matching Score = (5 + 3 + 10) / 18 × 100 = 100**

**Item 2 — Salesforce France**

* Name similarity = 1 − 7/17 = **0.59** → `0.59 × 5`
* Domain match = **1.0** → `1.0 × 3`
* Hierarchy = ln(1+1) / ln(1+12) = **0.27** → `0.27 × 10`
* **Matching Score = (2.94 + 3 + 2.70) / 18 × 100 = 48**

✅ **Best match:** Salesforce (Matching Score = 100) ❌ **Salesforce France** falls below the 60 threshold and is dropped.

**Final Confidence Score**

A matching account was found, so the final confidence is the Matching Score itself: **100 (100%)**.

This is what ends up stored in **D Ultimate Data**:

```json
"recommendations": [
  {
    "account_id": "001fo000009a6rSAAQ",
    "account_name": "Salesforce",
    "score": 100,
    "status": "Potential"
  }
]
```

Delpha therefore recommends **Salesforce** as the Ultimate Parent of Heroku in the customer's org, with a final confidence score of **100 (100%)**.

{% hint style="warning" %}
[Delpha’s Ultimate Parent model is designed to reflect how companies actually operate and present themselves in the market](/use-cases/ultimate-parent/how-selection-works/ultimate-parent-concepts-brands-vs.-operating-structures.md) — not how they’re legally registered. By focusing on the **brand and operating structure**, Delpha captures real commercial relationships, group affiliations, and brand hierarchies that drive sales, marketing, and territory management.\
This approach ensures more relevant and actionable insights, especially for **franchise and multi-brand organizations**, where legal ownership often differs from day-to-day operational reality.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://help.delpha.io/use-cases/ultimate-parent/how-selection-works/understanding-the-ultimate-parent-analysis.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.