> For the complete documentation index, see [llms.txt](https://cortex-docs.paloaltonetworks.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://cortex-docs.paloaltonetworks.com/cortex-xsiam/configure-cortex-xsiam/data-management/data-model-rules/accelerated-cortex-data-modeling.md).

# Accelerated Cortex Data Modeling

Execute Accelerated Cortex Data Modeling in Cortex XSIAM using data model rules.

Cortex XSIAM supports modeling acceleration for datasets. This feature is designed to deliver accelerated data modeling for queries with minimal overhead. By executing existing Data Model rules at ingestion time (on-write) instead of query time (on-read), Cortex XSIAM eliminates the performance bottleneck traditionally associated with large-scale XDM queries (datamodel queries).

Modeling acceleration is enabled in the dataset level. If a dataset has modeling acceleration enabled, it is called an “accelerated dataset”. This means that all data model rules that apply to this dataset can be executed in an accelerated modeling mode for a datamodel query, provided all requirements are met (see [Requirements for query modeling acceleration](#requirements-for-query-modeling-acceleration) below).

In this context, regular modeling mode refers to the standard modeling behavior (on-read) where data model rules are computed at query time. If a query or configuration does not meet the requirements for query modeling acceleration (see below), Cortex XSIAM automatically runs the query modeling in regular mode to ensure data model rules are always applied (if they exist).

{% hint style="info" %}

#### Licenses

* **License consumption**: Modeled data written on-write counts toward your **Analytics GB** license consumption.
* **Visibility**: In the **Data Ingestion** dashboard, accelerated (XDM) data volume is counted separately and presented distinctly from raw data volume.
  {% endhint %}

{% hint style="warning" %}

#### Prerequisite

* **Permissions**: Requires **View/Edit** RBAC permissions for **Data Management** (under **Configurations** → **Data Management**).
* **Audit logging**: All enable and disable operations are recorded in the **Management Audit Logs** page under the **Datasets** type. For bulk operations, each failed dataset action includes its own specific failure reason.
* **Availability**: Modeling acceleration is forward-looking and applies exclusively to data ingested after acceleration was enabled for the specific dataset.
  {% endhint %}

### Goals and Guidelines

The modeling acceleration initiative is governed by the following core principles:

* **High-speed queries**: The primary objective is to provide significant performance acceleration for XDM queries (datamodel queries).
* **Self-service & opt-in**: Administrators can enable or disable acceleration per dataset or in bulk directly from the **Dataset Management** page.
* **No migration**: Accelerated modeling works on top of your existing datasets, Data Model rules (default or user-defined), and Cortex Query Language (XQL) queries. No data or content change is required.
* **Internal acceleration mechanism**: The dataset schema remains unchanged even when modeling acceleration is enabled. All acceleration-supporting mechanisms are internal and do not enforce a schema change or require adjustments to your existing dataset definitions.
* **Standard query syntax**: XDM queries continue to use the standard datamodel keyword.
* **Backward compatibility**: By default, datamodel queries execute in regular (on-read) mode so existing dashboards, widgets, scheduled reports, and correlation rules continue to function unchanged.

### Configuring modeling acceleration

You manage modeling acceleration directly from the **Dataset Management** page (**Configurations** → **Data Management** → **Dataset Management**).

#### Enable or disable acceleration for datasets

You can configure acceleration for individual datasets or across multiple datasets simultaneously:

* **Single dataset**: Right-click the dataset in the table and select **Enable Modeling Acceleration** or **Disable Modeling Acceleration**.
* **Bulk action**: Multi-select datasets using the table checkboxes.
  * **Enable Modeling Acceleration** is available if at least one selected dataset is eligible and not yet accelerated.
  * **Disable Modeling Acceleration** is available if at least one selected dataset is currently accelerated.
  * Non-applicable or unsupported datasets are automatically skipped and listed in the action summary.
* **Confirmation**: A confirmation dialog appears detailing the selected datasets, the expected effect on Analytics GB license consumption, and a link to prerequisites.

#### Configure default behavior for new datasets

To specify how newly added datasets should be handled:

1. Select **Configurations** → **Data Management** → **Dataset Management**, and click **Acceleration Settings**.
2. Select the default setting for newly created datasets:
   * **Disabled** (default): New datasets use regular on-read modeling.
   * **Enabled**: New datasets automatically enable modeling acceleration upon creation.

### Scope

#### Query sources

Modeling acceleration is supported for queries from any source, such as XQL Search, Public API (PAPI), Dashboards, and other sources. One exception to this is Correlation Rules, which are currently out of scope and unsupported. This means that Correlation rule queries will execute in regular (on-read) mode, even if they are run on accelerated datasets.

#### Supported datasets

* **Raw datasets**: All standard raw datasets are eligible.
* **xdr\_data dataset**: Supports selective field acceleration for approximately 65 selected XDM fields. An info icon in the **Modeling Acceleration** column provides context on this selective behavior, noting that acceleration is balanced against performance and cost. Queries must be limited strictly to these supported fields to achieve acceleration. For more information on the specific fields supported for acceleration in this dataset, see [xdr\_data supported fields for acceleration](#xdr_data-supported-fields-for-acceleration).

#### Out-of-Scope

* **Unsupported datasets**: Snapshot, User, and Lookup Datasets.
* **Egress data**: No modeled data will be forwarded within the event forwarding data.
* **Data Lake tier**: No modeling in the Data Lake tier.
* **Hybrid time ranges**: Queries spanning both accelerated and non-accelerated timeframes for an accelerated dataset are not supported and will fallback to regular modeling mode (see Requirements for query modeling acceleration below).
* **Cold storage**: Out of scope. Queries using cold storage will run in `regular` mode.

### Query syntax and control

By default, `datamodel` queries execute in `regular` (on-read) mode, preserving existing query execution across your workflows.

To run a query in accelerated mode, you must explicitly add the `config modeling_mode` statement to your XQL query:

`config modeling_mode = <accelerated | regular>`

* `accelerated`: Executes the query in accelerated mode using the on-write modeled copy if all acceleration requirements are met.
* `regular`: Executes the query in standard on-read modeling mode, even if an accelerated copy exists. This is the default system behavior if no `config modeling_mode` statement is present in the query.

{% hint style="info" %}

#### Note

The `config modeling_mode` statement can be defined at the query root and applies recursively to inner subqueries by default. If a subquery requires a different mode, a granular inner config statement will override the outer settings.
{% endhint %}

### Requirements for query modeling acceleration

A query runs in accelerated modeling mode only if all requirements are met. If any of these requirements are not met, the query will automatically fallback to regular (on-read) mode:

1. **Acceleration is currently enabled**: Modeling acceleration must be enabled for the queried datasets at the time of query execution.
2. **Entire timeframe is covered**: Modeling acceleration was enabled for the queried datasets during the entire query requested timeframe.
3. **Modeling mode statement**: The query must explicitly include the `config modeling_mode = accelerated` statement.
4. **Supported query source**: The query originates from a supported source, such as XQL Search, Public API (PAPI), or Dashboards.

{% hint style="info" %}

#### Note

Correlation Rules are currently not a supported source.
{% endhint %}

5. No unsupported fields: The query must not reference unmapped auto-enriched fields or unsupported `xdr_data` fields.

{% hint style="info" %}

#### Note

If a query targets the `xdr_data` dataset and includes even one field outside the supported list, the query will execute in `regular` (on-read) mode for that dataset.
{% endhint %}

### Acceleration scenarios and results

The following table describes how Cortex XSIAM handles various query scenarios when `config modeling_mode = accelerated` is used.

| Query Scenario                                                            | Execution Result      | Behavioral Rule                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ------------------------------------------------------------------------- | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Table Mix** (Accelerated + non-accelerated datasets)                    | Partially Accelerated | Accelerated datasets run in accelerated mode, while the rest run in `regular` (on-read) mode.                                                                                                                                                                                                                                                                                                                                                     |
| **Field Mix** (Raw Fields + XDM Fields)                                   | Accelerated           | You can reference both raw dataset fields and XDM fields simultaneously in an accelerated query.                                                                                                                                                                                                                                                                                                                                                  |
| **xdr\_data supported fields only**                                       | Accelerated           | Queries targeting `xdr_data` using strictly the supported fields run in accelerated mode.                                                                                                                                                                                                                                                                                                                                                         |
| **xdr\_data Field Mix** (Supported + Unsupported fields)                  | Regular (on-read)     | If even one unsupported field is included, the query falls back to `regular` (on-read) modeling.                                                                                                                                                                                                                                                                                                                                                  |
| **Hybrid time ranges** (timeframe starts before acceleration was enabled) | Regular (on-read)     | <p>A query is only accelerated if the dataset was continuously accelerated for the <em>entire</em> requested timeframe, and is currently configured for acceleration.<br><strong>Clarification</strong>: Once acceleration is turned off for a dataset, you can no longer query it in <code>accelerated</code> mode for any timeframe, even for historical data that was originally ingested while acceleration was enabled for this dataset.</p> |
| **Rule Changes** (rule updated after data was ingested)                   | Accelerated           | Accelerated results reflect the rules active at the time of ingestion. Use `regular` mode to evaluate new rules against old data.                                                                                                                                                                                                                                                                                                                 |
| **Disabled datasets** (acceleration turned off after ingestion)           | Regular (on-read)     | Once acceleration is disabled, historical data can no longer be queried in `accelerated` mode.                                                                                                                                                                                                                                                                                                                                                    |

### Monitoring acceleration

* **Dataset Management table columns**:
  * **Modeling Acceleration**: Indicates if acceleration is **Enabled**, **Disabled**, or **N/A** (meaning the dataset is not applicable for acceleration).
  * **Acceleration Enabled On**: Displays the timestamp of when acceleration was last enabled for the dataset. Accelerated queries are only available for data ingested from this point forward. Note that if acceleration is disabled and later re-enabled, this column reflects the most recent activation time, which represents the point from which accelerated modeling becomes available for the dataset. For more information, see [Requirements for query modeling acceleration](#requirements-for-query-modeling-acceleration).
* **Query Center**: The optional **Modeling Mode** column indicates if a query was **Accelerated**, **Partially Accelerated**, or **Regular**, and provides the specific fallback reason.
  * **Modeling Mode**: An optional column (hidden by default) indicates the execution mode of the query. Possible values include:
    * **Accelerated**: The query executed entirely against the pre-modeled copy.
    * **Partially Accelerated**: Portions of the query ran accelerated (for example, accelerated for some tables, accelerated for some fields, or mixed query configuration).
    * **Regular**: The query ran using standard on-read modeling (for example, acceleration not enabled/supported, unavailable for timeframe, unsupported fields, or manual query configuration).
    * **N/A**: No data modeling was applied.
  * **Modeling Reasoning**: Provides the specific reason if a query falls back to `regular` mode or runs in partial acceleration, such as "Acceleration unavailable for the requested timeframe" or "Query includes fields not supported for acceleration."
* **Pre-query banner**: A warning banner appears in XQL Search before running a query if it targets an accelerated dataset but cannot achieve full acceleration. This banner indicates that the query will execute in `regular` (not-accelerated) mode or in `partially accelerated`, even though the queried datasets have acceleration enabled. The banner also shows the reason.

### Enhanced default field return behavior

* **Query without a fields stage**: Returns `_time`, all mapped fields, and any query-referenced fields (even if unmapped), instead of just the \~30 core XDM fields.
* **Unmapped fields**: Referencing an unmapped field does not cause the query to fail; it returns an empty value and allows the query to complete successfully.
* **Consistency**: This behavior is identical across both `regular` (on-read) and `accelerated` (on-write) modeling modes.
* **Legacy behavior**: To revert to the legacy behavior of returning only core XDM fields, contact your[ Customer Support Team](https://support.paloaltonetworks.com/Support/Index).

### xdr\_data supported fields for acceleration

The following XDM fields within the `xdr_data` dataset are supported for modeling acceleration. To achieve accelerated performance, queries against this dataset must be limited strictly to these fields.

* xdm.alert.severity
* xdm.auth.ntlm.dns\_hostname
* xdm.auth.ntlm.hostname
* xdm.auth.ntlm.user\_name
* xdm.event.id
* xdm.event.operation
* xdm.event.operation\_sub\_type
* xdm.event.outcome
* xdm.event.outcome\_reason
* xdm.event.type
* xdm.intermediate.asn.as\_name
* xdm.intermediate.asn.as\_number
* xdm.intermediate.asn.is\_proxy
* xdm.intermediate.host.hostname
* xdm.intermediate.host.ipv4\_addresses
* xdm.intermediate.host.ipv6\_addresses
* xdm.intermediate.ipv4
* xdm.intermediate.ipv6
* xdm.intermediate.is\_internal\_ip
* xdm.intermediate.location.city
* xdm.intermediate.location.continent
* xdm.intermediate.location.country
* xdm.intermediate.location.latitude
* xdm.intermediate.location.longitude
* xdm.intermediate.location.region
* xdm.intermediate.location.timezone
* xdm.network.application\_protocol
* xdm.network.dns.dns\_question.name
* xdm.network.dns.dns\_resource\_record.name
* xdm.network.http.domain
* xdm.network.ip\_protocol
* xdm.observer.product
* xdm.observer.vendor
* xdm.source.agent.identifier
* xdm.source.asn.as\_name
* xdm.source.asn.as\_number
* xdm.source.asn.is\_proxy
* xdm.source.host.device\_id
* xdm.source.host.fqdn
* xdm.source.host.hostname
* xdm.source.host.ipv4\_addresses
* xdm.source.host.ipv6\_addresses
* xdm.source.host.os\_family
* xdm.source.ipv4
* xdm.source.ipv6
* xdm.source.is\_internal\_ip
* xdm.source.location.city
* xdm.source.location.continent
* xdm.source.location.country
* xdm.source.location.region
* xdm.source.location.timezone
* xdm.source.location.latitude
* xdm.source.location.longitude
* xdm.source.port
* xdm.source.process.command\_line
* xdm.source.process.executable.directory
* xdm.source.process.executable.extension
* xdm.source.process.executable.file\_type
* xdm.source.process.executable.filename
* xdm.source.process.executable.path
* xdm.source.process.executable.sha256
* xdm.source.process.executable.signer
* xdm.source.process.name
* xdm.source.user.identifier
* xdm.source.user.identity\_type
* xdm.source.user.netbios\_domain
* xdm.source.user.sam\_account\_name
* xdm.source.user.scope
* xdm.source.user.upn
* xdm.source.user.username
* xdm.target.agent.identifier
* xdm.target.asn.as\_name
* xdm.target.asn.as\_number
* xdm.target.asn.is\_proxy
* xdm.target.file.extension
* xdm.target.file.file\_type
* xdm.target.file.filename
* xdm.target.file.path
* xdm.target.file.sha256
* xdm.target.file\_before.file\_type
* xdm.target.host.hostname
* xdm.target.host.ipv4\_addresses
* xdm.target.host.ipv6\_addresses
* xdm.target.ipv4
* xdm.target.ipv6
* xdm.target.is\_internal\_ip
* xdm.target.location.city
* xdm.target.location.continent
* xdm.target.location.country
* xdm.target.location.region
* xdm.target.location.timezone
* xdm.target.location.latitude
* xdm.target.location.longitude
* xdm.target.module.directory
* xdm.target.module.extension
* xdm.target.module.filename
* xdm.target.port
* xdm.target.process.command\_line
* xdm.target.process.executable.directory
* xdm.target.process.executable.extension
* xdm.target.process.executable.file\_type
* xdm.target.process.executable.filename
* xdm.target.process.executable.path
* xdm.target.process.executable.sha256
* xdm.target.process.name
* xdm.target.user.identifier
* xdm.target.user.identity\_type
* xdm.target.user.netbios\_domain
* xdm.target.user.sam\_account\_name
* xdm.target.user.scope
* xdm.target.user.upn
* xdm.target.user.username


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://cortex-docs.paloaltonetworks.com/cortex-xsiam/configure-cortex-xsiam/data-management/data-model-rules/accelerated-cortex-data-modeling.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
