Dit is een machinevertaling van het originele Engelstalige document. In het geval van een conflict tussen deze vertaling en de originele Engelse versie, is de Engelse versie doorslaggevend. Lees de originele Engelse versie

Openbare API

Caiioo bevat een REST API waarmee je alles programmatisch kunt aansturen: agents uitvoeren, tools beheren, taken plannen en meer. De API bevindt zich op dezelfde lokale server die de desktop-app en browser-bridge aanstuurt.

Basis-URL: http://localhost:3847/v1

Authenticatie: Twee manieren om te authenticeren, beide beveiligd door de API-schakelaar in de instellingen:

Voor externe gebruikers (scripts, integraties, curl): Stel een API-toegangstoken in via Instellingen > API-toegang en gebruik dit vervolgens als een Bearer-token:

curl -H "Authorization: Bearer JOUW_API_TOKEN" http://localhost:3847/v1/providers

Voor de lokale app (automatisch): De Caiioo desktop-app, browserextensies en mobiele apps authenticeren automatisch via de bestaande relay-auth-header (X-Relay-Auth). Geen handmatige configuratie nodig — de app regelt dit achter de schermen.

Configuratie:

  1. Open Caiioo Instellingen > API-toegang
  2. Zet Openbare API inschakelen aan
  3. Stel een API-toegangstoken in (elke gewenste reeks — behandel het als een wachtwoord)
  4. Gebruik dat token in alle API-verzoeken

De API is beschikbaar op localhost en via de privé-relay. Controleer GET /v1/auth/info (geen authenticatie vereist) voor de huidige status en installatie-instructies.

Providers & Modellen

Ontdek welke LLM-providers zijn geconfigureerd en welke modellen beschikbaar zijn.

Lijst met providers:

GET /v1/providers

Retourneert alle geconfigureerde providertypes (Anthropic, OpenAI, Google, OpenRouter, Ollama, Poe, MLX, Baseten, en andere zodra ze worden toegevoegd) met functie-vlaggen (supportsVision, supportsToolCalling, supportsStreaming, etc.) en of er een API-sleutel is geconfigureerd.

Lijst met modellen voor een provider:

GET /v1/providers/anthropic/models

Retourneert de modellencatalogus voor die provider. Elk model bevat id, displayName en contextLength indien beschikbaar.

Platte catalogus over alle providers:

GET /v1/models

Voegt modellen van elke geconfigureerde provider samen in één lijst. Providers zonder API-sleutels worden overgeslagen en vermeld in warnings.

Agents

Agents vormen de kern van caiioo. Elke agent is een Modus — een geconfigureerde persoonlijkheid met een eigen systeemprompt, tools, variabelen en vaardigheden.

Lijst van alle agents:

GET /v1/agents

Retourneert ingebouwde agents (Winkelen, Werkplek, Algemeen) en alle aangepaste agents die je hebt gemaakt. Elk is gelabeld met source: \"builtin\" of source: \"custom\".

Een aangepaste agent maken:

POST /v1/agents
Content-Type: application/json

{
  \"id\": \"mijn-onderzoeks-agent\",
  \"branding\": {
    \"name\": \"Onderzoeks-agent\",
    \"description\": \"Doorzoekt het web en vat bevindingen samen\"
  },
  \"defaultSettings\": {
    \"systemPrompt\": \"Je bent een onderzoeksassistent. Citeer altijd bronnen.\",
    \"enabledTools\": { \"web_browsing\": true, \"search_tools\": true }
  },
  \"settingLevels\": {}
}

Retourneert 201 met de gemaakte agent. Een vector-klok wordt automatisch toegevoegd voor synchronisatie.

Een agent bijwerken:

PATCH /v1/agents/mijn-onderzoeks-agent
Content-Type: application/json

{ \"branding\": { \"name\": \"Onderzoeks-agent\", \"description\": \"Bijgewerkte beschrijving\" } }

Voegt de patch samen met de bestaande agent en verhoogt de vector-klok. Ingebouwde agents retourneren 403 — deze zijn alleen-lezen.

Een agent verwijderen:

DELETE /v1/agents/mijn-onderzoeks-agent

Verwijdert via een 'tombstone' (synchroniseert over apparaten). Retourneert 204.

Agents uitvoeren

Dit is waar het om draait — roep een agent aan om een bericht te verwerken.

Synchrone Modus

Wacht op de volledige reactie:

POST /v1/runs
Content-Type: application/json

{
  \"agentId\": \"general\",
  \"input\": { \"message\": \"Wat is het weer in Parijs vandaag?\" },
  \"mode\": \"sync\"
}

Retourneert 200 met { content, usage, status: \"completed\" } nadat de agent klaar is. Als de agent een fout geeft, retourneert dit 500 met { error, status: \"error\" }.

Asynchrone Modus

Verstuur en vergeet — handig voor langdurige taken:

POST /v1/runs
Content-Type: application/json

{
  \"agentId\": \"mijn-onderzoeks-agent\",
  \"input\": { \"message\": \"Schrijf een analyse van 2000 woorden over trends in hernieuwbare energie\" },
  \"mode\": \"async\"
}

Retourneert direct 202 met { runId, threadId, status: \"running\" }.

Status opvragen:

GET /v1/runs/{runId}

Retourneert { run: { runId, threadId, agentId, status, createdAt, content?, usage?, error? } }. Status is running, completed, error of cancelled.

Events in realtime streamen (SSE):

GET /v1/runs/{runId}/events

Retourneert een text/event-stream met elk agent-event terwijl het gebeurt: GENERATION_STARTED, STREAMING_CONTENT, tool-aanroepen, subagent-activiteit en het eind-event (GENERATION_COMPLETE, GENERATION_ERROR of GENERATION_CANCELLED). De stream stopt na het eind-event.

Een uitvoering annuleren:

POST /v1/runs/{runId}/cancel

Retourneert { run: { ..., status: \"cancelled\" } }.

Threads

Threads zijn conversaties. Elke agent run vindt plaats binnen een thread, en threads blijven behouden over verschillende sessies. De API stelt u in staat om threads programmatisch op te lijsten, te lezen, aan te maken en te beheren.

Lijst alle threads op (alleen metadata):

GET /v1/threads

Retourneert threads voor het huidige profiel waarbij berichten zijn weggelaten voor betere prestaties. Elke thread bevat id, title, createdAt, updatedAt, modeId, archived, en gebruiksstatistieken.

Haal een thread op met volledige berichten:

GET /v1/threads/{id}

Retourneert de volledige thread inclusief de messages array — elk gebruikersbericht, assistant-antwoord, tool call en tool resultaat.

Haal alleen de berichten op:

GET /v1/threads/{id}/messages

Retourneert alleen de messages array — lichter dan het volledige thread-object wanneer u alleen de conversatie nodig heeft.

Maak een thread aan:

POST /v1/threads
Content-Type: application/json

{ "title": "Research project", "modeId": "general" }

Retourneert 201 met de nieuwe thread. Standaard schakelt de API de actieve thread van de app NIET om — geef "setActive": true mee in de body als u dat wel wilt. De nieuwe thread verschijnt onmiddellijk in de zijbalk (via WebSocket broadcast).

Update een thread:

PATCH /v1/threads/{id}
Content-Type: application/json

{ "title": "Renamed project", "archived": true }

Bij te werken velden: title, modeId, archived, lastUsedModel. Wijzigingen worden in real-time naar de zijbalk gepusht.

Verwijder een thread:

DELETE /v1/threads/{id}

Verwijdert de thread via een soft-delete (tombstone voor synchronisatie). Retourneert 204. Verwijderde threads worden verplaatst naar de prullenbak en kunnen worden hersteld totdat de prullenbak wordt geleegd.

Actieve thread:

GET /v1/threads/active            # Retourneert { threadId }
PUT /v1/threads/active            # Body: { "threadId": "..." }

Prullenbakbeheer:

GET /v1/threads/trash/count       # Retourneert { count }
POST /v1/threads/trash/empty      # Retourneert { deletedCount, protectedCount }

Beveiligde threads (bewaard via de data retention toggle) worden uitgesloten bij het legen van de prullenbak.

Een conversatie voortzetten via de API: Om een vervolgbericht naar een bestaande thread te sturen, gebruikt u POST /v1/runs met het ID van de thread:

POST /v1/runs
Content-Type: application/json

{
  "agentId": "general",
  "threadId": "existing-thread-id",
  "input": { "message": "Follow up on that last point" },
  "mode": "sync"
}

De agent ziet de volledige conversatiegeschiedenis van de thread.

Bijlagen

Bijlagen zijn bestanden die aan threads zijn gekoppeld — screenshots, PDF's, documenten, geüploade afbeeldingen, gegenereerde artefacten. Met de API kun je ze weergeven, uploaden, downloaden en beheren.

Lijst van alle bijlagen (alleen metadata):

GET /v1/attachments

Retourneert metadata van bijlagen voor het huidige profiel. Zware velden (dataUrl, extractedContent, extractedImages) zijn weggelaten — gebruik de detail- of content-endpoints hiervoor.

Lijst van bijlagen voor een specifieke thread:

GET /v1/threads/{threadId}/attachments

Metadata van bijlage ophalen:

GET /v1/attachments/{id}

Retourneert volledige metadata inclusief extractedContent (OCR-tekst, geparseerde markdown), contentType, fileName, size en een hasContent vlag. Het ruwe binaire bestand is NIET inbegrepen — gebruik daarvoor het /content endpoint.

Binair bestand van bijlage downloaden:

GET /v1/attachments/{id}/content

Retourneert het ruwe bestand met de juiste Content-Type en Content-Disposition headers. Sluis dit door naar een bestand:

curl -o output.pdf \
  -H "Authorization: Bearer $API_TOKEN" \
  http://localhost:3847/v1/attachments/{id}/content

Een bijlage uploaden:

POST /v1/attachments
Content-Type: application/json

{
  "threadId": "thread-id",
  "type": "user_upload",
  "contentType": "application/pdf",
  "fileName": "report.pdf",
  "description": "Kwartaalrapport",
  "dataUrl": "data:application/pdf;base64,JVBERi0xLjQ..."
}

De dataUrl is een base64-gecodeerde data-URL. Retourneert 201 met het nieuwe bijlage-ID. De bijlage wordt gekoppeld aan de opgegeven thread.

Metadata van bijlage bijwerken:

PATCH /v1/attachments/{id}
Content-Type: application/json

{ "description": "Bijgewerkte beschrijving", "fileName": "nieuwe-naam.pdf" }

Een bijlage verwijderen:

DELETE /v1/attachments/{id}

Zachte verwijdering via tombstone. Retourneert 204.

MCP Servers

Beheer uw MCP (Model Context Protocol) serververbindingen — de servers die agents toegang geven tot externe tools en databronnen.

Lijst van geconfigureerde servers:

GET /v1/mcp-servers

Retourneert alle MCP server-configuraties voor het huidige profiel. Gevoelige velden (authToken, env, credentialId) worden uit het antwoord verwijderd.

Configuratie van een server ophalen:

GET /v1/mcp-servers/{id}

Een nieuwe MCP server toevoegen:

POST /v1/mcp-servers
Content-Type: application/json

{
  "id": "my-server",
  "name": "My MCP Server",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/files"],
  "serverType": "local"
}

Gebruik voor externe HTTP-servers "url" in plaats van "command":

{
  "id": "remote-server",
  "name": "Remote API",
  "url": "https://my-mcp-server.example.com/sse",
  "serverType": "remote"
}

Een server bijwerken:

PATCH /v1/mcp-servers/{id}
Content-Type: application/json

{ "name": "Renamed Server", "args": ["-y", "@mcp/server-v2"] }

Een server in- of uitschakelen:

POST /v1/mcp-servers/{id}/toggle
Content-Type: application/json

{ "enabled": false }

Een server verwijderen:

DELETE /v1/mcp-servers/{id}

Procesbeheer

Voor lokale (stdio) MCP servers kunt u het serverproces rechtstreeks beheren.

Lijst van actieve processen:

GET /v1/mcp-servers/processes

Retourneert actieve serverprocessen met pid, startedAt, en running status.

Een server starten:

POST /v1/mcp-servers/{id}/start

Leest de command/args/env uit de serverconfiguratie en start het proces. Retourneert de processtatus.

Een server stoppen:

POST /v1/mcp-servers/{id}/stop

Sluit het serverproces netjes af (SIGTERM met terugval naar SIGKILL).

Rechtstreeks een JSON-RPC methode aanroepen:

POST /v1/mcp-servers/{id}/call
Content-Type: application/json

{ "method": "tools/list", "params": {} }

Verstuurt een onbewerkt JSON-RPC 2.0 verzoek naar de server en retourneert het resultaat. Handig voor debugging of het aanroepen van methoden die niet via de tools API beschikbaar zijn.

Tools & Toolkits

Bekijk en roep de tools aan die agents gebruiken — webbrowsen, zoeken, agenda, Gmail, Slate en meer.

Lijst met toolkits (gegroepeerd):

GET /v1/toolkits

Retourneert ingebouwde tools gegroepeerd per categorie (Productiviteit, Zoeken, Hulpprogramma's, etc.) en alle verbonden MCP-servers als afzonderlijke toolkits, elk met hun acties.

Lijst met alle tools (plat):

GET /v1/tools
GET /v1/tools?source=embedded   # Alleen ingebouwde tools
GET /v1/tools?source=mcp        # Alleen MCP-server tools

Tooldetails ophalen met invoerschema:

GET /v1/tools/calculator

Retourneert het JSON-schema van de tool voor de invoerparameters, zodat je kunt valideren voor het aanroepen.

Een tool direct aanroepen:

POST /v1/tools/calculator/invoke
Content-Type: application/json

{ \"input\": { \"expression\": \"sqrt(144) + 3^2\" } }

Retourneert { result }. Invoer wordt gevalideerd tegen het schema van de tool — ongeldige invoer retourneert 422 met details. Externe MCP-tools retourneren 501 met het advies om in plaats daarvan /v1/runs te gebruiken (ze vereisen het transport van het agent-subproces).

Connectoren

Beheer OAuth-integraties — Google, Microsoft, GitHub, Notion, Slack en meer.

Beschikbare integraties bekijken:

GET /v1/connectors/catalog

Retourneert alle geregistreerde OAuth-providers met hun naam, categorie en standaard scopes.

Lijst van je verbonden accounts:

GET /v1/connectors

Retourneert actieve verbindingen voor het huidige profiel. Tokens worden nooit getoond — alleen metadata (provider, e-mail, status, scopes, tijdstempels).

Verbindingsstatus controleren:

POST /v1/connectors/{id}/test

Retourneert { health: { status, isTokenExpired, canRefresh } }.

Een verbinding verwijderen:

DELETE /v1/connectors/{id}

Het maken van nieuwe verbindingen vereist de interactieve OAuth-flow via de app-UI of de /auth/* routes.

Triggers

Plan agents om automatisch uit te voeren — dagelijkse briefings, wekelijkse rapporten, monitoring op basis van intervallen.

Lijst met triggers:

GET /v1/triggers

Een geplande trigger maken:

POST /v1/triggers
Content-Type: application/json

{
  \"name\": \"Ochtendbriefing\",
  \"prompt\": \"Vat mijn ongelezen e-mails en de agenda van vandaag samen\",
  \"modeId\": \"general\",
  \"schedule\": { \"type\": \"daily\", \"time\": \"08:00\" }
}

Ondersteunde planningstypes:

  • { \"type\": \"interval\", \"minutes\": 60 } — elke N minuten (min 15, max 1440)
  • { \"type\": \"daily\", \"time\": \"09:00\" } — dagelijks op een specifiek tijdstip
  • { \"type\": \"weekly\", \"day\": \"mon\", \"time\": \"09:00\" } — wekelijks
  • { \"type\": \"weekdays\", \"time\": \"08:30\" } — maandag tot en met vrijdag
  • { \"type\": \"daysOfWeek\", \"days\": [\"mon\", \"wed\", \"fri\"], \"time\": \"10:00\" } — specifieke dagen
  • { \"type\": \"monthly\", \"dayOfMonth\": 1, \"time\": \"09:00\" } — maandelijks
  • { \"type\": \"manual\" } — alleen bij handmatige aanroep via API

Een trigger handmatig activeren:

POST /v1/triggers/{id}/fire

Retourneert 202 met een threadId voor de resulterende uitvoering.

Bijwerken of verwijderen:

PATCH /v1/triggers/{id}
DELETE /v1/triggers/{id}

Webhooks

Webhook-triggers laten externe diensten (CI/CD, monitoring, formulierbouwers) een agent-uitvoering triggeren via HTTP.

Een webhook-trigger maken:

POST /v1/triggers
Content-Type: application/json

{
  \"name\": \"Deploy hook\",
  \"prompt\": \"Er heeft een deploy plaatsgevonden: {{webhook.body}}\",
  \"modeId\": \"general\",
  \"kind\": \"webhook\"
}

Retourneert 201 met een webhookSecret and webhookPath. Bewaar het geheim — je hebt het nodig om payloads te ondertekenen.

Een webhook verzenden:

# Bereken HMAC-SHA256 van de ruwe request body
SIGNATURE=$(echo -n '{\"repo\":\"my-app\",\"branch\":\"main\"}' | openssl dgst -sha256 -hmac \"$WEBHOOK_SECRET\" | awk '{print $2}')

POST /v1/webhooks/{triggerId}
Content-Type: application/json
X-Webhook-Signature: $SIGNATURE

{\"repo\": \"my-app\", \"branch\": \"main\"}

Het webhook-eindpunt vereist GEEN bearer-auth — het gebruikt in plaats daarvan HMAC-verificatie. Retourneert 202 met de threadId van de verzonden uitvoering. De {{webhook.body}} placeholder in de trigger-prompt wordt vervangen door de ruwe request body.

Aangepaste functies

Maak je eigen tools die agents kunnen aanroepen. Functies worden geschreven in JavaScript of Python en uitgevoerd in een sandbox.

Lijst met functies:

GET /v1/functions

Een functie maken:

POST /v1/functions
Content-Type: application/json

{
  \"name\": \"bereken_bmi\",
  \"description\": \"Bereken Body Mass Index op basis van lengte en gewicht\",
  \"language\": \"javascript\",
  \"source\": \"return { bmi: (input.weightKg / (input.heightM * input.heightM)).toFixed(1) };\",
  \"inputSchema\": {
    \"type\": \"object\",
    \"properties\": {
      \"weightKg\": { \"type\": \"number\" },
      \"heightM\": { \"type\": \"number\" }
    },
    \"required\": [\"weightKg\", \"heightM\"]
  }
}

JavaScript-functies ontvangen input en moeten een resultaat retourneren. Python-functies stellen een result variabele in:

# Python voorbeeld
result = {\"bmi\": round(input[\"weightKg\"] / (input[\"heightM\"] ** 2), 1)}

Een functie direct uitvoeren:

POST /v1/functions/{id}/execute
Content-Type: application/json

{ \"input\": { \"weightKg\": 75, \"heightM\": 1.80 } }

Beveiliging: JavaScript draait in de vm sandbox van Node (geen toegang tot bestandssysteem of netwerk, 10s timeout). Python draait als een subproces met een 30s timeout. Beiden valideren invoer voor uitvoering.

Bijwerken of verwijderen:

PATCH /v1/functions/{id}
DELETE /v1/functions/{id}

Workflows

Orkestreer meerdere agents in een DAG (directed acyclic graph) — voer stappen waar mogelijk parallel uit en gebruik de output van eerdere stappen in latere stappen.

Valideer een workflow-grafiek:

POST /v1/workflows/validate
Content-Type: application/json

{
  "graph": {
    "nodes": [
      { "id": "research", "agentId": "general", "prompt": "Onderzoek trends in hernieuwbare energie" },
      { "id": "analyze", "agentId": "general", "prompt": "Onderzoek prijzen van concurrenten" },
      { "id": "report", "agentId": "general", "prompt": "Schrijf een rapport dat het volgende combineert: {{outputs.research}} en {{outputs.analyze}}", "dependsOn": ["research", "analyze"] }
    ]
  }
}

Retourneert { valid: true/false, errors: [...] }. Controleert op cycli, dubbele ID's en ontbrekende afhankelijkheidsverwijzingen.

Voer een workflow uit:

POST /v1/workflows/execute
Content-Type: application/json

{
  "graph": {
    "nodes": [
      { "id": "research", "agentId": "general", "prompt": "Onderzoek trends in hernieuwbare energie" },
      { "id": "summarize", "agentId": "general", "prompt": "Vat samen: {{outputs.research}}", "dependsOn": ["research"] }
    ]
  }
}

Retourneert { status: "completed", outputs: { research: "...", summarize: "..." }, nodeResults: {...} }.

Onafhankelijke nodes (zonder gedeelde afhankelijkheden) worden parallel uitgevoerd. De placeholder {{outputs.nodeId}} in de prompt van een node wordt vervangen door de inhoudelijke output van de genoemde upstream node. Elke node is een volledige agent-run, dus deze kan tools gebruiken, op het web surfen en toegang krijgen tot alle mogelijkheden van de doel-agent.

Kennisbanken

Organiseer documenten in doorzoekbare collecties waar agents naar kunnen verwijzen.

Lijst met kennisbanken:

GET /v1/knowledge/bases

Een kennisbank maken:

POST /v1/knowledge/bases
Content-Type: application/json

{ \"name\": \"Onderzoeksartikelen\" }

Retourneert 201 met het nieuwe base-ID.

Een document uploaden naar een kennisbank:

POST /v1/knowledge/bases/{id}/documents
Content-Type: application/json

{
  \"fileName\": \"onderzoeksartikel.pdf\",
  \"contentType\": \"application/pdf\",
  \"dataUrl\": \"data:application/pdf;base64,JVBERi0xLjQ...\",
  \"description\": \"Trends in hernieuwbare energie 2026\"
}

Het veld dataUrl is een base64-gecodeerde data-URL. Retourneert 201 met de document-metadata.

Lijst met documenten in een kennisbank:

GET /v1/knowledge/bases/{id}/documents

Zoeken binnen een kennisbank:

POST /v1/knowledge/bases/{id}/search
Content-Type: application/json

{ \"query\": \"hernieuwbare energie\" }

Retourneert overeenkomende documenten op basis van bestandsnaam en beschrijving. Semantisch (vector) zoeken volgt in een toekomstige release.

Een document of kennisbank verwijderen:

DELETE /v1/knowledge/bases/{id}/documents/{docId}
DELETE /v1/knowledge/bases/{id}

Agents exporteren & importeren

Deel agents als draagbare pakketten — over apparaten, teams of de Community Hub.

Een agent exporteren:

POST /v1/agents/{id}/export

Retourneert een JSON-pakket met de agent-definitie, tool-vereisten (afgeleid van ingeschakelde tools), connector-vereisten (welke OAuth-providers nodig zijn) en trigger-sjablonen. Synchronisatie-metadata wordt verwijderd — het pakket is een schone, op zichzelf staande blauwdruk.

Een agent importeren:

POST /v1/agents/import
Content-Type: application/json

{
  \"package\": {
    \"$schema\": \"caiioo.agent.package/v1\",
    \"agent\": {
      \"id\": \"gedeelde-onderzoeks-agent\",
      \"branding\": { \"name\": \"Onderzoeks-agent\", \"description\": \"Van het team\" },
      \"defaultSettings\": { \"systemPrompt\": \"Je onderzoekt dingen.\" },
      \"settingLevels\": {}
    },
    \"toolRequirements\": [
      { \"toolId\": \"web_browsing\", \"enabled\": true },
      { \"toolId\": \"search_tools\", \"enabled\": true }
    ]
  }
}

Retourneert 201 met de geïnstalleerde agent. ID-conflicten met ingebouwde of bestaande agents retourneren 409.

Foutafhandeling

De API gebruikt standaard HTTP-statuscodes:

Code Betekenis
200 Succes
201 Gemaakt
202 Geaccepteerd (asynchrone bewerking gestart)
204 Verwijderd (geen inhoud)
400 Slecht verzoek — controleer het veld error voor details
401 Niet geautoriseerd — ontbrekend of ongeldig sessiegeheim
403 Verboden — bijv. proberen een ingebouwde agent te wijzigen
404 Niet gevonden
409 Conflict — bijv. agent-ID bestaat al
422 Validatiefout — invoer komt niet overeen met tool-schema
500 Serverfout — controleer het veld error
501 Niet geïmplementeerd — functie bestaat maar is niet op deze manier beschikbaar
503 Dienst niet beschikbaar — opslag of provider niet gereed

Alle foutreacties bevatten { \"error\": \"menselijk leesbaar bericht\" }.

Snelstart-voorbeeld

Hier is een complete workflow: maak een agent, voer deze uit en stream de resultaten.

# 1. Maak een aangepaste agent
curl -X POST http://localhost:3847/v1/agents \\
  -H \"Authorization: Bearer $API_TOKEN\" \\
  -H \"Content-Type: application/json\" \\
  -d '{
    \"id\": \"snelle-samenvatter\",
    \"branding\": { \"name\": \"Snelle samenvatter\" },
    \"defaultSettings\": {
      \"systemPrompt\": \"Vat elke invoer beknopt samen in 3 opsommingstekens.\",
      \"enabledTools\": { \"web_browsing\": true }
    },
    \"settingLevels\": {}
  }'

# 2. Voer het asynchroon uit
RUN=$(curl -s -X POST http://localhost:3847/v1/runs \\
  -H \"Authorization: Bearer $API_TOKEN\" \\
  -H \"Content-Type: application/json\" \\
  -d '{ \"agentId\": \"snelle-samenvatter\", \"input\": { \"message\": \"Vat https://nl.wikipedia.org/wiki/Kunstmatige_intelligentie samen\" }, \"mode\": \"async\" }')

RUN_ID=$(echo $RUN | jq -r '.runId')

# 3. Stream de events
curl -N http://localhost:3847/v1/runs/$RUN_ID/events \\
  -H \"Authorization: Bearer $API_TOKEN\"

# 4. Exporteer de agent om te delen
curl -X POST http://localhost:3847/v1/agents/snelle-samenvatter/export \\
  -H \"Authorization: Bearer $API_TOKEN\"

This guide is maintained by the Caiioo team using Slate, our built-in editor.