Agent-gestuurde apps bouwen met Next.js, Supabase & Cron in 2026
Ik heb het afgelopen halfjaar drie agent-gestuurde applicaties voor klanten gebouwd
Ik heb het afgelopen halfjaar immersief gewerkt aan het bouwen van drie agent-gestuurde applicaties voor klanten. Twee daarvan zijn volledig live en voeren autonoom duizenden taken per dag uit. Dus wat drijft deze projecten aan? Het is de formidabele combinatie van Next.js geïmplementeerd op Vercel, Supabase voor persistentie en real-time behoeften, en goeie ouwe cron-gebaseerde orchestratie om agents op één lijn te houden en overtollige API-kosten te voorkomen. Dit is niet alleen theorie--ik zal uitleggen wat werkt, de valkuilen, en alle inzichten die ik had willen hebben voordat ik erin dook.
Hoe agent-gestuurde applicaties er in 2026 eigenlijk uitzien
Als ik het heb over "agent-gestuurde applicaties", bedoel ik niet zomaar een chatbot die een systeemvraag papegaait. Denk aan software die autonoom multi-stap taken afhandelt, real-time gegevensgestuurde beslissingen neemt, en op schema functioneert, alles zonder menselijke stimulering.
Hier een voorbode van wat in productie draait:
- Content pipelines die RSS-feeds scannen, samenvattingen genereren, sociale posts opstellen en deze in de rij zetten voor beoordeling. Deze cyclus herhaalt zich elke 30 minuten als klokwerk.
- Data reconciliation agents die elke nacht verbinding maken met meerdere API's, inconsistenties opsporen, automatische correcties proberen en problemen die ze niet kunnen oplossen escaleren.
- Customer onboarding agents geactiveerd door nieuwe sign-up webhooks. Deze agents richten resources in, sturen aangepaste sequenties en passen zich aan naarmate ze gebruikersgedrag leren kennen.
De rode draad? Ze hebben statuspersistentie, geplande uitvoering, toolacces en een manier nodig zodat mensen kunnen meekijken en kunnen ingrijpen wanneer nodig. Dat is het zoete plekje voor de stack waar we in duiken.
Waarom deze stack werkt
Ik heb geëxperimenteerd met andere setups. Er is LangChain gekoppeld aan een Python-backend, Temporal voor orchestratie, en custom AWS-queue-systemen. Hoewel ze allemaal het werk doen, komen ze met een berghoogte van operationele complexiteit waar de meeste teams tegen 2026 gewoon niet mee om kunnen gaan.
Hier mijn directe vergelijking:
| Stack | Inrichtingstijd | Operationele overhead | Kosten bij 10K taken/dag | Best voor |
|---|---|---|---|---|
| Next.js + Supabase + Vercel Cron | 1-2 dagen | Laag | ~€85-150/mnd | Meeste agent apps |
| Python + Celery + Redis + AWS | 3-5 dagen | Hoog | ~€200-400/mnd | Zware compute-taken |
| Temporal + Custom Workers | 5-10 dagen | Zeer hoog | ~€300-600/mnd | Complexe workflows |
| Inngest + Next.js | 1-2 dagen | Laag-Gemiddeld | ~€100-200/mnd | Event-driven agents |
De Next.js-combinatie wint zonder discussie op snelheid. Je krijgt serverless-functies, een dashboard-UI, databases, authenticatie, real-time updates en getimede uitvoering zonder je zorgen over infrastructuur. Voor de overgrote meerderheid van ons die agent apps bouwen, is dat meer dan genoeg.
Overzicht van de architectuur
Laten we een beeld schetsen van de architectuur die een hit is geweest in projecten:
┌─────────────────┐ ┌──────────────────┐
│ Vercel Cron │────▶│ Next.js API Route │
│ (Scheduler) │ │ (Agent Runner) │
└─────────────────┘ └────────┬───────────┘
│
┌────────────┼────────────┐
▼ ▼ ▼
┌──────────┐ ┌─────────┐ ┌───────────┐
│ Supabase │ │ LLM API │ │ External │
│ (State + │ │ (OpenAI/│ │ Tools & │
│ Queue) │ │ Claude) │ │ APIs │
└──────────┘ └─────────┘ └───────────┘
│
▼
┌──────────┐
│ Supabase │
│ Realtime │──▶ Dashboard UI
└──────────┘
De cron jobs bereiken een Next.js API route, die vervolgens taken ophaalt uit Supabase, agentlogica uitvoert, resultaten terugschrijft en afsluit. Ondertussen houdt je dashboard het gebeuren in de gaten met Supabase Realtime die live updates aflevert.
Ja, eenvoudig genoeg, maar duivel zit in details.
Het fundament opzetten met Next.js en Vercel
Als je agent apps bouwt in 2026, is Next.js 15 met de App Router een must-have. Het geeft je de schoonste executiepatronen dankzij Server Actions en Route Handlers. Bij Social Animal hebben we deze Next.js-vaardigheid verfijnd, en vertel me, de App Router is schitterend volwassen geworden voor backend-intensieve projecten.
Een project starten is eenvoudig:
pnpx create-next-app@latest agent-app --typescript --tailwind --app
cd agent-app
pnpm add @supabase/supabase-js ai @ai-sdk/openai
Ik gebruik de Vercel AI SDK dankzij de uniforme interface in verschillende LLM-providers. Tegen 2026 ondersteunt versie 4.x van het ai pakket structured outputs, tool calls en streaming meteen--LangChain wie?
Nu moet je vercel.json zijn cron-configuratie er als volgt uitzien:
{
"crons": [
{
"path": "/api/agents/run",
"schedule": "*/15 * * * *"
},
{
"path": "/api/agents/cleanup",
"schedule": "0 2 * * *"
}
]
}
De eerste cron voert de agent elke 15 minuten uit. De tweede ruimt elke nacht op. Onthoud dat Vercel Pro ($20/maand) cron-taken ondersteunt met een frequentie tot 1 minuut. Maar als je op het Hobby-plan bent, ben je beperkt tot dagelijkse crons, wat gewoon niet volstaat voor de meeste agent-gestuurde behoeften.
Vercel Function-configuratie
Agent-taken kunnen langer duren dan een zomerblockbuster (OK, niet echt), maar ze hebben meer dan de standaard 10 seconden nodig om uit te voeren. Configureer je route als volgt:
// app/api/agents/run/route.ts
export const maxDuration = 300; // 5 minuten op Pro-plan
export const dynamic = 'force-dynamic';
export async function GET(request: Request) {
// Verifieer cron-geheim om ongeautoriseerde toegang te voorkomen
const authHeader = request.headers.get('authorization');
if (authHeader !== `Bearer ${process.env.CRON_SECRET}`) {
return new Response('Unauthorized', { status: 401 });
}
// Agent-logica gaat hier
return Response.json({ success: true });
}
Dat maxDuration? Het is cruciaal. Tot 300 seconden op Pro, en 900 seconden als je in Enterprise-wateren zwemt. Een routine-taak die 5 minuten overschrijdt? Tijd om ze te segmenteren of je executiemodel te heroverwegen.
Supabase als het brein van je agent
Supabase--een machtsgebouw hier. Het fungeert als je taakwachtrij, state store, auditlog en je notifier voor real-time updates. Hier is het schema dat ik in de loop der tijd heb verfijnd:
-- Agent taakwachtrij
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()
);
-- Index voor de wachtrij polling-query
CREATE INDEX idx_agent_tasks_queue ON agent_tasks (
agent_type, status, priority DESC, scheduled_for
) WHERE status = 'pending';
-- Agent execution logs voor observability
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()
);
-- Agent state persistentie (voor multi-stap agents)
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)
);
Die locked_until kolom? Het is essentieel. Het imiteert een zelfgebouwde gedistribueerde vergrendeling. Dit betekent dat wanneer een cron-job een taak oppikt, het locked_until 5 minuten vooruit zet. Als het proces crasht, vervalt de vergrendeling en kan een ander proces het opnieuw proberen.
De taakophaalsquery
Het kronjuweel. Dit is je gouden kaartje om taken op te graaien zonder opnieuw verwerken:
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;
}
En de bijbehorende Postgres-functie:
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;
De FOR UPDATE SKIP LOCKED is de onbestemde held hier. Het zorgt ervoor dat geen twee gelijktijdige invocaties over elkaars voeten lopen. Vertrouw me, ontdekken en repareren van dubbele verwerking was niet grappig.
Cron-gebaseerde agent-orchestratie
Vercel Cron is de constante tromslag van deze hele operatie. Elke 15 minuten springt je agent runner in actie, grijpt taken, verwerkt ze en dutje dan tot volgende oproep.
Hier is hoe de volledige agent runner route eruitziet:
// 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);
}
Merk op de sequentiële verwerking per agent type, met een plafond van 5 taken per type per run. Dit helpt om functieuitvoeringstijden in bedwang te houden. Een stapel van 50 hangende taken? Spreid ze over verschillende cron-cycli. Geen haast, geen probleem.
Wanneer Cron niet genoeg is
Soms gaat het leven snel, en cron volstaat gewoon niet. In deze gevallen integreer ik cron met Supabase Database Webhooks of Edge Functions--ze worden geactiveerd door databasewijzigingen:
-- Trigger een edge function wanneer een hoog-prioriteitstask wordt aangemaakt
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;
Deze setup laat je mengen van voorspelbare cron-gebaseerde verwerking met snelle reactie voor urgente taken.
De agentlus bouwen
Hier gebeurt de magie. Een voorbeeldagent-implementatie met de tool-calling van 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,
};
}
Door maxSteps op 5 in te stellen kan het LLM tools aanroepen, resultaten evalueren en dienovereenkomstig verwerken--net zoals een klein werkertje aan het werk. De meeste contenttaken eindigen in 3–4 zulke oproepen.
Real-time agentbewaking met Supabase Realtime
Autonome agents zijn geweldig, maar erop toezien is van het grootste belang. Supabase Realtime drijft een dashboard aan dat real-time bijwerkt naarmate agents hun werk doen:
// 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(() => {
// Abonneer op taakwijzigingen
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();
// Abonneer op log stream
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);
};
}, []);
// Render je dashboard UI...
}
Dit levert een live stream van agent-activiteit. Normaal gesproken zou ik indicatoren, taakaantallen, foutfrequentievisualisaties en zelfs een "nu uitvoeren" knop voor testen toevoegen. Supabase Realtime is inbegrepen in de gratis tier--geen extra geld nodig.
Fouten en randgevallen afhandelen
Bereid je voor--iets zal ontploffen. API's zijn niet beschikbaar, rate limits slaan je in het gezicht, of services sturen gewoon onzin terug. Hier is wat ik heb geleerd over systemen die overleven.
Opnieuw proberen met exponentiële backoff
De attempts en max_attempts kolommen die we hebben opgenomen behandelen retries. Als een taak mislukt, hangt het in 'failed' status maar kan later handmatig of automatisch opnieuw proberen:
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,
// Exponentiële backoff: 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);
}
Circuit breakers voor externe API's
Wanneer externe API's wankelen, eten onmiddellijke retries retries snel op. Houd failurepercentages in Supabase bij, en je kunt agents stilleggen als dingen er ernstig uitzien:
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
}
Kostenanalyse en optimalisatie
Hier praten we eerlijk. Wat kost een productie agent app in 2026?
| Onderdeel | Gratis laag | Typische productie | Zwaar gebruik |
|---|---|---|---|
| Vercel Pro | - | €20/mnd | €20/mnd + gebruik |
| Supabase Pro | - | €25/mnd | €25/mnd + gebruik |
| OpenAI (GPT-4o-mini) | - | €30-80/mnd | €200+/mnd |
| Anthropic (Claude 3.5 Haiku) | - | €20-50/mnd | €150+/mnd |
| Totaal | ~€0 (dev) | €95-175/mnd | €395+/mnd |
Die LLM-kosten? Ze voeren de show. Hier is hoe je een deksel erop houdt:
- Gebruik waar mogelijk kleinere modellen. GPT-4o-mini en Claude 3.5 Haiku handelen de meeste taken af tegen een fractie van de kosten van hun grotere neven.
- Cache voordat je naar de API grijpt. Supabase kan LLM-reacties opslaan, wat het aantal nieuwe API-oproepen reduceert.
- Batch, batch, batch. In plaats van één API-oproep per taak, batch gelijkaardige taken en stuur ze samen.
- Token-limieten? Ja, graag. Stel altijd
maxTokensin tijdens je AI SDK-oproepen--voorkom wild genereren.
Productie-implementatiepatronen
Zodra je klaar bent voor implementatie, zijn verschillende dingen kritiek:
Gescheiden omgevingen. Maak gebruik van Supabase branching (Pro nodig) om afzonderlijke databases voor staging en productie in stand te houden. Koppel Vercel preview-implementaties met Supabase branches voor volledige isolatie.
Bewaking. De observability van Vercel biedt uitvoeringsgeschiedenis en functielogboeken van cron. Koppel dit aan een Supabase-gezondheidscontrole:
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;
Geheimen beheer. Bescherm je API-sleutels met Vercel-omgevingsvariabelen, hardcodeer ze nooit. Gebruik de service role key alleen server-zijdig met Supabase, terwijl de anon key aan client-zijdig blijft.
Als je hulp nodig hebt bij het opzetten van systemen als deze, heeft ons team meerdere agent-gestuurde applicaties geleverd met deze exacte stack. Bekijk onze headless CMS-ontwikkeling en Next.js-ontwikkelings mogelijkheden, of neem contact met ons op om over je project te praten.
Veelgestelde vragen
Kan Vercel Cron high-frequency agent-taken verwerken?
Vercel Cron kan intervallen zo kort als 1 minuut op het Pro-plan verwerken. De meeste agent-taken passen in cycli van 5-15 minuten. Sneller nodig? Overweeg Supabase Database Webhooks of schakel over naar Inngest voor event-driven acties.
Hoe voorkom ik dubbele taakverwerking met cron?
Dat is waar PostgreSQL's FOR UPDATE SKIP LOCKED in je taakophaalsquery schittert. Het is je vangnet zelfs als cron-timings overlappen, zodat elke taak uniek wordt opgeclaimed. locked_until voegt een laag veiligheid toe voor mid-execution rampen.
Is Supabase betrouwbaar voor productie agent workloads?
Absoluut. Supabase Pro draait op toegewezen Postgres-instanties met geautomatiseerde backups en een 99,9% uptime SLA. In feite is Postgres voor dit taakwachtrijsysteem meer dan gekwalificeerd--staat gelijktijdige toegang en complexe queries eenvoudig af.
Hoeveel kost het om AI-agenten in productie uit te voeren?
Normaal gesproken zal het verwerken van 5.000-10.000 taken per dag je €95-175/maand kosten (Vercel Pro + Supabase Pro) plus €30-80/maand voor LLM API-oproepen met modellen zoals GPT-4o-mini. De variabele laag is je LLM-kosten--afhankelijk van taakcomplexiteit en tokengebruik.
Moet ik LangChain of de Vercel AI SDK gebruiken voor agentlogica?
Tegen 2026 dekt Vercel's AI SDK (v4.x) de meeste agentbehoeften nuitgebreid--tool usage, multi-stap redenering, structured outputs en streaming. LangChain wordt nuttig wanneer je in geavanceerde chain-of-thought patronen, RAG-setups of gespecialiseerde tool-integraties duikt. Voor deze stack wint minder complexiteit met de AI SDK.
Kan ik Astro in plaats van Next.js gebruiken voor dit patroon?
Astro kan cron-geactiveerde API routes verwerken, maar je mist Vercel's optimalisaties, inclusief cron-config en langere timeouts. Als je dashboard content-zwaar voorkeur heeft, laag interactiviteit, Astro past de frontend. Stick met Next.js voor je agent backend.
Hoe bewijk ik agentprestaties en fouten?
Mengel drie lagen: Vercel's logs voor uitvoeringsniveau-inzicht, de agent_logs tabel in Supabase voor applicatie log-tracking en Supabase Realtime voor dynamische dashboard-bewaking. Stel gezondheidscontroles in voor fouten, uitvoeringstijden en wachtrijlengte. Vercel synchroniseert naadloos met waarschuwingsservices zoals PagerDuty en Slack.
Wat gebeurt er wanneer mijn agent-taken Vercel's functietimeout overschrijden?
Op Vercel Pro heb je een plafond van 300 seconden. Als taken hier vaak overheen gaan, overwegen deze in hapklare subtaken over cron-cycli. Verdeel bijvoorbeeld een contentproces in "fetch," "analyze," en "generate" taken. Of verken Supabase Edge Functions voor uitgebreide uitvoeringen--ze hebben een limiet van 150 seconden en kunnen op basis van nodig worden geactiveerd.