AI-afbeeldinggeneratie

De inhoud is gebaseerd op mijn eigen experimenten waarbij ik diverse aanbieders vanuit Python heb aangeroepen. Ik heb pixel art sprites, fotorealistische achtergronden van kaarttafels en een serie restaurantposters gegenereerd, waarbij ik probeerde een resultaat te bereiken dat er niet uitziet alsof het door AI is gemaakt. Elke afbeelding in deze gids is voortgekomen uit deze experimenten.

Samenvatting (TLDR)

• Werking: De meeste modellen beginnen met ruis en "poetsen" dit op. Tekst stuurt dit proces aan. Nieuwere modellen plannen de afbeelding op een manier die vergelijkbaar is met hoe een chatmodel een zin plant.
• Kosten: Je betaalt voor het canvas, niet voor de inhoud. Een eenvoudige houten tafel kost hetzelfde als een gedetailleerd olieverfschilderij van dezelfde afmetingen.
• ChatGPT: De makkelijkste instap, maar het moeilijkst te controleren. Ideaal voor eenmalige afbeeldingen en conversationele aanpassingen. Voor alles wat herhaalbaar moet zijn, is de API aan te raden.
• Prijsverschillen: Prijzen variëren enorm (factor 100+), van een fractie van een cent tot 15 cent of meer per afbeelding. Het lokaal draaien van een model is gratis. Het goedkoopste model levert niet altijd het goedkoopste resultaat (rekening houdend met het aantal pogingen).
• Stabiliteit: API's veranderen constant. Modellen worden met korte kennisgeving uitgefaseerd en aanbieders negeren soms stilletjes parameters. Houd het model in de configuratie en log wat je daadwerkelijk terugkrijgt.
• Prompting: Beschrijf hoe de afbeelding is gemaakt, niet hoe deze eruit moet zien. Camera, film, printproces en layout leveren betere resultaten op dan termen als "stunning" en "hyper-detailed".
• AI-kenmerken: Spellingfouten en zes vingers zijn niet langer de belangrijkste weggevers. Het gaat nu om smaak: te veel gloed, te veel drama en niets dat simpel of vlak mag zijn.
• Agents: Agents zijn hier erg goed in. Een multimodale agent kan de prompt schrijven, de API aanroepen, het resultaat bekijken en het opnieuw proberen. De gebruiker moet nog steeds de "smaak" leveren.
• Pipelines: De beste pipelines zijn hybriden. Laat AI het creatieve deel doen en gebruik gewone code voor de exacte zaken zoals afmetingen, transparantie, paletten en layout.

Een korte geschiedenis

• 2014 - GANs: Ian Goodfellow’s generative adversarial networks zetten twee netwerken tegen elkaar op: één die afbeeldingen maakt en één die vervalsingen spot. Ze produceren overtuigende synthetische gezichten, maar zijn moeilijk aan te sturen met tekst.
• 2015 - DeepDream: Googles Inceptionism-experimenten keren beeldherkenning binnenstebuiten. De resultaten zitten vol psychedelische hondengezichten, omdat het netwerk was getraind op een dataset met veel honden.
• 2018 - AI-kunst op veiling: Een wazig GAN-portret genaamd Edmond de Belamy wordt bij Christie’s verkocht voor $432.500, meer dan 40 keer de hoogste schatting.
• 2019 - Gezichten die niet bestaan: NVIDIA’s StyleGAN drijft thispersondoesnotexist.com aan; bij elke refresh verschijnt er een nieuw fotorealistisch nepgezicht.
• 2021 - DALL-E: OpenAI koppelt tekst en afbeeldingen in één model. Je kunt een zin typen en een plaatje krijgen, ook al is dit nog klein en wazig.
• 2022 - Het doorbraakjaar: DALL-E 2, Midjourney en Stable Diffusion verschijnen binnen enkele maanden. Stable Diffusion is open source en draait op een gaming-pc met ongeveer 7GB videogeheugen, wat een enorme community van fine-tunes en tools ontketent.
• 2023 - Fotorealisme en leesbare tekst: Een Midjourney-afbeelding van de paus in een witte pufferjas fopt een groot deel van het internet. Ideogram lanceert met tekst die je daadwerkelijk kunt lezen. SDXL verhoogt de lat voor open modellen en DALL-E 3 wordt geïntegreerd in ChatGPT.
• 2024 - Flux en de backlash: Oud-onderzoekers van Stable Diffusion richten Black Forest Labs op en brengen Flux uit, wat het standaard open-weight model wordt. Ondertussen worden AI-posters synoniem voor het nemen van shortcuts.
• 2025 - Native beeldmodellen: OpenAI bouwt beeldgeneratie direct in GPT-4o in en de "Studio Ghibli"-trend domineert sociale media. Googles Gemini 2.5 Flash Image (bijnaam "Nano Banana") maakt conversationele bewerkingen goedkoop ($0,039 per afbeelding).
• 2026 - Overvloed en verloop: OpenAI schakelt DALL-E uit in zijn API. Alleen OpenRouter lijst al meer dan 60 beeldmodellen van een dozijn bedrijven, en oudere modellen worden elke paar maanden vervangen.

Zes vingers en onbegrijpelijke tekst

Enkele jaren geleden was de makkelijkste manier om een AI-afbeelding te herkennen het tellen van de vingers of het proberen te lezen van de tekst op de achtergrond. Beide problemen zijn grotendeels opgelost, en de reden waarom ze bestonden zegt veel over de werking van deze modellen.

Handen

Handen zijn ingewikkeld, flexibel en in foto's vaak gedeeltelijk verborgen (achter een kopje, in een zak, half buiten beeld). De modellen leerden hoe handen eruitzien als een textuur, niet hoeveel vingers ze hebben. Midjourney v5 (maart 2023) was het omslagpunt, waarschijnlijk door beter gecureerde trainingsdata met duidelijkere foto's van handen, grotere modellen en hogere resoluties.

Tekst

Tekst had een specifiekere oorzaak. De meeste modellen lezen prompts via een tokenizer die tekst splitst in stukjes woorden in plaats van letters. Het model ziet niet dat "chocolate" gespeld wordt als c-h-o-c-o-l-a-t-e en kan het daarom niet letter voor letter tekenen. Een paper uit 2022 (Character-Aware Models Improve Visual Text Rendering) toonde aan dat toegang tot individuele karakters dit probleem oplost. Ideogram maakte tekst in 2023 tot een USP. Tegen 2025 hadden multimodale modellen van OpenAI en Google, die taal begrijpen zoals elke chatbot, leesbare tekst tot de norm gemaakt.

Hoewel de fix in fasen kwam, sijpelden de oude problemen door naar de echte wereld. Zo beloofden de AI-gegenereerde posters van Willy’s Chocolate Experience in Glasgow (februari 2024) een "pasadise of sweet teats". Lange teksten zijn nog steeds niet volledig opgelost; in december 2025 veranderde Nano Banana Pro "Lived experience" in "Liver experience" op een infographic.

Hoe het werkt

Je hebt de wiskunde niet nodig om deze modellen goed te gebruiken, maar een ruw beeld van het proces verklaart veel verrassingen.

Diffusiemodellen

De meeste beeldmodellen zijn diffusiemodellen. Tijdens de training leren ze ruis uit afbeeldingen te verwijderen. Men neemt een foto, voegt statische ruis toe en leert het model te voorspellen hoe de schone versie eruitzag.

Bij het genereren gebeurt dit in omgekeerde volgorde: men begint met pure statische ruis en verwijdert stap voor stap ruis. Een text encoder zet je prompt om in getallen die elke stap sturen richting een afbeelding die bij de tekst past.

Twee details zijn in de praktijk belangrijk:

1. Gecomprimeerde ruimte: Latent diffusion (gebruikt door Stable Diffusion) schildert op een intern canvas dat ongeveer 8 keer kleiner is dan de uiteindelijke afbeelding, en decodeert deze daarna. Daarom werken zeer kleine afbeeldingen (bijv. 32x32) niet goed; het interne canvas zou dan slechts 4x4 zijn.
2. Stappen kosten tijd: Meer stappen betekenen meestal een beter resultaat, maar het is trager. "Distilled" modellen zoals Flux Schnell en SDXL Turbo zijn getraind om in 4 stappen een goed beeld te krijgen in plaats van 30.

Multimodale modellen

De nieuwere aanpak integreert beeldgeneratie in een model dat ook taal begrijpt. Omdat hetzelfde model de prompt leest en de afbeelding maakt, zijn ze veel beter in het volgen van instructies, het renderen van tekst en het bewerken van referentiebeelden. Voorbeelden zijn GPT Image, Gemini's beeldmodellen en Meta’s Muse. Sommige van deze modellen plannen de layout voordat ze gaan tekenen.

Zijn multimodale modellen eigenlijk diffusiemodellen?

Vaak gedeeltelijk, maar de grens is vager dan marketing suggereert. OpenAI's GPT-4o lijkt een hybride: een taalmodel plant de afbeelding als een reeks tokens (zoals een zin), waarna een diffusion-style decoder de pixels schildert. Moderne diffusiemodellen zoals Flux gebruiken weer transformer blocks die tekst en beeld samen verwerken, wat dezelfde bouwsteen is als in chatmodellen.

Het nuttige onderscheid zit dus niet in de wiskunde, maar in hoe diep het model taal begrijpt. Dat is wat zorgt voor betere instructie-opvolging, leesbare tekst en bewerkingsmogelijkheden.

Vergelijking

Kenmerk	Diffusiemodellen (Flux, SDXL, Imagen)	Multimodale modellen (GPT Image, Gemini, Muse)
Kostenbepaling	Resolutie en aantal stappen	Beeld-tokens, meestal vast per grootte/kwaliteit
Sterke punten	Goedkoop, snel, lokaal draaibaar, seeds voor reproduceerbaarheid	Volgt instructies, rendert tekst, bewerkt vanuit referentiebeeld
Zwakke punten	Neemt prompts vaker te letterlijk	Vaak geen seed-controle en vaste output-grootte
Open weights?	Vaak	Zelden

Seeds

De willekeurige ruis waarmee een diffusiemodel start, wordt bepaald door een seed. Dezelfde seed, prompt en model geven dezelfde afbeelding. Dit maakt batches reproduceerbaar. Let op: veel hosted modellen negeren of weigeren seeds.

Typen beeldgeneratie

Type	Wat het doet	Voorbeeld	Waar te proberen
Text to image	Prompt wordt een plaatje	Concept art, achtergronden	OpenAI image guide
Image editing	"Maak de mok blauw" op bestaande foto	Itereren op design	Gemini image docs
Reference images	Houd personage/stijl consistent	Dezelfde ridder in 8 poses	Gemini image docs
Inpainting	Genereer alleen een gemaskeerd gebied	Object verwijderen, hand fixen	Diffusers inpainting guide
Outpainting	Breid afbeelding buiten de randen uit	Vierkant maken tot banner	ComfyUI examples
Structural control	Volg schets, pose of depth map	Layout exact matchen	ControlNet / Diffusers
Fine-tuning (LoRA)	Leer model een nieuwe stijl/onderwerp	Consistente huisstijl	Diffusers LoRA training
Upscaling	Voeg detail toe op hogere resolutie	Afmaken van goede beelden	Real-ESRGAN
Background removal	Snijd het onderwerp uit	Transparante sprites	rembg
Text to vector	Produceer SVG in plaats van pixels	Iconen en logo's	Recraft

Opmerking: Naadloze textures (tileable textures) vereisen specifieke modellen of LoRA's; standaardmodellen doen dit onbetrouwbaar.

Manieren om het te gebruiken

Route	Voorbeelden	Goed voor	Valkuilen
Chat apps	ChatGPT, Gemini	Eenmalige beelden, snelle edits	Weinig controle, limieten
Creatieve tools	Midjourney, Adobe Firefly, Canva	Designers, gepolijste resultaten	Abonnementen, lastig automatiseren
Directe API's	OpenAI, Google Gemini / Vertex AI	Productiecode	Elke API is anders
Aggregatoren	OpenRouter, Replicate, fal.ai	Veel modellen via één sleutel	Marges/opslag, modellen verdwijnen
Lokaal	Flux of SDXL met mflux of ComfyUI	Gratis bulk, volledige controle	Vereist sterke GPU/Apple Silicon

Gebruik van ChatGPT

ChatGPT gebruikt de GPT Image modellen (sinds maart 2025). DALL-E 3 was de voorganger; OpenAI heeft DALL-E 2 en 3 in mei 2026 uit de API verwijderd.

Sterke punten:

• Conversatie: Je kunt zeggen "warmer licht" of "verplaats de mok naar links" en het model bewerkt het beeld.
• Instructies: Gaat beter om met layouts, aantallen en details dan oudere modellen.
• Tekst: Borden en posters zijn meestal correct gespeld.
• Referenties: Kan werken vanuit een geüploade foto of schets.

Zwakke punten:

• Controle: Beperkte aspect ratio's, geen seeds en geen batch-mogelijkheden.
• Snelheid: Kan variëren van enkele seconden tot meer dan een minuut; er zijn gebruikslimieten.
• Huisstijl: Neigt naar een herkenbare look (bijv. de gelige "piss filter" van het 2025-model).
• Contentregels: Weigert bepaalde verzoeken (publieke figuren, auteursrechtelijk beschermde karakters).
• Herkomst: OpenAI voegt C2PA-metadata en SynthID-watermerken toe. Metadata is makkelijk te verwijderen; watermerken overleven screenshots beter.

ChatGPT of API? Voor meer dan een paar afbeeldingen of herhaalbaar werk is de API aan te raden. De API biedt vaste maten, kwaliteitsniveaus, batching en (bij sommige modellen) transparante achtergronden.

Wat het kost

Je betaalt voor het canvas

De beste metafoor is een schilder die alleen grote doeken bezit, per doek rekent en elke vierkante centimeter met dezelfde zorg schildert. Een vlakblauwe lucht kost evenveel moeite als een gezicht. Eenvoudige plaatjes zijn dus niet goedkoper.

Modellen werken optimaal tussen 512 en 1600 pixels. Voor een 32x32 sprite moet je een grote afbeelding genereren en deze zelf verkleinen. Vragen om een kleinere maat helpt vaak niet in de prijs (bijv. Gemini 2.5 Flash Image gaf 1024x1024 terug bij een vraag om 512x512, tegen dezelfde prijs).

Facturatiemodellen

Model	Voorbeelden	Helpt verkleinen?
Vast per afbeelding	Gemini 2.5 Flash Image, Recraft	Nee
Getrapt per grootte/kwaliteit	Nieuwere Gemini modellen, OpenAI GPT Image	Een beetje
Per megapixel of GPU-seconde	Replicate, fal.ai, OpenRouter	Ja
Eigen elektriciteit	Lokaal Flux	Ja (besparing in snelheid)

Het landschap in oktober 2026 (Indicatieve kosten per afbeelding)

• Lokaal Flux Schnell: $0 (+ tijd) → Ideaal voor iteratie en bulk.
• Flux Schnell (Replicate/fal.ai): ~$0,003 → Goedkope cloud-batches.
• Recraft V4.1 Flash (OpenRouter): ~$0,007 → Snel, goedkope illustraties.
• FLUX 3 Image Klein (OpenRouter): ~$0,009 → Goedkoop fotorealisme.
• Meta Muse Image (OpenRouter): ~$0,01 → Goed in layout-instructies.
• OpenAI GPT Image 1.5: $0,009 (low) tot $0,133 (high) → Kwaliteitsniveaus van OpenAI.
• Gemini 2.5 Flash Image: ~$0,039 (half via Batch API) → Edits en consistentie.
• Nano Banana 2 (Gemini 3.1 Flash Image): ~$0,045 tot ~$0,067 → Nieuwer, beter, duurder.
• Nano Banana Pro (Gemini 3 Pro Image): ~$0,134+ → "Hero" kwaliteit.

Kosten per bruikbare afbeelding: De prijs per afbeelding is misleidend. De echte formule is: kosten per bruikbaar beeld = (prijs per beeld x benodigde pogingen) + jouw tijd Een gratis lokaal model dat tien pogingen nodig heeft, kan duurder zijn dan een model van $0,039 dat het in één keer goed doet.

Prompting die werkt

Beschrijf de camera, niet het uitzicht

Voor achtergronden van een kaarttafel (gezien van boven) was "seen from directly above" niet genoeg, omdat de meeste foto's van tafels een hoek hebben.

Twee oplossingen:

1. Beschrijf de camera: "An orthographic flat lay. The camera points straight down at the tabletop, with no perspective and no horizon. The table surface fills the entire frame edge to edge. No walls, windows, floor or table edges are visible."
2. Specificeer posities: "Spread these around all four edges (top, bottom, left and right) rather than bunching them on one side or in the corners. Each one should be small and cut off by the edge of the image."

Marketing en de "AI-look"

AI-afbeeldingen in posters en infographics zien er vaak "goedkoop" uit door:

• Onzintekst: Bijv. "catgacating" op posters.
• Slechte smaak: Te veel effecten, fouten in architectuur (bijv. A24 posters voor Civil War).
• Feitelijke onjuistheden: Infographics die tekst negeren of witruimte opvullen.

Een poster maken die niet als AI oogt

Om een restaurantposter te maken die niet direct als AI herkenbaar is, werkt het beste om het printproces te beschrijven in plaats van de "look":

• Technisch: "Three flat spot inks on uncoated paper, slight misregistration, a scan rather than a photo, an off-centre composition and a named design tradition."
• Vermijd perfectie: Voor een burgerposter uit de jaren 90 vroeg ik om "1996 medium-format film photography" en bewust imperfect voedsel (scheve broodjes, bleke wintertomaten).
• Maak het saai: "Pristine scan, flat red background with an early-Photoshop gradient, cut-out product photo with a slightly too-even drop shadow and plain heavy italic type." Ik vroeg zelfs om het "competent and slightly bland" te maken.

Vuistregels voor prompting:

• Beschrijf hoe het gemaakt is (lens, film, belichting, printproces).
• Vermijd hype-woorden ("stunning", "hyper-detailed", "8K").
• Wees bot over de layout (wat vult het frame, waar staat alles).
• Echt design is ingetogen; vraag om "iets saai" voor meer realisme.
• Houd tekst kort en exact; zet het tussen aanhalingstekens en voeg toe: "spell every word exactly as written".
• Noem specifieke details uit een tijdperk om moderne objecten te voorkomen.
• Genereer altijd 2 of 3 varianten.
• Gebruik een template (vaste style suffix en seed) voor batches.

Pixel art

Pixel art lijkt eenvoudig, maar is lastig omdat AI vaak een plaatje van pixel art maakt in plaats van echte pixel art.

Stijl vs. Formaat

Een AI-gegenereerde sprite is vaak een 1024x1024 afbeelding waarbij de "pixels" variëren in grootte, niet op een echt grid liggen en te veel kleuren gebruiken. Om dit bruikbaar te maken is extra code nodig voor:

1. Achtergrondverwijdering.
2. Snap-to-grid via nearest-neighbour downscaling.
3. Reductie van het kleurpalet.

Meerdere sprites op één canvas

Het is goedkoper en consistenter om veel sprites in één beeld te vragen. Voor objecten werkt 10x10 goed; voor personages in verschillende poses is 4x4 het maximum. Bij meer dan 4x4 worden personages vaak identieke kopieën.

• Tip: Slice nooit op een vast grid; zoek sprites op basis van hun vorm.
• Tip: Schaal alles samen om te voorkomen dat een personage tussen frames in van grootte verandert.

Professionele routes voor pixel art

Voor echt goede resultaten zijn gespecialiseerde tools beter:

• PixelLab: Tekent echte sprites op werkelijke grootte.
• Retro Diffusion: Commercieel alternatief.
• Zelf doen: Gebruik een LoRA zoals Pixel Art XL, verklein het resultaat naar een grid en fix het palet in code. PixelOE kan beelden zonder AI omzetten naar pixel art.

Conclusie: AI is goed in "hoe moet dit eruitzien?" (creatief), maar slecht in "zet dit exact in dit vakje" (structureel). Gebruik AI voor het creatieve deel en code voor de structuur.

Integratie in codeprojecten

Gebruik een dunne interface

Elke API is anders. Verstop de details (Base64 decoding, parameter-namen) achter één functie, zodat het wisselen van provider een configuratiewijziging is.

from dataclasses import dataclass, field
from typing import Protocol
from PIL import Image

@dataclass
class GenerationResult:
    image: Image.Image
    provider: str
    model: str
    prompt: str
    seed: int | None = None
    cost_usd: float | None = None
    metadata: dict = field(default_factory=dict)

class ImageProvider(Protocol):
    def generate(self, prompt: str, *, width: int, height: int, seed: int | None = None) -> GenerationResult: ...

Houd rekening met volatiliteit

Modellen verdwijnen snel, endpoints veranderen en parameters worden genegeerd.

• Houd provider en model in de configuratie, niet in de code.
• Controleer de afmetingen van het resultaat in plaats van te vertrouwen op de aanvraag.
• Draai periodiek smoke tests om uitgefaseerde modellen vroegtijdig te ontdekken.

Logging en uitvoering

• Log alles: Prompt, model, parameters, grootte, duur en kosten.
• Async verwerking: Generatie is traag (seconden tot minuten). Gebruik een job queue; doe dit nooit binnen een direct web-request.
• Foutafhandeling: Behandel timeouts en rate limits met backoff, maar behandel content-weigeringen als definitief.
• Cashing: Cache resultaten op basis van een hash van de prompt en parameters.

Gebruik code voor het exacte werk

Gebruik AI alleen voor het creatieve deel. De volgende zaken zijn gratis, snel en deterministisch in Python:

• Achtergrondverwijdering (rembg).
• Resizing, palette-reductie en cropping.
• Het toevoegen van exacte tekst (prijzen, datums) via code in plaats van via de AI-prompt.

Integratie met agents

Een multimodale agent kan een gedetailleerde prompt schrijven, het model aanroepen, het resultaat bekijken en critici zijn.

Claude en afbeeldingen

Claude genereert zelf geen rasterafbeeldingen (zoals foto's). Claude kan wel afbeeldingen analyseren en diagrammen maken via SVG of HTML. Voor foto's moet Claude gekoppeld worden aan een specialistisch beeldmodel via een tool.

Manieren van koppeling

1. CLI-tool: Geef de agent een script dat hij kan uitvoeren via de shell.
2. MCP-server: Het Model Context Protocol stelt je in staat om beeldgeneratie als een getypeerde tool aan te bieden aan agents zoals Claude Code of Cursor.
3. Function calling: Definieer een generate_image tool in je eigen LLM-API call.

Voorbeeld van een minimale MCP-server in Python:

from mcp.server.fastmcp import FastMCP, Image
from image_gen.config import get_provider

mcp = FastMCP("image-gen")

@mcp.tool()
def generate_image(prompt: str, width: int = 1024, height: int = 1024) -> Image:
    """Generate an image from a detailed prompt. Costs about $0.01 per call."""
    result = get_provider("openrouter", model="meta/muse-image").generate(prompt, width=width, height=height)
    path = save_with_metadata(result)  # eigen logging en opslag
    return Image(path=path)

if __name__ == "__main__":
    mcp.run()

Tips voor agent-gestuurde generatie

• Laat de agent de prompts schrijven; LLM's zijn uitstekend in het vertalen van een vage wens naar een gestructureerde prompt.
• Zorg dat de agent de output kan zien. Zonder visuele feedback is een agent slechts een trage manier om een API aan te roepen.
• Zet de kosten in de tool-beschrijving; agents maken betere keuzes als ze weten of een call 1 of 15 cent kost.
• Stel een budget in (max aantal calls per sessie).
• Vraag om eerlijke kritiek; laat de agent specifiek benoemen wat er fout is.
• De mens bepaalt de smaak; de agent controleert of het beeld bij de brief past, maar jij bepaalt of de brief juist is.

Glossarium

• Diffusion: Het genereren van een beeld door te beginnen met willekeurige ruis en deze stap voor stap te verwijderen, gestuurd door de prompt.
• Latent: Het gecomprimeerde interne canvas waarop een diffusiemodel werkt.
• Steps: Het aantal denoising-passes. Meer stappen zijn trager, maar vaak beter.
• Distilled model: Een model getraind om in zeer weinig stappen goede resultaten te leveren (bijv. Flux Schnell).
• Seed: Het willekeurige startpunt. Dezelfde seed + prompt + model = hetzelfde beeld.
• Tokeniser: Het onderdeel dat tekst splitst in stukjes; de reden waarom oudere modellen niet konden spellen.
• Tokens: De eenheid waarmee multimodale modellen output tellen.
• Open weights: Een model dat je kunt downloaden en zelf kunt draaien.
• LoRA: Een kleine add-on die een open model een nieuwe stijl of onderwerp leert zonder volledige retraining.
• ControlNet: Een methode om een diffusiemodel een schets, pose of depth map te laten volgen.
• Inpainting: Het opnieuw genereren van slechts een gemaskeerd deel van een afbeelding.
• C2PA: Een metadata-standaard die vastlegt hoe een afbeelding is gemaakt.
• SynthID: Google's onzichtbare watermerk voor AI-content.
• MCP: Model Context Protocol; een standaard om agents toegang te geven tot tools.
• Nearest-neighbour: Een resize-methode die pixels kopieert in plaats van mengt (essentieel voor pixel art).
• Orthographic: Een aanzicht zonder perspectief.

Bronnen

• OpenRouter image models: Vergelijk prijzen en probeer modellen via één API-key.
• OpenAI image generation guide: Documentatie voor de GPT Image API.
• Gemini image generation docs: Info over Nano Banana en andere modellen.
• mflux: Flux lokaal draaien op Apple Silicon.
• ComfyUI: Node-based lokale workflows.
• Hugging Face Diffusers: De Python library achter veel open-model tooling.
• rembg: Achtergrondverwijdering in Python.
• Replicate & fal.ai: Goedkope hosted open-weight modellen voor bulk.
• Model Context Protocol: Voor het blootstellen van beeldgeneratie aan agents.