# Ejecute una A/B prueba con enrutamiento basado en objetivos
Utilice el patrón de enrutamiento basado en el destino cuando el cambio que esté probando implique cambios de código, una actualización del marco o la implementación de un agente completamente diferente. Target-based el enrutamiento enruta el tráfico entre varias versiones del mismo AgentCore entorno de ejecución (denominados puntos finales) o entre entornos de ejecución completamente diferentes AgentCore . El AgentCore Gateway registra cada punto final como un destino independiente y enruta cada sesión a uno u otro punto final en función de las ponderaciones de tráfico de la A/B prueba.
Configuración clave para las A/B pruebas basadas en objetivos:
+ Configuración de variantes: `variantConfiguration.target` con el nombre del objetivo AgentCore de Gateway
+ Configuración de evaluación: `perVariantOnlineEvaluationConfig` (una configuración de evaluación en línea por variante, ya que cada punto final tiene su propio grupo de registros)
+ Filtro de puerta de enlace: `gatewayFilter.targetPaths` determina qué rutas de AgentCore puerta de enlace intercepta la A/B prueba
En este tutorial se utilizan dos versiones del agente de atención al cliente (una con Claude Sonnet (control) y otra con Claude Opus (tratamiento). Crea puntos finales con nombre para cada versión, crea una A/B prueba, envía el tráfico, revisa los resultados e implementa la versión ganadora.
**nota**
Este tutorial es para agentes alojados en un entorno de ejecución. AgentCore Si su agente se ejecuta **fuera** de un AgentCore entorno de ejecución (un agente externo o autohospedado, por ejemplo, en AWS Lambda), [consulte Ejecutar A/B una prueba para agentes alojados fuera AgentCore](ab-testing-3p-agents.md) de.
Para ver una comparación detallada de los patrones de A/B prueba, consulte [Elegir un](ab-testing.md#ab-testing-pattern-comparison) patrón.
## Paso 1: Crea el proyecto
Cree el proyecto con la AgentCore CLI:
```
agentcore create --name ABTestTargetBased --no-agent
cd ABTestTargetBased
```
## Paso 2: Añadir el tiempo de ejecución
Añada el tiempo de ejecución del agente. Implementará dos versiones de este tiempo de ejecución (una para el control y otra para el tratamiento) y, a continuación, creará puntos finales con nombre para asignar un alias a cada versión.
```
agentcore add agent \
--name csAgent \
--language Python \
--framework Strands \
--model-provider Bedrock \
--memory none \
--build CodeZip
```
Estructura del proyecto:
```
ABTestTargetBased/
├── agentcore/
│ ├── agentcore.json
│ ├── aws-targets.json
│ └── cdk/
└── app/
└── csAgent/
├── main.py
└── pyproject.toml
```
## Paso 3: Implementar las versiones de control y tratamiento
`app/csAgent/main.py`Sustitúyala por la versión de control (utilizando Claude Sonnet):
```
"""Customer support agent — control variant."""
from strands import Agent, tool
from strands.models.bedrock import BedrockModel
from bedrock_agentcore.runtime import BedrockAgentCoreApp
app = BedrockAgentCoreApp()
MODEL_ID = "global.anthropic.claude-sonnet-4-5-20250929-v1:0"
SYSTEM_PROMPT = "You are a helpful customer support assistant for Acme Store."
@tool
def lookup_order(order_id: str) -> str:
"""Look up an order by ID."""
orders = {
"ORD-1001": {"status": "delivered", "item": "Blue T-Shirt", "total": "$29.99"},
"ORD-1002": {"status": "in_transit", "item": "Running Shoes", "est_delivery": "2026-04-05"},
"ORD-1003": {"status": "delayed", "item": "Wireless Headphones", "days_late": 5},
}
return str(orders.get(order_id, {"error": f"Order {order_id} not found"}))
@tool
def initiate_return(order_id: str, reason: str) -> str:
"""Initiate a return for an order."""
return f"Return initiated for {order_id}. Reason: {reason}. Return label sent to customer email."
@tool
def apply_discount(order_id: str, discount_percent: int, reason: str) -> str:
"""Apply a discount to an order."""
return f"Applied {discount_percent}% discount to {order_id}. Reason: {reason}."
agent = Agent(
model=BedrockModel(model_id=MODEL_ID),
tools=[lookup_order, initiate_return, apply_discount],
system_prompt=SYSTEM_PROMPT,
)
@app.entrypoint
def invoke(payload, context):
result = agent(payload.get("prompt", "Hello"))
return {"response": result.message["content"][0]["text"]}
if __name__ == "__main__":
app.run()
```
Actualice `app/csAgent/pyproject.toml` las dependencias:
```
dependencies = [
"aws-opentelemetry-distro",
"bedrock-agentcore >= 1.8.0",
"boto3",
"botocore[crt] >= 1.35.0",
"strands-agents[otel] >= 1.13.0",
"opentelemetry-distro",
"opentelemetry-instrumentation",
]
```
Implemente la versión de control (esto crea la versión 1):
```
agentcore deploy
```
Ahora actualice `main.py` para usar un modelo diferente para la variante de tratamiento e impleméntelo (esto crea la versión 2):
```
MODEL_ID = "global.anthropic.claude-opus-4-6-v1"
```
```
agentcore deploy
```
Cree puntos finales con nombre para cada versión e implemente:
```
agentcore add runtime-endpoint \
--runtime csAgent \
--endpoint control \
--version 1 \
--description "Control variant — Claude Sonnet"
agentcore add runtime-endpoint \
--runtime csAgent \
--endpoint treatment \
--version 2 \
--description "Treatment variant — Claude Opus"
agentcore deploy
```
Ahora tiene:
+ Punto final de ejecución`control`: servidor de la versión 1 con Claude Sonnet.
+ Punto final de ejecución`treatment`: sirve la versión 2 con Claude Opus.
Compruebe que el tiempo de ejecución funciona:
```
agentcore invoke --runtime csAgent --prompt "What is the status of order ORD-1003?"
```
Ahora tiene:
+ Punto final de ejecución`control`: servidor de la versión 1 con Claude Sonnet.
+ Punto final de ejecución`treatment`: sirve la versión 2 con Claude Opus.
## Paso 4: Crear configuraciones de evaluación en línea
Cada punto final tiene su propio grupo de registros (el nombre del grupo de registros termina con el nombre del punto final), por lo que necesita una configuración de evaluación en línea por variante:
```
agentcore add online-eval \
--name controlEvalTb \
--runtime csAgent \
--endpoint control \
--evaluator "Builtin.Helpfulness" \
--sampling-rate 100.0 \
--enable-on-create
agentcore add online-eval \
--name treatmentEvalTb \
--runtime csAgent \
--endpoint treatment \
--evaluator "Builtin.Helpfulness" \
--sampling-rate 100.0 \
--enable-on-create
agentcore deploy
```
Después de cada implementación, anote el ARN de la configuración de evaluación en línea; necesitará ambos al crear la A/B prueba.
Para obtener más información sobre las opciones y la configuración del evaluador, consulte [Crear una evaluación en línea](create-online-evaluations.md).
## Paso 5: Cree la puerta de enlace y los objetivos
Una A/B prueba basada en objetivos enruta el tráfico a través de una AgentCore puerta de enlace, por lo que la puerta de enlace y sus dos objetivos ya deben estar implementados antes de iniciar la prueba. Agregue una puerta de enlace y registre cada punto final de tiempo de ejecución como `http-runtime` destino y, a continuación, implemente:
```
agentcore add gateway --name csGateway
agentcore add gateway-target \
--name customer-support-control \
--gateway csGateway \
--type http-runtime \
--runtime csAgent \
--runtime-endpoint control
agentcore add gateway-target \
--name customer-support-treatment \
--gateway csGateway \
--type http-runtime \
--runtime csAgent \
--runtime-endpoint treatment
agentcore deploy
```
## Paso 6: Crea la A/B prueba
Comience la A/B prueba con`agentcore run ab-test`. Cada variante hace referencia a uno de los objetivos de pasarela que ha creado y tiene su propia configuración de evaluación en línea. El comando inicia la prueba directamente en el servicio en la puerta de enlace ya implementada.
**Example**
```
agentcore run ab-test \
--mode target-based \
--name customerSupportTargetTest \
--gateway csGateway \
--runtime csAgent \
--control-target customer-support-control \
--treatment-target customer-support-treatment \
--control-online-eval controlEvalTb \
--treatment-online-eval treatmentEvalTb \
--control-weight 80 \
--treatment-weight 20
```
La prueba se ejecutará en cuanto vuelva el comando. Pase `--disable-on-create` para crearla detenida. El `--gateway` indicador es obligatorio y debe hacer referencia a la puerta de enlace que implementó en el paso 5. Solo se puede ejecutar una prueba por puerta de enlace a la vez. El comando imprime el identificador del trabajo de la prueba, que también está disponible en el `id` campo. `--json` Necesitará este ID para los comandos de ciclo de vida que aparecen a continuación.
```
import boto3
import uuid
REGION = "us-west-2"
ACCOUNT_ID = "123456789012"
# Runtime ARNs from Step 2 deployment output
CONTROL_RUNTIME_ARN = f"arn:aws:bedrock-agentcore:{REGION}:{ACCOUNT_ID}:runtime/ABTestTargetBased_CustomerSupportControl-abc123"
TREATMENT_RUNTIME_ARN = f"arn:aws:bedrock-agentcore:{REGION}:{ACCOUNT_ID}:runtime/ABTestTargetBased_CustomerSupportTreatment-def456"
# Online evaluation config ARNs from Step 3
CONTROL_EVAL_ARN = f"arn:aws:bedrock-agentcore:{REGION}:{ACCOUNT_ID}:online-evaluation-config/controlEvalTb-abc123"
TREATMENT_EVAL_ARN = f"arn:aws:bedrock-agentcore:{REGION}:{ACCOUNT_ID}:online-evaluation-config/treatmentEvalTb-def456"
# IAM roles
GATEWAY_ROLE_ARN = f"arn:aws:iam::{ACCOUNT_ID}:role/AgentCoreGatewayRole"
AB_TEST_ROLE_ARN = f"arn:aws:iam::{ACCOUNT_ID}:role/ABTestRole"
cp_client = boto3.client("bedrock-agentcore-control", region_name=REGION)
dp_client = boto3.client("bedrock-agentcore", region_name=REGION)
# 1. Create an AgentCore Gateway
gateway_response = cp_client.create_gateway(
name="customerSupportTargetTest-gw",
roleArn=GATEWAY_ROLE_ARN,
authorizerType="AWS_IAM",
clientToken=str(uuid.uuid4()),
)
gateway_id = gateway_response["gatewayId"]
gateway_arn = gateway_response["gatewayArn"]
print(f"Created AgentCore Gateway: {gateway_id}")
# 2. Add control runtime as an AgentCore Gateway target
cp_client.create_gateway_target(
gatewayIdentifier=gateway_id,
name="customer-support-control",
targetConfiguration={
"http": {
"agentcoreRuntime": {
"arn": CONTROL_RUNTIME_ARN,
"qualifier": "DEFAULT"
}
}
},
clientToken=str(uuid.uuid4()),
)
print("Added target: customer-support-control")
# 3. Add treatment runtime as an AgentCore Gateway target
cp_client.create_gateway_target(
gatewayIdentifier=gateway_id,
name="customer-support-treatment",
targetConfiguration={
"http": {
"agentcoreRuntime": {
"arn": TREATMENT_RUNTIME_ARN,
"qualifier": "DEFAULT"
}
}
},
clientToken=str(uuid.uuid4()),
)
print("Added target: customer-support-treatment")
# 4. Create the A/B test
response = dp_client.create_ab_test(
name="customerSupportTargetTest",
gatewayArn=gateway_arn,
roleArn=AB_TEST_ROLE_ARN,
evaluationConfig={
"perVariantOnlineEvaluationConfig": [
{"name": "C", "onlineEvaluationConfigArn": CONTROL_EVAL_ARN},
{"name": "T1", "onlineEvaluationConfigArn": TREATMENT_EVAL_ARN}
]
},
gatewayFilter={
"targetPaths": ["/customer-support-control/*"]
},
variants=[
{
"name": "C",
"weight": 80,
"variantConfiguration": {
"target": {"name": "customer-support-control"}
}
},
{
"name": "T1",
"weight": 20,
"variantConfiguration": {
"target": {"name": "customer-support-treatment"}
}
}
],
enableOnCreate=True,
clientToken=str(uuid.uuid4()),
)
ab_test_id = response["abTestId"]
print(f"Created A/B test: {ab_test_id}")
print(f"Status: {response['status']}")
print(f"Execution status: {response['executionStatus']}")
```
## Paso 7: Enviar tráfico a través de la AgentCore puerta de enlace
Una vez A/B ejecutada la prueba, envíe el tráfico a través del punto final HTTP de la AgentCore puerta de enlace. El AgentCore Gateway asigna cada solicitud a una variante (control o tratamiento) en función del ID de la sesión en tiempo de ejecución.
### Cómo funciona la asignación de variantes
La AgentCore puerta de enlace usa el `X-Amzn-Bedrock-AgentCore-Runtime-Session-Id` encabezado para determinar a qué objetivo enrutar el tráfico. Este encabezado es **opcional**: si no lo proporciona, el motor de ejecución genera un ID de sesión automáticamente. A continuación, el AgentCore Gateway utiliza el ID de sesión (tanto si lo has proporcionado como si lo ha generado el tiempo de ejecución) para asignar la solicitud a una variante en función de las ponderaciones de tráfico configuradas.
La asignación de sesiones es **fija**: una vez que se asigna un ID de sesión a una variante, todas las solicitudes posteriores con ese mismo ID de sesión se dirigen al mismo destino. Esto garantiza una experiencia coherente dentro de una sesión y, al mismo tiempo, distribuye las nuevas sesiones entre las variantes en función de la división del tráfico.
### Genera tráfico para realizar pruebas
Guarde el siguiente script como`loadgen.sh`, sustituyendo `` y por `` los valores del resultado de la implementación. También puede copiar la URL de invocación completa de`agentcore view ab-test `:
```
#!/bin/bash
export AWS_ACCESS_KEY_ID=$(aws configure get aws_access_key_id)
export AWS_SECRET_ACCESS_KEY=$(aws configure get aws_secret_access_key)
export AWS_SESSION_TOKEN=$(aws configure get aws_session_token)
GATEWAY_URL="https://.gateway.bedrock-agentcore.us-west-2.amazonaws.com//invocations"
PROMPTS=(
"What is the status of order ORD-1003?"
"I want to return order ORD-1001, it doesn't fit."
"My order ORD-1003 is late. Can I get a discount?"
"Where is my order ORD-1002?"
"I need help with a return for order ORD-1001. The color is wrong."
"Can you check on order ORD-1003? I've been waiting forever."
"I'd like to cancel order ORD-1002 if it hasn't shipped yet."
"Order ORD-1003 is delayed again. This is unacceptable."
"What's your return policy for order ORD-1001?"
"My headphones order ORD-1003 still hasn't arrived. What can you do?"
)
for i in $(seq 1 30); do
PROMPT="${PROMPTS[$(( (i - 1) % ${#PROMPTS[@]} ))]}"
echo "=== Request $i: $PROMPT ==="
curl -s --aws-sigv4 "aws:amz:us-west-2:bedrock-agentcore" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "Content-Type: application/json" \
-H "X-Amzn-Bedrock-AgentCore-Runtime-Session-Id: $(uuidgen)" \
-d "{\"prompt\": \"$PROMPT\"}" \
-X POST \
"$GATEWAY_URL"
echo ""
sleep 2
done
```
Ejecute el script :
```
bash loadgen.sh
```
## Paso 8: Obtenga resultados
Realice un sondeo A/B de la prueba para monitorear los resultados a medida que aumenta el tamaño de la muestra. El sondeo no afecta a la validez estadística.
**Example**
Obtenga los resultados actuales (``sustitúyalos por el identificador de trabajo del paso 6):
```
agentcore view ab-test
```
Obtenga los resultados como JSON:
```
agentcore view ab-test --json
```
Realice una encuesta hasta que los resultados alcancen significación estadística:
```
import boto3
import time
client = boto3.client("bedrock-agentcore", region_name="us-west-2")
ab_test_id = "customerSupportTargetTest-Ab1Cd2Ef3G"
while True:
response = client.get_ab_test(abTestId=ab_test_id)
status = response["status"]
exec_status = response["executionStatus"]
print(f"Status: {status}, Execution: {exec_status}")
results = response.get("results")
if results:
print(f"Analysis timestamp: {results.get('analysisTimestamp')}")
for metric in results["evaluatorMetrics"]:
evaluator = metric["evaluatorArn"]
control = metric["controlStats"]
print(f"\nEvaluator: {evaluator}")
print(f" Control: mean={control['mean']:.3f}, n={control['sampleSize']}")
for variant in metric["variantResults"]:
print(f" {variant['variantName']}: mean={variant['mean']:.3f}, "
f"n={variant['sampleSize']}, "
f"pValue={variant.get('pValue', 'N/A')}, "
f"significant={variant['isSignificant']}")
if variant["isSignificant"]:
print(f" >>> Statistically significant! "
f"Change: {variant.get('percentChange', 0):.1f}%")
# Check if any evaluator has reached significance
all_significant = all(
variant["isSignificant"]
for metric in results["evaluatorMetrics"]
for variant in metric["variantResults"]
)
if all_significant:
print("\nAll evaluators have reached statistical significance.")
break
time.sleep(300) # Poll every 5 minutes
```
**nota**
El tiempo que tardan en aparecer los resultados depende principalmente del tiempo de espera de la sesión configurado en las configuraciones de evaluación en línea. Una sesión se considera completa cuando no llegan nuevas solicitudes dentro del período de tiempo de espera. Una vez finalizada la sesión, los resultados suelen aparecer en 15 minutos. Los resultados se acumulan a medida que se completan más sesiones; la significación estadística mejora con el tamaño de la muestra.
+ **Valor p < 0,05 y positivo`percentChange`:** el tratamiento es significativamente mejor que el control. Considere la posibilidad de utilizar el tratamiento.
+ **Valor p < 0,05 y negativo`percentChange`:** el tratamiento es significativamente peor. Mantén el control.
+ **Valor p >= 0.05:** No hay pruebas suficientes para concluir una diferencia. Continúe recolectando muestras o aumente el tráfico al tratamiento.
+ **Compruebe todos los evaluadores:** un tratamiento puede mejorar una métrica y hacer retroceder otra. Revise todos los resultados de los evaluadores antes de tomar una decisión.
## Paso 9: Confirme los resultados y detenga la prueba A/B
Una vez que la A/B prueba alcance la significación estadística, revise los resultados y detenga el experimento.
1. **Confirme la significancia.** Compruebe que el evaluador objetivo tiene `isSignificant: true` un resultado positivo `percentChange` en la variante de tratamiento (o confirme que el control es el ganador si el tratamiento ha retrocedido).
1. **Detenga la prueba A/B .** Ejecute `agentcore stop ab-test -i `. El enrutamiento del tráfico finaliza inmediatamente y todas las solicitudes vuelven al destino predeterminado. Consulte [Ver, pausar, reanudar y detener](ab-testing-manage.md#manage-ab-test-start-stop).
## Paso 10: Despliega al ganador
Tras detener la A/B prueba, dirija todo el tráfico a la variante ganadora.
```
agentcore promote ab-test -i
agentcore deploy
```
`promote`detiene la A/B prueba (si aún se está ejecutando), actualiza el punto final de control para que apunte a la versión del tratamiento (por ejemplo, al actualizar `control` de la versión 1 a la versión 2) y elimina el punto final del tratamiento. Ejecute `agentcore deploy` para aplicar los cambios.
Como alternativa, puedes desplegar el ganador manualmente mediante una de las siguientes acciones:
+ **Opción A:** utilice [las reglas de enrutamiento de AgentCore Gateway](gateway-rules.md) para dirigir el tráfico de ambos objetivos al objetivo ganador.
+ **Opción B:** Elimine el objetivo perdedor de la AgentCore puerta de enlace y dirija todo el tráfico al ganador.
+ **Opción C:** actualiza el objetivo perdedor para que apunte al punto final ganador.
Tras desplegar al ganador:
+ **Elimine la A/B prueba** para limpiar los recursos. Consulte [Eliminar una A/B prueba](ab-testing-manage.md#manage-ab-test-remove).
+ **Supervise la nueva línea base.** La evaluación en línea continúa con las sesiones de puntuación de la configuración ganadora. Esté atento a las regresiones.
+ **Inicie la siguiente iteración.** Las nuevas trazas de la configuración ganadora constituyen la base para el siguiente ciclo de recomendaciones. Vea [cómo funciona](optimization-how-it-works.md).
## Comprensión de los resultados
Cuando llamas`GetABTest`, la respuesta incluye un `results` objeto una vez que la canalización de agregación haya procesado suficientes sesiones. Los resultados contienen métricas por evaluador desglosadas por variante.
### Estructura de resultados
```
{
"results": {
"analysisTimestamp": "2026-04-30T18:45:00Z",
"evaluatorMetrics": [
{
"evaluatorArn": "arn:aws:bedrock-agentcore:us-west-2:123456789012:evaluator/Builtin.Helpfulness",
"controlStats": {
"variantName": "C",
"sampleSize": 24,
"mean": 0.72
},
"variantResults": [
{
"variantName": "T1",
"sampleSize": 6,
"mean": 0.85,
"absoluteChange": 0.13,
"percentChange": 18.1,
"pValue": 0.032,
"confidenceInterval": {
"lower": 0.02,
"upper": 0.24
},
"isSignificant": true
}
]
}
]
}
}
```
### Referencia de campos
| Campo | Description (Descripción) |
| --- | --- |
| `analysisTimestamp` | Cuándo fue la última vez que el servicio calculó las estadísticas. |
| `evaluatorMetrics` | Una entrada por evaluador en la configuración de evaluación en línea. |
| `controlStats.mean` | Puntuación media de los evaluadores en todas las sesiones de control. |
| `controlStats.sampleSize` | Número de sesiones puntuadas para la variante de control. |
| `variantResults[].mean` | Puntuación media del evaluador en todas las sesiones de tratamiento. |
| `variantResults[].sampleSize` | Número de sesiones puntuadas para la variante de tratamiento. |
| `variantResults[].absoluteChange` | Diferencia entre la media del tratamiento y la media de control. |
| `variantResults[].percentChange` | Porcentaje de mejora (positiva) o regresión (negativa) en relación con el control. |
| `variantResults[].pValue` | Probabilidad de que la diferencia observada se deba al azar. Un valor inferior a 0,05 indica significación estadística. |
| `variantResults[].confidenceInterval` | Intervalo de confianza del 95% para el cambio absoluto (`lower`y `upper` los límites). |
| `variantResults[].isSignificant` | `true`cuando el valor p es inferior a 0,05 y el tamaño de la muestra son suficientes. |
## Resolución de problemas
### A/B la prueba no muestra resultados después de enviar el tráfico
Los resultados no aparecen inmediatamente. El tiempo necesario depende del tiempo de espera de la sesión configurado en la configuración de evaluación en línea: una sesión se considera completa solo cuando no llegan nuevas solicitudes dentro del período de tiempo de espera. Una vez finalizada la sesión, los resultados se obtienen en aproximadamente 15 minutos.
Si los resultados siguen sin aparecer después de esta ventana:
+ **Compruebe el grupo de registros de evaluación en línea.** La configuración de la evaluación en línea debe apuntar al grupo de registros de salida del agente de ejecución. Si la configuración de evaluación en línea hace referencia a un grupo de registros diferente (o a uno que no reciba intervalos de su tiempo de ejecución), las sesiones no se puntuarán y la A/B prueba nunca arrojará resultados.
+ **Compruebe el nombre del grupo de registros.** Para el enrutamiento basado en el destino, cada punto final tiene su propio grupo de registros (el nombre del grupo de registros termina con el nombre del punto final). Asegúrese de que cada configuración de evaluación en línea haga referencia al grupo de registros del punto final correcto.
+ **Confirme que el tiempo de ejecución esté emitiendo intervalos.** Compruebe CloudWatch los registros para ver el grupo de registros esperado. Los atributos clave que busca en cada intervalo:
+ `aws.agentcore.gateway.routing_experiment_arn`
+ `aws.agentcore.gateway.routing_experiment_variant_name`(valores: `C` o`T1`)
+ `session.id`
+ **Verificar CLI-created frente a las configuraciones manuales.** Si lo utilizó`agentcore add online-eval --runtime `, la CLI configura automáticamente el grupo de registros correcto. Si creó la configuración de evaluación en línea manualmente a través de la API, asegúrese de que la configuración de evaluación AgentCore en línea `dataSourceConfig.cloudWatchLogs.logGroupNames` coincida con el grupo de registros de intervalos de su tiempo de ejecución.