> ## Documentation Index
> Fetch the complete documentation index at: https://docs.retailgrid.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Dynamic Pricing

> Configura reglas de precios y aplícalas de forma determinista en todo un Grid: márgenes mínimos, matching de competidores, redondeo y más.

**Dynamic Pricing** (precios dinámicos) ejecuta tus reglas de precios sobre las filas de un Grid (productos, o combinaciones producto-tienda cuando el Grid está en vista SKU-Store) y escribe los precios resultantes en una nueva columna. Úsalo cuando tengas una lógica de precios conocida (márgenes mínimos, matching de competidores, cambios porcentuales, topes de promoción) y quieras aplicarla de forma consistente en todos los SKUs.

Dynamic Pricing es un solucionador de restricciones determinista: cada regla reduce el rango de precios válidos para una fila, y el precio final es el valor dentro de ese rango más cercano al precio actual de la fila.

> [!NOTE]
>
> Dynamic Pricing se llamaba antes **Rules Based Pricing**. Es el mismo agente y el mismo motor; solo cambió el nombre.

## Cuándo usar Dynamic Pricing

Recurre a Dynamic Pricing cuando puedas describir la lógica de precios que quieres:

* Precios operativos: límites de seguridad, promociones, paridad con un competidor.
* Control de margen: conoces el mínimo o la banda en la que quieres mantenerte.
* Sincronizar precios dentro de una familia o conjunto de productos.
* Aplicar redondeo a terminaciones de precio psicológicas.
* Precios relativos dentro de un grupo (escalado bueno / mejor / óptimo).

Si en cambio quieres que el sistema *sugiera* precios basados en demanda y elasticidad, eso es [Price Optimization](https://docs.retailgrid.io/es/agents/price-optimization.md).

## Abrir Dynamic Pricing

En cualquier Grid:

1. Haz clic en **Agents** en la barra de herramientas superior (o en el botón fijado **Dynamic Pricing** si lo tienes).
2. Selecciona **Dynamic Pricing** en la ventana modal All Agents.
3. Se abre el cuadro de diálogo de configuración con un panel **Config by AI** junto a dos pestañas de configuración: **Rules** (reglas) y **Parameters** (parámetros).

El botón **Run** (ejecutar) se habilita una vez que las entradas están mapeadas y existe al menos una regla.

![Cuadro de diálogo de configuración de Dynamic Pricing: panel Config by AI, lista de reglas, Config Manager](https://mintcdn.com/retailgrid/yby33A9XHZVL6uVo/images/SCR-20260607-txgm.png?fit=max\&auto=format\&n=yby33A9XHZVL6uVo\&q=85\&s=a0cfe8182f889c3cb1d61063148453d7)

## Configurar con IA: describe lo que quieres en lenguaje natural

El panel **Config by AI** se encuentra junto a las pestañas de configuración como un asistente tipo chat, utilizable en cualquier momento. Úsalo cuando sepas el resultado que quieres pero no qué tipo de regla encaja.

* **Prompt**: describe tu objetivo en 1-3 frases. Ejemplo: *"Fija el precio un 5% por encima del costo, pero nunca por debajo del competidor más barato."*
* **AI model**: actualmente Gemini 2.5 Flash.
* **Run AI**: genera reglas y las añade a la pestaña **Rules**.

Las reglas generadas por IA se **añaden** a la lista de reglas existente. Usa **Reset** antes de ejecutar la IA cuando quieras empezar desde cero.

La salida de la IA es un punto de partida. Revisa cada regla generada antes de hacer clic en **Run**: la IA ofrece una suposición estructurada, no una respuesta final. Como Config by AI es independiente de las pestañas, puedes seguir editando reglas manualmente después de que la IA las complete; las dos superficies no se bloquean entre sí.

Si el asistente no puede convertir tu prompt en reglas, te pedirá que lo reformules en lugar de fallar en silencio. Intenta describir el objetivo de forma más concreta (nombra la columna, el umbral, la referencia de competidor).

## Configurar la ejecución

La pestaña **Rules** contiene la lista de reglas. Los mapeos de entrada y el alcance de la ejecución están en **Parameters**. El orden recomendado para la primera configuración es entradas → alcance → reglas.

### Entradas (pestaña Parameters): mapear Price y Cost

Dos columnas del Grid se mapean a los campos reservados del algoritmo:

* **Price**: el precio de venta actual (por defecto `price`).
* **Cost**: el costo por unidad (por defecto `unit_cost`).

Ambos son obligatorios. Las reglas Margin Rule necesitan Cost; todos los tipos de regla usan Price como ancla para la selección "más cercano al precio actual".

Si tus datos usan nombres de columna diferentes, elígelos en los menús desplegables. Los mapeos no son destructivos; tus columnas originales no se renombran en el Grid.

### Alcance (pestaña Parameters): Full Dataset o Sample 10 Rows

El alcance controla sobre qué filas se ejecutan las reglas:

* **Full Dataset**: todas las filas del libro de trabajo actual.
* **Sample 10 Rows**: muestreo del lado del servidor sobre diez filas, pensado para validar una configuración de reglas antes de comprometerse con una ejecución completa. Devuelve resultados rápidamente y expone errores de configuración (referencias faltantes, reglas contradictorias, condiciones inválidas) sin procesar todo el Grid.

Las ejecuciones de muestra también se registran en la sección Runs y escriben los resultados en el Grid para las filas muestreadas.

### Reglas: el corazón de la configuración

La pestaña **Rules** es donde listas las reglas a aplicar. Haz clic en **Add Rule** para abrir el selector de tipo de regla, configura cada regla y guárdala. La lista muestra todas las reglas con sus prioridades; la insignia en el encabezado de la pestaña es el número de reglas.

## Cómo se evalúan las reglas

Para cada fila dentro del alcance, de forma independiente:

1. Las reglas se ordenan por **Priority** (1 = la más alta, máximo 50).
2. El motor recorre las reglas de arriba abajo. Cada regla reduce el corredor de precios factible de la fila.
3. Si el corredor de una regla no se cruza con el corredor actual, la regla se marca como **violada** (ver Fallback Behavior).
4. Después de ejecutar todas las reglas, el precio final es el valor del corredor resultante más cercano al **precio actual** de la fila.
5. **Price Rounding** se evalúa siempre al final, independientemente de su posición de prioridad; su número de prioridad controla qué otras reglas puede violar.

El modelo de ejecución está documentado internamente como **Interval Selection Algorithm (ISA)**. El resultado es reproducible: las mismas entradas y reglas siempre dan la misma salida.

## Ejecución a nivel de tienda

Cuando tu Grid está en **vista SKU-Store** (una fila por combinación producto-tienda), Dynamic Pricing se ejecuta a nivel SKU-Store:

* El motor emite **un precio recomendado por combinación producto-tienda**, usando el precio, el costo y el conjunto de competidores propios de cada tienda.
* Las **Conditions** (condiciones) pueden apuntar a atributos de tienda (país, canal, zona de precios) para que una regla se aplique solo a las tiendas coincidentes. Un margen mínimo para un país, paridad con competidores para un canal.
* Las reglas sin condiciones de tienda se aplican a todas las tiendas, por lo que las configuraciones de reglas a nivel de producto existentes siguen funcionando sin modificaciones.

Las tiendas y sus atributos se definen en [Gestión de tiendas](https://docs.retailgrid.io/es/stores/manage-stores.md); los dos modos de granularidad del Grid se describen en [Vistas de Grid por producto y SKU-Store](https://docs.retailgrid.io/es/grids/sku-store-view.md).

## Campos universales de las reglas

Cada regla tiene la misma estructura, independientemente de su tipo:

* **Name**: texto libre. Hazlo legible en las trazas (p. ej. *"Margen mín. 25%"*).
* **Priority** (1-50): número más bajo = prioridad más alta. El motor evalúa primero las reglas de mayor prioridad.
* **Conditions** (desplegable): filtro que limita a qué filas se aplica la regla.
* **Fallback Behavior** (desplegable): qué hacer cuando la regla entra en conflicto con el corredor actual o a la fila le faltan datos requeridos.
* Parámetros específicos de la regla (ver cada tipo de regla más abajo).

Máximo 50 reglas por ejecución. El orden de la lista de reglas en la pestaña **Rules** es puramente visual; solo **Priority** controla el orden de evaluación.

![Selector Select Rule Type](https://mintcdn.com/retailgrid/yby33A9XHZVL6uVo/images/agents/rbp-rule-type-picker.png?fit=max\&auto=format\&n=yby33A9XHZVL6uVo\&q=85\&s=4d946a1b419c3705ac49d81ae3ef52bc)

## Los 8 tipos de regla

> [!TIP]
>
> ¿Es tu primera vez con los tipos de regla? La [Guía de reglas de precios](https://docs.retailgrid.io/es/agents/pricing-rules-guide.md) recorre los 8 desde un ángulo de negocio: cuándo usar cada regla, por qué importa y un ejemplo minorista resuelto para cada una. Las secciones de abajo son la referencia técnica.

### Fixed Price

Fija las filas coincidentes a su precio actual. El precio final es igual al precio de entrada; ninguna regla posterior puede moverlo.

* **Parámetros:** ninguno.
* **Corredor:** `[current_price, current_price]`, un único punto.
* **Úsala para:** precios de promoción, SKUs regulados, precios aprobados manualmente.
* **Atención:** cualquier regla posterior cuyo corredor no contenga el precio actual se marcará como violada para esas filas.

### Price Change Limit

Limita cuánto pueden moverse los precios respecto al precio actual. Úsala como corredor exterior (Maximum) o como zona muerta que prohíbe micro-cambios (Minimum).

* **Limit Type:** Maximum (corredor exterior) o Minimum (zona muerta).
* **Increase:** Percent o Absolute, con un valor.
* **Decrease:** Percent o Absolute, con un valor.
* **Corredor Maximum:** `[base - decrease, base + increase]`. Los precios fuera se llevan al límite más cercano.
* **Minimum (zona muerta):** prohíbe cambios menores que el umbral. Se codifica internamente como un corredor invertido; es el único tipo de regla que produce legítimamente `lo > hi`.

### Price Change

Mueve los precios en un porcentaje, un importe absoluto o según una columna de referencia. Siempre produce un único precio objetivo.

* **Value Type:** Percent, Absolute o Column.
* **Value:** el porcentaje / número absoluto, o la columna de referencia.
* **Fórmulas:**
  ```text theme={null}
  percent:   target = current_price * (1 + value / 100)
  absolute:  target = current_price + value
  column:    target = current_price + reference_column
  ```
* **Nota:** siempre se calcula respecto al **precio base (precio actual)**, no respecto al candidato en curso en la prioridad de esta regla. Así, un Price Change de +5% aplicado después de una Margin Rule sigue añadiendo un 5% al precio original, no al precio derivado del margen.

### Price Match

Alinea el precio con una columna de referencia (normalmente un precio de competidor), ya sea exactamente o dentro de un corredor porcentual. Un **ajuste de referencia** opcional puede transformar la referencia primero, para que puedas posicionarte frente a un valor *derivado* de la columna en lugar de la columna sin procesar.

* **Reference Column:** columna numérica.
* **Reference adjustment** *(opcional)*: transforma la referencia **antes** de emparejar: **multiply** (multiplicar) por un factor, o sumar/restar un **percent** (porcentaje) o un importe **absolute** (absoluto) fijo. Déjalo desactivado para usar la referencia tal cual. Así expresas objetivos como "80% del precio regular" dentro de la regla, en lugar de crear una columna de fórmula aparte.
* **Operator:** `Equals` (un único punto) o `Between` (corredor).
* **Valores From / To** (cuando es `Between`): límites porcentuales inferior / superior.
* **Corredor:**
  ```text theme={null}
  equals:   [ref, ref]
  between:  [ref - from%, ref + to%]
  ```
  Cuando hay un ajuste de referencia configurado, `ref` arriba es el valor **ajustado** (por ejemplo `regular_price * 0.8`). Tanto el ajuste como la referencia emparejada aparecen en la explicación del panel Price Analysis, para que puedas ver por qué se propuso un precio.
* **Cuando se viola:** el motor ajusta el precio al límite más cercano al corredor deseado por esta regla ("estirar hacia lo que la regla quería").

### Sync Prices

Obliga a todas las filas de un grupo a compartir un mismo precio final idéntico. Es una regla dinámica: cruza los corredores de todos los miembros del grupo y resuelve un único objetivo de grupo en el momento de su prioridad.

* **Group Column:** columna de texto o categórica (p. ej. `product_family`).
* **Cascada de resolución** (en orden):
  1. **Moda**: si algún precio actual es compartido por 2 o más miembros, se usa ese.
  2. **Ponderado por ventas**: si todos los precios actuales son únicos y existe una columna `sales_units`, se usa el precio del miembro con más ventas.
  3. **Mediana** de los precios actuales del grupo.
* **Tres casos después de cruzar los corredores de los miembros:**
  * **Intersección completa:** todos los miembros del grupo reciben el mismo precio.
  * **Intersección parcial:** el motor descarta los SKUs atípicos (menor contribución al solapamiento) uno a uno hasta que el resto coincide. Los atípicos se marcan como Sync violada y se les asigna precio individualmente.
  * **Sin intersección:** todo el grupo se marca como Sync violada y cada SKU recibe precio individualmente.
* **Atención al alcance:** Sync solo agrupa las filas que cumplen sus condiciones. Las filas fuera de las condiciones no se ven afectadas en absoluto; la regla no aparece en sus listas de aplicadas / violadas.
* **Fallback especial:** cuando Sync se viola, el motor no "estira hacia el corredor de Sync" (Sync no tiene corredor numérico). En su lugar, cada SKU afectado recibe el precio más cercano a su propio precio actual.

### Margin Rule

Restringe el precio a un objetivo de margen o markup derivado del Cost. Es estática: el corredor se calcula antes de que el motor se ejecute.

* **Margin Type:** Margin o Markup.
* **Constraint:** Exact (un único punto) o Between (corredor).
* **Value Source:** Percent, Absolute o Column.
* **Value** (o **From / To** cuando Constraint es Between).
* **Fórmulas (con `T = value / 100` para porcentaje):**
  ```text theme={null}
  Margin, percent / column:  boundary = cost / (1 - T)
  Markup, percent / column:  boundary = cost * (1 + T)
  Absolute (margin/markup):  boundary = cost + T
  ```
* **Ejemplos:** *"Margen exactamente 25%"* -> `[cost / 0.75, cost / 0.75]`. *"Markup entre 30% y 50%"* -> `[cost * 1.30, cost * 1.50]`.
* **Validación:** `Value Source = Column` solo es válido con `Constraint = Exact`. Combinar Column con Between devuelve un error.

### Price Rounding

Obliga a que los precios finales terminen en terminaciones psicológicamente permitidas (p. ej. `*.99`, `*.95`, `*.00`).

* **Price Scope:** todos los precios, o un filtro por rango de precios (Equals / Between).
* **Pattern (terminaciones permitidas):** patrones separados por comas, p. ej. `*.99, *.95`.
* **Excluded endings:** patrones a evitar, p. ej. `*.77`.
* **Rounding Direction:** Up (el menor valor válido por encima del candidato), Down (el mayor valor válido por debajo del candidato) o Closest (el valor válido más cercano que aún cae dentro del rango factible).
* **Siempre al final:** el redondeo se ejecuta después de todas las demás reglas, independientemente de su posición en la lista de prioridades. Su número de prioridad determina qué otras reglas puede violar (solo las de menor prioridad).
* **Atención:** si no existe ninguna terminación válida dentro del rango factible, la regla se viola y el precio se queda sin redondear; no se anula.

### Price Relations

Mantiene una estructura de precios relativa dentro de un grupo. Ejemplo: mantener el SKU Profit Driver un 6% por debajo del Traffic Driver.

* **Group Column:** texto o categórica.
* **Price Type:** Price o Unit Price.
* **Relationship Type:** *One by one* (cada ítem N tiene precio relativo al ítem N-1) o *Same gap* (la misma distancia desde el ancla para cada miembro).
* **Gap Value Type:** Percent o Absolute.
* **Gap Value.**
* **Anchor Logic:** Highest priced (ancla = miembro del grupo con el precio actual más alto) o Explicit item.
* **Fórmulas:**
  ```text theme={null}
  percent:   price(N) = price(N-1) * (1 - gap / 100)
  absolute:  price(N) = price(N-1) - gap
  ```
* **Cascada:** cada SKU de la cadena recibe un corredor de un único punto. Si el ancla se mueve por un conflicto de mayor prioridad, toda la cadena se recalcula.
* **Solo se combina con el redondeo:** como Price Relations deja corredores de un único punto, solo Price Rounding puede combinarse de forma significativa después de ella. Otras reglas de menor prioridad o bien cruzan el punto exacto (sin conflicto) o bien se violan.
* **Explicación de la escalera completa:** cuando una regla Price Relations fijó el precio, el panel Price Analysis muestra la **escalera completa** del SKU (cada peldaño de la cadena y dónde se sitúa este SKU entre ellos), no solo el vecino inmediato del que partió, de modo que una inversión o un peldaño bloqueado por otra regla queda visible en contexto.

## Conditions: filtrar a qué filas se aplica una regla

Abre la sección **Conditions** en cualquier regla para limitarla a un subconjunto de filas. Las reglas sin condiciones se aplican a todas las filas dentro del alcance.

* Cada condición es un triplete **columna + operador + valor**.
* Las condiciones se combinan con **AND** (no hay OR).
* Operadores admitidos: `=`, `!=`, `>`, `<`, `>=`, `<=`, `IN`, `NOT IN`, `IS TRUE`, `IS FALSE`.

En la vista SKU-Store, las columnas de atributos de tienda (país, canal, zona de precios) están disponibles como columnas de condición; así es como limitas una regla a un subconjunto de tiendas.

Una fila coincide con una regla solo si todas las condiciones se evalúan como verdaderas.

## Fallback Behavior: qué pasa cuando una regla no puede aplicarse limpiamente

Abre la sección **Fallback Behavior** en cualquier regla para controlar el manejo de conflictos y datos faltantes.

**Comportamiento ante conflicto**

* **Follow priority** (por defecto): la regla se marca como violada, el corredor se mantiene en el último rango válido y el motor elige el límite más cercano a lo que esta regla quería ("estirar hacia la regla violada").
* **Return error**: el cálculo se detiene para esta fila. La fila recibe `rbp_status = error` y el nombre de la regla causante. Recomendado para reglas críticas de cumplimiento.

**Comportamiento ante valor faltante**

* **Ignore** (por defecto): la regla se omite para las filas a las que les faltan datos requeridos; la fila continúa evaluando las demás reglas.
* **Return error**: la ejecución falla cuando falta el valor de una columna requerida.

Sync Prices, Price Rounding y Price Relations tienen fallbacks específicos de regla (descritos en sus secciones de arriba).

## Guardar y cargar configuraciones

Haz clic en **Config Manager** en la parte superior derecha para guardar la configuración actual como una configuración con nombre o cargar una guardada previamente.

Una configuración captura la configuración completa: alcance, entradas, historial de prompts de IA y toda la lista de reglas. Puedes cargar una configuración en el mismo Grid o en uno diferente.

Es la herramienta adecuada para ejecuciones mensuales recurrentes y para compartir configuraciones entre compañeros de equipo.

## Validar con Sample 10 Rows y luego ejecutar

El flujo recomendado:

1. Configura las reglas.
2. Establece el alcance en **Sample 10 Rows** y haz clic en **Run**.
3. Inspecciona la columna **Rules Based Price** en las filas muestreadas; abre el panel Price Analysis en algunas para confirmar que las reglas se activaron como esperabas.
4. Vuelve a poner el alcance en **Full Dataset** y haz clic en **Run**.

Las ejecuciones de muestra son rápidas y sacan a la luz errores de configuración (referencias faltantes, Conditions contradictorias, fallos de validación) antes de que esperes una ejecución completa.

## Leer el resultado

Después de una ejecución, el Grid muestra una nueva columna **Rules Based Price** con el precio calculado por fila. Haz clic en cualquier celda de esa columna para abrir el panel derecho **Price Analysis**, que explica cómo se obtuvo el precio.

![Panel Price Analysis](https://mintcdn.com/retailgrid/yby33A9XHZVL6uVo/images/agents/rbp-insights-panel.png?fit=max\&auto=format\&n=yby33A9XHZVL6uVo\&q=85\&s=c7fcfcd57331cb8cd81535af3bf8077c)

El encabezado del panel muestra el producto (imagen, ID, nombre) para el que se calculó el precio, más un subtítulo `Rule-based pricing trace`.

El bloque de resumen tiene dos columnas:

**Columna izquierda: Final Price**

* **Final Price**: el Rules Based Price calculado, grande y destacado.
* **% delta vs Start Price**: cuánto se movió el precio calculado respecto al precio inicial de la fila (positivo = subida, negativo = bajada).

**Columna derecha: entradas y reglas aplicadas**

* **Start Price**: el precio inicial de la fila (la entrada).
* **Cost**: el costo unitario de la fila (la entrada).
* **Feasible Range**: el corredor de precios que sobrevivió después de que cada regla aplicada lo redujera. El Final Price es el punto dentro de este rango más cercano al Start Price.
* **Applied Rules**: una tarjeta compacta por cada regla que se activó, mostrando el resumen y el estado de la regla y su **prioridad** (para que puedas leer el orden en que se aplicaron las reglas), con un **gráfico del corredor de precios** expandible en cada tarjeta que muestra la restricción impuesta por la regla y el precio que produjo. Junto a ellas hay un contador de reglas violadas. Cuando el precio proviene de una recomendación de [Price Optimization](https://docs.retailgrid.io/es/agents/price-optimization.md), el panel también muestra la **elasticidad** utilizada y cómo moldeó el precio final. Las tarjetas se mantienen legibles con tres o más reglas aplicadas, sin truncamiento.

**Sección de impacto (tres tarjetas de métricas debajo del resumen)**

* **New Unit Margin %**: margen al Rules Based Price calculado, con el margen inicial mostrado debajo como `vs Start: X%`.
* **Unit Margin % pp change**: cambio en puntos porcentuales respecto al margen inicial.
* **Unit Margin % Change (%)**: cambio relativo del margen (cambio en pp / margen inicial).

Todos los valores se redondean a 2 decimales.

**Visualización del corredor**

Una barra horizontal en la parte inferior muestra el Feasible Range, con marcadores para Start Price (entrada) y Final Price (calculado). Es útil para ver de un vistazo con qué agresividad las reglas restringieron el precio.

Pulsa **ESC** o haz clic en la X del encabezado del panel para cerrarlo.

## Columnas de salida

El agente escribe estas columnas en el Grid:

| Columna | Clave del motor | Qué significa |
| :- | :- | :- |
| **Rules Based Price** | `rule_based_price` | El precio final calculado por fila. |
| **rbp\_status** | `rbp_status` | `success` o `error`. |
| **rbp\_error\_message** | `rbp_error_message` | Detalle del error cuando el estado es `error`. |
| **rbp\_trigger\_rule** | `rbp_trigger_rule` | Nombre de la regla que produjo el precio final. |
| **rbp\_applied\_rules** | `rbp_applied_rules` | IDs de reglas separados por comas que se activaron correctamente. |
| **rbp\_violated\_rules** | `rbp_violated_rules` | IDs de reglas separados por comas que fueron violadas. |
| **rbp\_skipped\_rules** | `rbp_skipped_rules` | IDs de reglas separados por comas omitidas por datos faltantes o condiciones no coincidentes. |
| **rbp\_delta\_abs** | `rbp_delta_abs` | `Rules Based Price - current_price`. |
| **rbp\_delta\_pct** | `rbp_delta_pct` | `(Rules Based Price - current_price) / current_price`. |
| **New Unit Margin %** | `rbp_new_margin` | `(Rules Based Price - cost) / Rules Based Price`. |
| **RBP Price Change Trace** | `rbp_price_range_trace` | Traza JSON del corredor por fila, usada por el panel Price Analysis. |

Oculta lo que no necesites desde el panel Columns. Fija **Rules Based Price** a la derecha para revisarlo de un vistazo.

## Errores comunes

* **Falta `cost`**: las Margin Rules no pueden ejecutarse sin él. Mapea una columna Cost en la pestaña **Parameters** o elimina las reglas basadas en margen.
* **Monedas distintas**: si los productos y los competidores usan monedas diferentes, configura el tipo de cambio en la [configuración de la cuenta](https://docs.retailgrid.io/es/settings/currency.md) antes de ejecutar reglas basadas en competidores.
* **Conditions demasiado estrechas**: si ninguna fila coincide, la regla se omite en silencio. Vigila el número de filas en las ejecuciones de muestra.
* **Fixed Price seguida de otras reglas**: Fixed Price es un corredor de un único punto; casi cualquier regla posterior se violará para esas filas. Es el comportamiento esperado.
* **Price Change relativo a la base**: Price Change siempre parte del precio actual, no de lo que produjeron las reglas anteriores. Si necesitas deltas en cascada, usa Price Relations en su lugar.
* **El redondeo nunca alcanza una terminación válida**: si el corredor resultante es más estrecho que el espaciado de tu Pattern, el redondeo se viola y el precio se queda sin redondear.

## Relacionado

* [Guía de reglas de precios](https://docs.retailgrid.io/es/agents/pricing-rules-guide.md): recorrido para usuarios de negocio por los 8 tipos de regla con ejemplos resueltos
* [Descripción general de agentes](https://docs.retailgrid.io/es/agents/overview.md)
* [Price Optimization](https://docs.retailgrid.io/es/agents/price-optimization.md)
* [Pricing Strategy](https://docs.retailgrid.io/es/agents/pricing-strategy.md)
* [Gestionar tiendas](https://docs.retailgrid.io/es/stores/manage-stores.md)
* [Vistas de Grid por producto y SKU-Store](https://docs.retailgrid.io/es/grids/sku-store-view.md)
* [Añadir columnas](https://docs.retailgrid.io/es/grids/manage-columns.md)
* [Glosario de métricas](https://docs.retailgrid.io/es/reference/metrics.md)
* [Moneda](https://docs.retailgrid.io/es/settings/currency.md)
* [Runs](https://docs.retailgrid.io/es/runs/overview.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.