Construir Aplicaciones Potenciadas por Agentes con Next.js, Supabase y Cron en 2026
He pasado el último medio año inmerso en la construcción de tres aplicaciones impulsadas por agentes para clientes. Dos están completamente en vivo, procesando autónomamente miles de tareas cada día. Entonces, ¿qué está impulsando estos proyectos? Es la combinación formidable de Next.js implementado en Vercel, Supabase para persistencia y necesidades en tiempo real, y buena orquestación basada en cron para mantener los agentes alineados y evitar excesos de honorarios de API. Esto no es solo teoría: desglosaremos qué funciona, las trampas y todos los conocimientos que desearía haber tenido antes de sumergirme.
Cómo se ven realmente las aplicaciones impulsadas por agentes en 2026
Cuando hablo de "aplicaciones impulsadas por agentes", no solo estoy discutiendo un chatbot que repite un indicador del sistema. Piensa en software que maneja autónomamente tareas multietapa, toma decisiones basadas en datos en tiempo real y funciona en un horario, todo sin necesidad de intervención humana.
Aquí hay una muestra de lo que está en funcionamiento en producción:
- Canales de contenido que escanean feeds RSS, generan resúmenes, redactan publicaciones sociales y las ponen en cola para revisión. Este ciclo se repite cada 30 minutos como un reloj.
- Agentes de reconciliación de datos que se conectan a múltiples APIs cada noche, detectan inconsistencias, intentan correcciones automáticas y escalan problemas que no pueden resolver.
- Agentes de incorporación de clientes activados por webhooks de nuevas suscripciones. Estos agentes aprovisionan recursos, envían secuencias personalizadas y se adaptan mientras aprenden comportamientos de usuarios.
¿El hilo común? Necesitan persistencia de estado, ejecución programada, acceso a herramientas y una manera para que los humanos espíen e intervengan cuando sea necesario. Ese es el punto dulce para la pila en la que nos estamos sumergiendo.
Por qué funciona esta pila
He jugado con otras configuraciones. Hay LangChain emparejado con un backend Python, Temporal para orquestación y sistemas de cola personalizados de AWS. Aunque todos hacen el trabajo, vienen con una montaña de complejidad operativa que la mayoría de los equipos simplemente no puede manejar en 2026.
Aquí está mi comparación directa:
| Pila | Tiempo de configuración | Sobrecarga operativa | Costo en 10K tareas/día | Mejor para |
|---|---|---|---|---|
| Next.js + Supabase + Vercel Cron | 1-2 días | Bajo | ~$85-150/mo | La mayoría de apps de agentes |
| Python + Celery + Redis + AWS | 3-5 días | Alto | ~$200-400/mo | Tareas de cómputo pesado |
| Temporal + Workers personalizados | 5-10 días | Muy alto | ~$300-600/mo | Flujos de trabajo complejos |
| Inngest + Next.js | 1-2 días | Bajo-Medio | ~$100-200/mo | Agentes impulsados por eventos |
La combinación de Next.js gana por mucho en velocidad. Obtienes funciones sin servidor, una interfaz de panel, bases de datos, autenticación, actualizaciones en tiempo real y ejecución cronometrada sin preocuparte por la infraestructura. Para la gran mayoría de nosotros que construimos aplicaciones de agentes, eso es más que suficiente.
Descripción general de la arquitectura
Vamos a pintar una imagen de la arquitectura que ha sido un éxito en todos los proyectos:
┌─────────────────┐ ┌──────────────────┐
│ Vercel Cron │────▶│ Next.js API Route │
│ (Scheduler) │ │ (Agent Runner) │
└─────────────────┘ └────────┬───────────┘
│
┌────────────┼────────────┐
▼ ▼ ▼
┌──────────┐ ┌─────────┐ ┌───────────┐
│ Supabase │ │ LLM API │ │ External │
│ (State + │ │ (OpenAI/│ │ Tools & │
│ Queue) │ │ Claude) │ │ APIs │
└──────────┘ └─────────┘ └───────────┘
│
▼
┌──────────┐
│ Supabase │
│ Realtime │──▶ Dashboard UI
└──────────┘
Los trabajos cron llegan a una ruta de API de Next.js, que luego extrae tareas de Supabase, ejecuta la lógica del agente, escribe resultados nuevamente y termina. Mientras tanto, tu panel está observando la acción con Supabase Realtime entregando actualizaciones en vivo.
Sí, bastante simple, pero el diablo prospera en los detalles.
Configurando la base con Next.js y Vercel
Cuando construyes aplicaciones de agentes en 2026, Next.js 15 con el App Router es imprescindible. Te da los patrones de ejecución más limpios gracias a sus Server Actions y Route Handlers. En Social Animal, hemos perfeccionado esta habilidad de Next.js, y te digo, el App Router ha madurado esplendidamente para proyectos intensivos de backend.
Comenzar un proyecto es sencillo:
pnpx create-next-app@latest agent-app --typescript --tailwind --app
cd agent-app
pnpm add @supabase/supabase-js ai @ai-sdk/openai
Estoy utilizando el Vercel AI SDK gracias a su interfaz unificada entre diferentes proveedores de LLM. En 2026, la versión 4.x del paquete ai soporta salidas estructuradas, llamadas de herramientas y transmisión lista para usar – ¿LangChain quién?
Ahora tu vercel.json necesita que su configuración cron se vea algo como esto:
{
"crons": [
{
"path": "/api/agents/run",
"schedule": "*/15 * * * *"
},
{
"path": "/api/agents/cleanup",
"schedule": "0 2 * * *"
}
]
}
El primer cron ejecuta el agente cada 15 minutos. El segundo limpia cada noche. Recuerda, Vercel Pro ($20/mes) soporta trabajos cron con frecuencia de hasta 1 minuto. Pero si estás en el plan Hobby, estás limitado a crons diarios, lo que simplemente no funcionará para la mayoría de necesidades impulsadas por agentes.
Configuración de función de Vercel
Las tareas de agentes pueden ser más largas que un éxito de taquilla (bueno, no exactamente), pero necesitan más de 10 segundos para ejecutarse de forma predeterminada. Configura tu ruta así:
// app/api/agents/run/route.ts
export const maxDuration = 300; // 5 minutos en plan Pro
export const dynamic = 'force-dynamic';
export async function GET(request: Request) {
// Verifica el secreto cron para evitar acceso no autorizado
const authHeader = request.headers.get('authorization');
if (authHeader !== `Bearer ${process.env.CRON_SECRET}`) {
return new Response('Unauthorized', { status: 401 });
}
// La lógica del agente va aquí
return Response.json({ success: true });
}
Ese maxDuration? Es crucial. Hasta 300 segundos en Pro, y 900 segundos si estás nadando en aguas Enterprise. ¿Alguna tarea de rutina que supere los 5 minutos? Es hora de segmentarlas o replantear tu modelo de ejecución.
Supabase como el cerebro de tu agente
Supabase--una potencia aquí. Se posiciona como tu cola de tareas, almacén de estado, registro de auditoría y tu notificador de actualizaciones en tiempo real. Aquí está el esquema que he perfeccionado con el tiempo:
-- Cola de tareas del agente
CREATE TABLE agent_tasks (
id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
agent_type TEXT NOT NULL,
status TEXT NOT NULL DEFAULT 'pending'
CHECK (status IN ('pending', 'running', 'completed', 'failed', 'cancelled')),
priority INTEGER DEFAULT 0,
payload JSONB NOT NULL DEFAULT '{}',
result JSONB,
error TEXT,
attempts INTEGER DEFAULT 0,
max_attempts INTEGER DEFAULT 3,
locked_until TIMESTAMPTZ,
scheduled_for TIMESTAMPTZ DEFAULT NOW(),
started_at TIMESTAMPTZ,
completed_at TIMESTAMPTZ,
created_at TIMESTAMPTZ DEFAULT NOW(),
updated_at TIMESTAMPTZ DEFAULT NOW()
);
-- Índice para la consulta de sondeo de cola
CREATE INDEX idx_agent_tasks_queue ON agent_tasks (
agent_type, status, priority DESC, scheduled_for
) WHERE status = 'pending';
-- Registros de ejecución del agente para observabilidad
CREATE TABLE agent_logs (
id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
task_id UUID REFERENCES agent_tasks(id),
level TEXT NOT NULL DEFAULT 'info',
message TEXT NOT NULL,
metadata JSONB DEFAULT '{}',
created_at TIMESTAMPTZ DEFAULT NOW()
);
-- Persistencia de estado del agente (para agentes de múltiples pasos)
CREATE TABLE agent_state (
id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
agent_type TEXT NOT NULL,
agent_instance_id TEXT NOT NULL,
state JSONB NOT NULL DEFAULT '{}',
updated_at TIMESTAMPTZ DEFAULT NOW(),
UNIQUE(agent_type, agent_instance_id)
);
Esa columna locked_until? Es clave. Imita un bloqueo distribuido improvisado. Esto significa que cuando un trabajo cron recoge una tarea, establece locked_until hacia adelante por 5 minutos. Si el proceso se bloquea, el bloqueo expira y otro ciclo puede darle otra oportunidad.
La consulta de recogida de tareas
La joya de la corona. Este es tu boleto de oro para agarrar tareas sin reprocesar:
import { createClient } from '@supabase/supabase-js';
const supabase = createClient(
process.env.SUPABASE_URL!,
process.env.SUPABASE_SERVICE_ROLE_KEY!
);
async function claimTasks(agentType: string, limit: number = 5) {
const { data: tasks, error } = await supabase
.rpc('claim_agent_tasks', {
p_agent_type: agentType,
p_limit: limit,
p_lock_duration: '5 minutes'
});
if (error) throw error;
return tasks;
}
Y la función Postgres correspondiente:
CREATE OR REPLACE FUNCTION claim_agent_tasks(
p_agent_type TEXT,
p_limit INTEGER,
p_lock_duration INTERVAL
)
RETURNS SETOF agent_tasks AS $$
BEGIN
RETURN QUERY
UPDATE agent_tasks
SET
status = 'running',
locked_until = NOW() + p_lock_duration,
started_at = NOW(),
attempts = attempts + 1,
updated_at = NOW()
WHERE id IN (
SELECT id FROM agent_tasks
WHERE agent_type = p_agent_type
AND status = 'pending'
AND scheduled_for <= NOW()
AND (locked_until IS NULL OR locked_until < NOW())
AND attempts < max_attempts
ORDER BY priority DESC, scheduled_for ASC
LIMIT p_limit
FOR UPDATE SKIP LOCKED
)
RETURNING *;
END;
$$ LANGUAGE plpgsql;
El FOR UPDATE SKIP LOCKED es el héroe anónimo aquí. Asegura que ninguna invocación concurrente se pise una a la otra. Créeme, descubrir y corregir el procesamiento duplicado no fue una risa.
Orquestación de agentes basada en cron
Vercel Cron es el latido constante de toda esta operación. Cada 15 minutos, tu agente ejecutor entra en acción, agarra tareas, las procesa y luego se duerme hasta la próxima llamada.
Así es como se ve la ruta completa del ejecutor del agente:
// app/api/agents/run/route.ts
import { claimTasks, completeTask, failTask, logAgent } from '@/lib/agents';
import { runContentAgent } from '@/lib/agents/content';
import { runReconciliationAgent } from '@/lib/agents/reconciliation';
export const maxDuration = 300;
const AGENT_RUNNERS: Record<string, (task: AgentTask) => Promise<any>> = {
'content-pipeline': runContentAgent,
'data-reconciliation': runReconciliationAgent,
};
export async function GET(request: Request) {
const authHeader = request.headers.get('authorization');
if (authHeader !== `Bearer ${process.env.CRON_SECRET}`) {
return new Response('Unauthorized', { status: 401 });
}
const results = { processed: 0, failed: 0, skipped: 0 };
for (const [agentType, runner] of Object.entries(AGENT_RUNNERS)) {
const tasks = await claimTasks(agentType, 5);
for (const task of tasks) {
try {
await logAgent(task.id, 'info', `Starting ${agentType} task`);
const result = await runner(task);
await completeTask(task.id, result);
results.processed++;
} catch (error) {
const message = error instanceof Error ? error.message : 'Unknown error';
await failTask(task.id, message);
await logAgent(task.id, 'error', message);
results.failed++;
}
}
}
return Response.json(results);
}
Nota el procesamiento secuencial por tipo de agente, con un límite de 5 tareas por tipo por ejecución. Esto ayuda a mantener los tiempos de ejecución de funciones bajo control. ¿Tienes un montón de 50 tareas pendientes? Distribúyelas en varios ciclos cron. Sin prisa, sin problema.
Cuando cron no es suficiente
A veces, la vida llega rápido y cron simplemente no funciona. En estos casos, integro cron con Supabase Database Webhooks o Edge Functions: se activan mediante cambios en la base de datos:
-- Activar una edge function cuando se crea una tarea de alta prioridad
CREATE OR REPLACE FUNCTION notify_urgent_task()
RETURNS TRIGGER AS $$
BEGIN
IF NEW.priority > 5 THEN
PERFORM net.http_post(
url := 'https://your-app.vercel.app/api/agents/urgent',
headers := jsonb_build_object(
'Authorization', 'Bearer ' || current_setting('app.webhook_secret')
),
body := jsonb_build_object('task_id', NEW.id)
);
END IF;
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
Esta configuración te permite mezclar procesamiento predecible basado en cron con respuesta rápida para tareas urgentes.
Construyendo el bucle del agente
Aquí es donde ocurre la magia. Una implementación de agente de ejemplo usando la llamada de herramientas del Vercel AI SDK:
// lib/agents/content.ts
import { generateText, tool } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';
import { supabase } from '@/lib/supabase';
export async function runContentAgent(task: AgentTask) {
const { sourceUrl, targetPlatform } = task.payload;
const { text, toolCalls, usage } = await generateText({
model: openai('gpt-4o-mini'),
system: `You are a content processing agent. Fetch the source content,
analyze it, and generate appropriate social media content for ${targetPlatform}.
Use the provided tools to complete your task.`,
prompt: `Process this source: ${sourceUrl}`,
tools: {
fetchContent: tool({
description: 'Fetch content from a URL',
parameters: z.object({ url: z.string().url() }),
execute: async ({ url }) => {
const res = await fetch(url);
const html = await res.text();
// Strip HTML, extract main content
return extractMainContent(html);
},
}),
saveContent: tool({
description: 'Save generated content for review',
parameters: z.object({
title: z.string(),
body: z.string(),
platform: z.string(),
suggestedPostTime: z.string(),
}),
execute: async (content) => {
const { data, error } = await supabase
.from('generated_content')
.insert({
...content,
task_id: task.id,
status: 'pending_review',
})
.select()
.single();
if (error) throw error;
return { saved: true, id: data.id };
},
}),
},
maxSteps: 5, // Allow up to 5 tool-calling rounds
});
return {
summary: text,
toolCallCount: toolCalls.length,
tokensUsed: usage.totalTokens,
};
}
Establecer maxSteps en 5 permite que el LLM llame a herramientas, evalúe resultados y procese en consecuencia, como una pequeña abeja trabajadora haciendo su cosa. La mayoría de las tareas de contenido se completan en 3–4 llamadas de este tipo.
Monitoreo de agentes en tiempo real con Supabase Realtime
Los agentes autónomos son geniales, pero estar atento a ellos es primordial. Supabase Realtime alimenta un panel que se actualiza en tiempo real mientras los agentes avanzan:
// components/AgentDashboard.tsx
'use client';
import { useEffect, useState } from 'react';
import { createClient } from '@supabase/supabase-js';
const supabase = createClient(
process.env.NEXT_PUBLIC_SUPABASE_URL!,
process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
);
export function AgentDashboard() {
const [tasks, setTasks] = useState<AgentTask[]>([]);
const [logs, setLogs] = useState<AgentLog[]>([]);
useEffect(() => {
// Suscribirse a cambios de tareas
const taskChannel = supabase
.channel('agent-tasks')
.on(
'postgres_changes',
{ event: '*', schema: 'public', table: 'agent_tasks' },
(payload) => {
setTasks(prev => {
const updated = [...prev];
const idx = updated.findIndex(t => t.id === payload.new.id);
if (idx >= 0) updated[idx] = payload.new as AgentTask;
else updated.unshift(payload.new as AgentTask);
return updated.slice(0, 50);
});
}
)
.subscribe();
// Suscribirse a flujo de registros
const logChannel = supabase
.channel('agent-logs')
.on(
'postgres_changes',
{ event: 'INSERT', schema: 'public', table: 'agent_logs' },
(payload) => {
setLogs(prev => [payload.new as AgentLog, ...prev].slice(0, 100));
}
)
.subscribe();
return () => {
supabase.removeChannel(taskChannel);
supabase.removeChannel(logChannel);
};
}, []);
// Renderiza tu interfaz de panel...
}
Esto entrega un flujo en vivo de actividad del agente. Comúnmente, agregaría indicadores, conteos de tareas, visuales de tasa de error e incluso un botón "ejecutar ahora" para pruebas. Supabase Realtime se incluye en el nivel gratuito, sin dinero adicional necesario.
Manejo de fallos y casos extremos
Prepárate: algo explotará. Las APIs desaparecen, los límites de velocidad te golpean en la cara o los servicios simplemente envían tonterías. Aquí está lo que he aprendido sobre hacer sistemas que sobreviven.
Reintentos con retroceso exponencial
Las columnas attempts y max_attempts que incorporamos manejan reintentos. Si una tarea falla, permanece en estado 'failed' pero puede establecerse para reintentar manualmente o automáticamente después:
async function failTask(taskId: string, error: string) {
const { data } = await supabase
.from('agent_tasks')
.select('attempts, max_attempts')
.eq('id', taskId)
.single();
const shouldRetry = data && data.attempts < data.max_attempts;
await supabase
.from('agent_tasks')
.update({
status: shouldRetry ? 'pending' : 'failed',
error,
locked_until: null,
// Retroceso exponencial: 1min, 4min, 9min...
scheduled_for: shouldRetry
? new Date(Date.now() + Math.pow(data.attempts, 2) * 60000).toISOString()
: undefined,
updated_at: new Date().toISOString(),
})
.eq('id', taskId);
}
Disyuntores para APIs externas
Cuando las APIs externas fracasan, los reintentos inmediatos consumen reintentos rápidamente. Mantén un registro de tasas de fallos en Supabase, y puedes detener agentes si las cosas se ven sombrías:
async function checkCircuitBreaker(service: string): Promise<boolean> {
const fiveMinutesAgo = new Date(Date.now() - 300000).toISOString();
const { count } = await supabase
.from('agent_logs')
.select('*', { count: 'exact', head: true })
.eq('level', 'error')
.ilike('message', `%${service}%`)
.gte('created_at', fiveMinutesAgo);
return (count ?? 0) < 10; // Trip if more than 10 errors in 5 min
}
Análisis de costos y optimización
Aquí es donde hablamos en serio. ¿Cuánto cuesta una aplicación de agente de producción en 2026?
| Componente | Nivel gratuito | Producción típica | Uso pesado |
|---|---|---|---|
| Vercel Pro | - | $20/mo | $20/mo + uso |
| Supabase Pro | - | $25/mo | $25/mo + uso |
| OpenAI (GPT-4o-mini) | - | $30-80/mo | $200+/mo |
| Anthropic (Claude 3.5 Haiku) | - | $20-50/mo | $150+/mo |
| Total | ~$0 (dev) | $95-175/mo | $395+/mo |
¿Las cuotas de LLM? Manejan el espectáculo. Así es como mantienes un control:
- Usa modelos más pequeños donde sea posible. GPT-4o-mini y Claude 3.5 Haiku manejan la mayoría de tareas a una fracción del costo de sus parientes más grandes.
- Almacena en caché antes de llegar a la API. Supabase puede esconder respuestas de LLM, reduciendo nuevas llamadas a API.
- Lota, lota, lota. En lugar de una llamada a API por tarea, agrupa tareas similares y envíalas juntas.
- ¿Límites de tokens? Sí, por favor. Siempre establece
maxTokensdurante tus llamadas de AI SDK, previene generación desenfrenada.
Patrones de implementación de producción
Una vez que te estés preparando para la implementación, varias cosas son críticas:
Separación de entorno. Aprovecha las ramas de Supabase (Pro requerido) para mantener bases de datos discretas para staging y producción. Empareja las implementaciones de vista previa de Vercel con ramas de Supabase para aislamiento completo.
Monitoreo. La observabilidad de Vercel proporciona historial de ejecución de cron y registros de funciones. Empareja esto con una verificación de salud de Supabase:
SELECT
agent_type,
status,
COUNT(*) as count,
AVG(EXTRACT(EPOCH FROM (completed_at - started_at))) as avg_duration_seconds
FROM agent_tasks
WHERE created_at > NOW() - INTERVAL '24 hours'
GROUP BY agent_type, status
ORDER BY agent_type, status;
Gestión de secretos. Protege tus claves de API con variables de entorno de Vercel, nunca las hardcodees. Usa la clave de rol de servicio solo en el lado del servidor con Supabase, mientras mantienes la clave anon en el lado del cliente.
Si necesitas ayuda configurando sistemas como este, nuestro equipo ha entregado múltiples aplicaciones impulsadas por agentes utilizando esta pila exacta. Consulta nuestras capacidades de desarrollo de CMS headless y desarrollo Next.js, o ponte en contacto para charlar sobre tu proyecto.
Preguntas frecuentes
¿Puede Vercel Cron manejar tareas de agentes de alta frecuencia?
Vercel Cron puede manejar intervalos tan cortos como 1 minuto en el plan Pro. La mayoría de las tareas del agente se adaptan a ciclos de 5-15 minutos. ¿Necesitas algo más rápido? Considera Supabase Database Webhooks o cambiar a Inngest para acciones impulsadas por eventos.
¿Cómo evito el procesamiento duplicado de tareas con cron?
Ahí es donde brilla FOR UPDATE SKIP LOCKED de PostgreSQL en tu consulta de reclamación de tareas. Es tu red de seguridad incluso si los tiempos de cron se superponen, asegurando que cada tarea sea reclamada de forma única. locked_until añade una capa de seguridad si desastres a mitad de la ejecución ocurren.
¿Es Supabase confiable para cargas de trabajo de agentes de producción?
Absolutamente. Supabase Pro se ejecuta en instancias Postgres dedicadas con copias de seguridad automatizadas y un SLA de tiempo de actividad del 99.9%. De hecho, para este sistema de cola de tareas, Postgres está más que calificado: capaz de manejar acceso concurrente y consultas complejas fácilmente.
¿Cuánto cuesta ejecutar agentes de IA en producción?
Típicamente, procesar 5,000-10,000 tareas diarias te costará entre $95-175/mes (Vercel Pro + Supabase Pro) más $30-80/mes para llamadas a API de LLM usando modelos como GPT-4o-mini. La capa variable es tu costo de LLM, dependiendo de la complejidad de la tarea y el uso de tokens.
¿Debo usar LangChain o el Vercel AI SDK para la lógica del agente?
En 2026, Vercel's AI SDK (v4.x) cubre la mayoría de necesidades del agente de forma nativa: uso de herramientas, razonamiento multietapa, salidas estructuradas y transmisión. LangChain se vuelve útil cuando profundizas en patrones avanzados de cadena de pensamiento, configuraciones RAG o integraciones de herramientas especializadas. Para esta pila, menos complejidad con el AI SDK reina supremo.
¿Puedo usar Astro en lugar de Next.js para este patrón?
Astro puede manejar rutas de API activadas por cron, pero te pierdes las optimizaciones de Vercel, incluida la configuración de cron y tiempos de espera más largos. Si tu panel prefiere contenido pesado, baja interactividad, Astro se adapta al frontend. Mantente con Next.js para tu backend de agente.
¿Cómo monitoreo el rendimiento del agente y las fallas?
Mezcla tres capas: los registros de Vercel para información a nivel de ejecución, la tabla agent_logs en Supabase para seguimiento de registros a nivel de aplicación y Supabase Realtime para monitoreo dinámico del panel. Establece controles de salud para fallos, tiempos de ejecución y longitud de cola. Vercel se sincroniza sin problemas con servicios de alertas como PagerDuty y Slack.
¿Qué sucede cuando mis tareas de agente exceden el tiempo de espera de función de Vercel?
En Vercel Pro, tienes un techo de 300 segundos. Si las tareas frecuentemente superan esto, considera dividirlas en subtareas pequeñas en ciclos cron. Por ejemplo, divide un proceso de contenido en tareas de "obtener", "analizar" y "generar". O explora Supabase Edge Functions para ejecuciones extendidas: tienen un límite de 150 segundos y se pueden activar según sea necesario.