Kort antwoord: Program AI betekent dat je een agent bouwt die instructies omzet naar acties via tools, en de output in stukjes streamt zodat je UI en pipelines meteen doorlopen. Pak het praktisch aan: (1) definieer een agent en tools, (2) implementeer streaming, (3) voeg rate-limit en retries toe, (4) test tool schemas en guardrails, (5) deploy met tracing en observability.
1. Wat je precies programmeert bij “program ai”
“Program AI” is geen losse prompt. Het is software die een model orkestreert. In plaats van alleen tekst terug te krijgen, geef je het model een werkbaar systeem om te handelen:
- Agent: instructies, geheugen of context, regels, en beslislogica over wanneer tools wel of niet mogen.
- Tools: functies die echte acties doen, bijvoorbeeld web zoeken, database query, bestandsbewerking, of een interne API call.
- Orchestratie: modeloutput kan leiden tot meerdere tool calls in één run, inclusief tussenstappen.
- Streaming: output en events stromen terwijl de run gaande is, zodat je direct kunt renderen, loggen, of een UI kunt activeren.
Bij OpenAI Agents SDK draait het orkestreren vooral om een Runner die een agent runt en om streaming events die je UI of workflow direct kunt voeden. De SDK laat streaming expliciet aanzetten met een optie op de run, en je krijgt dan een stream van events in plaats van alleen een eindresultaat. (openai.github.io)
2. Minimale architecture: agent plus tools plus streaming
Als je weinig tijd hebt, start je met een minimale layout die je later uitbreidt. Houd drie lagen aan:
- Kernel: agent met instructies.
- Tooling: tool definitions met input schema en implementatie.
- Transport/UI: streaming consumer, event router, en fallback bij fouten.
2.1 Tool definities: maak het expliciet en schema-gedreven
Tools moeten een duidelijk contract hebben, anders krijg je onbetrouwbare tool arguments. In Agents SDK tooling zie je terug dat tools bestaan uit model-compatibele payloads en dat de SDK deze vertaalt naar de onderliggende Responses API tool schema’s. (openai.github.io)
Praktische regel:
- Maak tool inputs altijd zo klein mogelijk.
- Gebruik string enums of regex checks waar dat kan.
- Laat de agent geen verborgen parameters raden, geef ze altijd in de tool call input of in de context.
2.2 Streaming: events consumeren in plaats van wachten
Voor streaming maak je bij een run een stream aan en consumeer je events. Bij OpenAI Responses API wordt streaming aangezet met stream: true, waarna de server server-sent events uitzendt. (platform.openai.com)
In Agents SDK zie je dat streaming meerdere eventtypes kan uitsturen, zoals events voor output tekstdelta’s. (openai.github.io)
2.3 Code: minimale agent-run met streaming
Onderstaand is een conceptuele start in JavaScript/TypeScript-stijl (de exacte imports kunnen per SDK versie verschillen). Het punt is: stream aanzetten, events lezen, en tekst renderen zodra deltas binnenkomen.
import { Agent, run } from '@openai/agents';
const agent = new Agent({
name: 'ProgramAI-Example',
instructions: 'Je bent een assistent die een tool kan aanroepen als dat nodig is.'
});
async function main() {
const stream = await run(agent, 'Vat dit samen en haal relevante feiten uit de tool.', {
stream: true,
});
for await (const event of stream) {
if (event.type === 'response.output_text.delta') {
process.stdout.write(event.delta);
}
}
}
main();
De eventtype-naam response.output_text.delta komt terug in Agents SDK streaming documentatie als voorbeeld van tekstdelta’s. (openai.github.io)
3. Van “agent” naar nuttige acties: tools, approvals, en state
Een agent is pas nuttig als hij de juiste tools op het juiste moment gebruikt. Dit is waar “program ai” echt engineering wordt.
3.1 Tools als eerste klas: ontwerp tool flows
Typische toolflow voor technische taken:
- Agent identificeert intentie en benodigde data.
- Agent roept 1 of meerdere tools aan, mogelijk in volgorde.
- Agent maakt eindoutput, inclusief bronverwijzingen of samenvatting.
Bij grotere systemen wil je tool calls kunnen debuggen. Agents SDK beschrijft dat streaming events ook nested run events terug kunnen streamen bij agent-as-tool patronen, zodat je één run beter kunt traceren. (openai.github.io)
3.2 Human-in-the-loop: approvals waar nodig
In veel productiecases moet je voorkomen dat een model direct file writes, betaling, of productie deploys doet. Het alternatief is een approval stap, zodat de gebruiker of een policy eerst bekijkt.
Agents SDK streaming beschrijft dat er interrupties en approvals kunnen bestaan, en dat approvals in de RunResultStreaming worden blootgelegd als dat nodig is. (openai.github.io)
Praktijktip:
- Laat alleen kritieke tools approval vereisen.
- Laat niet-kritieke tools direct uitvoeren, dan blijft je flow snel.
3.3 State: houd de run consistent
Je kunt conversation history op verschillende manieren beheren. In agents SDK draait het om de run context en hoe je het systeem laat weten welke gegevens relevant zijn voor de huidige stap. Als je state niet netjes beheert, krijg je “tool drift”: de agent roept tools aan met argumenten die bij eerdere turns hoorden.
Praktisch minimum:
- Snijd inputs af tot wat nodig is.
- Maak state expliciet in je eigen code, bijvoorbeeld als JSON object dat je in elke run meegeeft.
- Log de uiteindelijke tool arguments, niet alleen de agenttekst.
3.4 Snelle interne links voor bouwpatronen
Als je al richting agents en productie gaat, kun je de volgende artikelen als technische referentie gebruiken:
- AI blog site bouwen: stack, agents, streaming, SEO
- AI automatisering: van agent tot productie in praktijk
- AI web: bouw en host je AI-agent met streaming en tools
- A AI: technische gids voor agents, tools en streaming
4. Rate limits en fouten: maak je systeem “run-safe”
Als je “program ai” serieus neemt, behandel je degradatie als feature. Je wil dat je agent blijft werken als je API een 429 of transient error teruggeeft.
4.1 429 is normaal: plan voor backoff en retries
OpenAI’s help center benoemt dat 429 fouten ontstaan door request bursts of verkeerde keuzes, en adviseert om bursts te verminderen en een juiste next step te kiezen. Ook wordt genoemd dat officiële SDK’s rate-limit errors kunnen retry’en en Retry-After kunnen honoreren. (help.openai.com)
Praktische implementatieregels:
- Gebruik exponential backoff met jitter.
- Respecteer Retry-After als je die krijgt.
- Beperk parallelism voor tool calls waar dat nodig is.
- Als je queue gebruikt, voeg een dedupe key toe per “run intent”.
4.2 Voorbeeld: eenvoudige retry wrapper
async function withRetry(fn, { maxAttempts = 5, baseMs = 300 } = {}) {
let attempt = 0;
while (true) {
attempt++;
try {
return await fn();
} catch (e) {
const status = e?.status ?? e?.response?.status;
const retryAfter = e?.headers?.get?.('Retry-After');
const isRetryable = status === 429 || status === 500 || status === 502 || status === 503;
if (!isRetryable || attempt >= maxAttempts) throw e;
const waitMs = retryAfter
? Number(retryAfter) * 1000
: baseMs * (2 ** (attempt - 1)) + Math.floor(Math.random() * 100);
await new Promise(r => setTimeout(r, waitMs));
}
}
}
Dit is geen OpenAI-specifiek protocol, maar de kern is wel consistent met de 429 aanpak uit de help center richtlijnen: minder bursts en retry met juiste timing. (help.openai.com)
4.3 Observability: log tool calls en event progress
Als je streaming gebruikt, wil je niet alleen de eindtekst loggen. Log minstens:
- Run id of correlatie-id
- Welke tools zijn aangeroepen
- Tool arguments (gesaneerd)
- Welke eventtypes je zag (voor debugging van UX)
5. Voorbeeld-eerst: bouw een tool-gedreven agent in kleine stappen
Je wil dat het werkt voordat je het “mooi” maakt. Daarom een stappenplan met concrete output-mijlpalen.
Stap 1: kies één tool en maak hem deterministisch
Voorbeeld tool: get_docs(query) die een interne knowledge base query doet, of een simpele HTTP GET naar een interne endpoint.
- Tool input:
{ query: string } - Tool output:
{ snippets: Array<{title: string, text: string}> }
Let op: maak de tool output stabiel in vorm. Dan kan je agent er later gemakkelijker structuur van maken.
Stap 2: agent instructie die tool-calls “concreet” maakt
Schrijf instructies als regels, niet als poëtische tekst. Voorbeeld:
- “Roep
get_docsaan als de vraag feiten of beleid vereist.” - “Gebruik minimaal 2 snippets als bron voor een samenvatting.”
- “Als de tool geen relevante snippets geeft, zeg dat je geen data vond.”
Stap 3: streaming UX, minimaal werkend
Doel: je UI geeft tekst zodra die binnenkomt. Bij Agents SDK of Responses streaming krijg je events terwijl de run loopt. (openai.github.io)
Wat je doet in code:
- Bij tekstdelta: append naar response buffer
- Bij tool event: zet een statusregel in je UI (“tool zoekt docs”)
- Bij fout: toon foutstate en laat retry toe
Stap 4: voeg structured output toe, alleen waar het nodig is
Een veelgemaakte fout is alles JSON willen. Doe structured output voor stukken waar je het echt nodig hebt, bijvoorbeeld:
- planning stappenlijst
- filtervoorwaarden voor een zoekquery
- samenvatting velden (titel, bullets, risico)
De rest mag vrije tekst blijven. Dat maakt itereren sneller.
Stap 5: harden tegen “tool drift”
Test met tegenvoorbeelden:
- Vage vraag, “hallucinatie”-risico
- Onvolledige input, ontbrekende context
- Tool returns empty
Pas instructies en tool policies aan. Als je tool output empty teruggeeft, moet de agent een duidelijke fallback doen.
Handige “verkennings” links voor jou als je al doorbouwt
- Chai chat met AI friends: setup, tools en veiligheid
- Open AI online: API, chat en agents, snel starten
- AI Market: zo denk je technisch, bouw je snel en veilig
- OpenAI AI: praktische gids voor API, agents en tools
- Chat AI Open: werkende setup, tools, streaming en agents
- elementsofai: bouwbare AI agent-onderdelen (praktisch)
6. Checklist voor productie: wat je vóór deploy wil hebben
Dit is je laatste korte gate. Als iets ontbreekt, ga niet live.
6.1 Kwaliteit en veiligheid
- Tool input validatie: server-side checks op schema, lengte, en allowed values.
- Tool output sanitization: beperk wat de agent ziet, filter PII of secrets.
- Approval policy: kritieke tools vereisen human-in-the-loop of een policy gate.
- Prompt injection defense: scheid user content van system instructions, en treat tool outputs als data, niet als instructies.
6.2 Reliability
- Retry en backoff op 429 en transient errors. (help.openai.com)
- Timeouts voor tools en upstream API calls.
- Circuit breaker als één tool faalt, zodat je agent niet eindeloos blijft proberen.
- Idempotency voor tools die bij herhaalde calls effecten kunnen hebben.
6.3 Streaming gedrag
- UI buffers: tekstdelta’s append, geen flicker.
- Event logging: log eventprogress, zodat je debugging sneller maakt.
- Fallback: als streaming faalt, stuur een niet-streaming response of toon status met retry.
Streaming is expliciet beschikbaar via stream: true en levert dan streaming events op. (platform.openai.com)
Conclusie
Program AI komt neer op dit: je programmeert een agent die tools gebruikt, niet alleen taal produceert. De kernstappen zijn simpel, maar je moet ze technisch hard maken: definieer tools met strakke schemas, orkestreer tool calls via een agent-run, en zet streaming aan zodat je UI en logging niet wachten tot het einde. Voor productie is je grootste winst betrouwbaarheid: 429 en transient errors afvangen met retry en backoff, plus observability op tool arguments en eventprogress. (help.openai.com)
Als je snel wil doorpakken: begin met één tool, voeg streaming toe, log alles, en pas daarna schaal je naar meerdere tools en approval gates. Zo voorkom je dat je debugging doet op een te groot systeem.
