🤖 AI

NormCode Canvas: Making LLM Agentic Workflows Development Sustainable via Case-Based Reasoning

Het paper introduceert NormCode Canvas, een systeem dat Case-Based Reasoning op twee niveaus toepast via een semi-formele taal om betrouwbare, lokaal diagnoseerbare en zelfverbeterende multi-stap LLM-workflows te realiseren.

Oorspronkelijke auteurs: Xin Guan, Yunshan Li, Ze Wang

Gepubliceerd 2026-03-17

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Xin Guan, Yunshan Li, Ze Wang

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een heel groot, complex recept probeert te volgen om een gerecht te koken. In de wereld van kunstmatige intelligentie (AI) noemen we dit een "workflow": een reeks stappen waarbij de AI eerst iets bedenkt, dan iets zoekt, daarna iets schrijft en tenslotte iets controleert.

Het probleem met de huidige AI-systemen is dat ze vaak werken als een zwart doosje. Als de AI halverwege de kookstap (bijvoorbeeld bij het snijden van de groenten) een fout maakt, is het heel lastig om te weten waar het misging. Was het de groente? Was het het mes? Of was het de instructie die de AI drie stappen eerder kreeg? Vaak moet je het hele gerecht opnieuw maken, omdat je niet precies weet wat er in de "pan" zat op dat specifieke moment.

NormCode Canvas is een nieuw systeem dat dit probleem oplost. Het maakt het bouwen van AI-systemen duurzaam, betrouwbaar en makkelijk te repareren. Hier is hoe het werkt, vertaald naar alledaagse taal:

1. De "Fototoestel"-methode (In plaats van een video)

Stel je voor dat je een lange video maakt van je kookproces. Als je halverwege een fout ziet, moet je de hele video terugspoelen om te zien wat er precies gebeurde. Dat is hoe huidige AI-systemen werken: ze onthouden alles als één lange, ononderbroken conversatie.

NormCode doet het anders. Het neemt bij elke stap een fototoestel (een "checkpoint").

De regel: Bij elke foto wordt alles wat je niet nodig hebt voor die specifieke stap, weggegooid. De foto bevat alleen de ingrediënten die op dat moment op het bord liggen.
Het voordeel: Als de soep later te zout is, kun je direct naar de foto van stap 3 kijken. Je ziet precies welke zoutkorrels er toen in zaten. Je hoeft niet te raden wat er in de hele pot zat. Dit noemen ze in het paper "Scope Rule": elke stap is een zelfstandig, afgesloten geval.

2. Twee niveaus van "Geheugen"

Het systeem werkt op twee niveaus, net als een groot bedrijf:

Niveau 1: De Concrete Gevallen (De "Dagboeken")
Dit zijn de foto's van de specifieke momenten in een taak. Als de AI een presentatie maakt en bij dia 5 vastloopt, slaat het systeem de exacte staat van de computer op dat moment op.
- Hoe het helpt: Als je later weer een presentatie moet maken, kun je zeggen: "Herhaal wat je deed tot aan dia 5, maar verander de titel." Het systeem pakt die oude foto, past de titel aan en gaat verder. Je hoeft niet opnieuw te beginnen. Dit is hergebruik.
Niveau 2: De Abstracte Gevallen (De "Recepten")
Dit zijn de algemene plannen of recepten zelf. Stel, je hebt een recept voor "PPT maken" en een recept voor "Code schrijven".
- Hoe het helpt: Als je merkt dat je recept voor "PPT maken" niet goed werkt, kun je het recept zelf aanpassen voordat je het weer gebruikt. Het systeem zorgt ervoor dat je het nieuwe recept eerst kunt lezen en controleren (in mensentaal) voordat de AI er überhaupt mee begint. Dit is verbetering.

3. De "Magische Werkbank" (NormCode Canvas)

Het paper introduceert een tool genaamd NormCode Canvas. Dit is de werkbank waar alles gebeurt.

Inspectie: Je kunt op elk punt in het proces op een knop drukken en zien exact wat de AI zag en dacht op dat moment. Geen giswerk, geen reconstructie.
Selectief Opnieuw Doen: Als je een fout vindt in stap 5, hoef je niet stap 1 tot 4 opnieuw te doen. Het systeem weet precies welke stappen afhankelijk zijn van stap 5 en doet alleen die opnieuw. De rest blijft staan.
Zelflerend Systeem: Het systeem heeft zelfs een eigen "AI-assistent" die andere plannen kan debuggen (repareren). Het is een ecosysteem waar de plannen elkaar helpen, verbeteren en repareren.

Waarom is dit belangrijk?

Vroeger was het bouwen van complexe AI-systemen als het bouwen van een huis zonder blauwdrukken: als er een muur scheef stond, moest je misschien het hele huis slopen.

Met NormCode Canvas bouw je met modulaire blokken.

Je kunt elk blok bekijken (inspectie).
Je kunt een blok vervangen zonder de rest van het huis aan te tasten (selectieve heruitvoering).
Je kunt een fout in het ontwerp (het recept) zien voordat je begint met bouwen (pre-executie review).

Kortom: NormCode Canvas maakt AI-systemen niet alleen slimmer, maar vooral begrijpbaarder en betrouwbaarder. Het zorgt ervoor dat we niet hoeven te gokken waarom een AI faalt, maar dat we precies kunnen zien, aanpassen en verbeteren, alsof we met een set legoblokken werken in plaats van met modder.

Probleemstelling

Multi-stap LLM-workflows (waarbij elke inferentiestap de volgende voedt) zijn de standaard geworden voor het inzetten van taalmodellen in real-world applicaties. Bestaande frameworks zoals LangChain, LangGraph en AutoGen maken het bouwen van deze workflows eenvoudig, maar ze lijden aan ernstige tekortkomingen in debuggen, hervatten en systematisch verbeteren:

Gebrek aan case-integriteit: De staat wordt vaak doorgegeven via conversatiegeschiedenis of mutabele objecten. Een checkpoint op stap $k$ bevat vaak impliciete afhankelijkheden van eerdere context ( $1 \dots k-1$ ) die niet expliciet in het checkpoint zelf staan.
Fragiele foutherstel: Omdat de oorzaak van een fout op stap $k$ ergens in de opgehoopte, impliciete staat kan liggen, is foutlocalisatie moeilijk en is het herhalen van een workflow onbetrouwbaar.
Verspreide semantiek: Het plan, de tussenliggende semantiek en de voorwaarden voor geldige voortzetting zijn verspreid over code en prompts in plaats van in één interpreteerbare vorm te staan.

Er is een behoefte aan een workflow-taal die multi-stap redenering expliciet representeert, inspecteerbaar, verifieerbaar en herzienbaar maakt, zonder impliciete gedeelde staat.

Methodologie: NormCode en Case-Based Reasoning (CBR)

De auteurs introduceren NormCode, een semi-formele planningstaal, en NormCode Canvas, een gedeployerd systeem dat Case-Based Reasoning (CBR) implementeert op twee niveaus.

1. De Basis: NormCode en de Scope Rule

NormCode is ontworpen om elke uitvoeringscheckpoint tot een zelfstandige "case" te maken door middel van een strikte scope rule (compiler-geverifieerd):

Elke stap kan alleen toegang hebben tot data die expliciet is gedeclareerd in zijn eigen scope-blok.
Er is geen impliciete gedeelde staat.
Dit zorgt voor structurele isolatie: een checkpoint bevat exact wat nodig is voor downstream-stappen, waardoor fouten lokaaliseerbaar zijn en checkpoints reproduceerbaar zijn.

De taal bestaat uit drie markers: <- (Waarde), <= (Functioneel) en <* (Context/loop-huidige element). Plans worden vertaald van een menselijk leesbaar formaat (.ncds) naar een formeel gecompileerd formaat (.ncd) en een narratieve weergave (.ncn) voor pre-executiereview.

2. Twee-Niveau CBR Architectuur

Het systeem implementeert CBR op twee niveaus:

Niveau 1: Concrete Case Management (Suspended Runtimes)
- Een Level 1 case is een "suspended runtime" op een specifiek flow-indexpunt.
- Retrieve: Selectie van een vorig geval bij een fout of nieuwe taak.
- Reuse (Fork): Het laden van een checkpoint om de uitvoering voort te zetten zonder upstream-stappen opnieuw uit te voeren.
- Revise (Value Override + Selective Re-run): Een operator kan een tensor (data) in een checkpoint aanpassen. Door de scope rule weet het systeem precies welke downstream-stappen "verouderd" (stale) zijn en moeten worden herberekend. Upstream-stappen worden uit de cache gehaald.
- Retain: Elke voltooide stap schrijft automatisch een nieuwe case op.
Niveau 2: Abstract Case Learning (Executable Plans)
- Level 2 cases zijn de NormCode-plans zelf (de werkstromen), die dienen als abstracte patronen voor een klasse van problemen.
- De compilatiepijplijn (van natuurlijke taal naar uitvoerbaar plan) is zelf een Level 2 case (de "NC Compilations" plan). Dit maakt het mogelijk om de compilatiepijplijn zelf te verbeteren en te debuggen via dezelfde CBR-mechanismen (recursief leren).

Belangrijkste Bijdragen

Twee-niveau CBR-account: Een architectuur die concrete runtimes (Level 1) en uitvoerbare plannen (Level 2) integreert, waarbij de compilatiepijplijn zelf deel uitmaakt van het leerproces.
NormCode Workflow-taal: Een taal die zes essentiële eigenschappen combineert: interpreteerbaar, afdwingbaar (via compiler), composable, lokaal adresseerbaar, generaliseerbaar en portabel.
Drie Structurele Capabiliteiten (C1-C3):
- C1: Directe checkpoint-inspectie: Directe toegang tot de exacte, begrenste inputs van elke stap zonder reconstructie uit logs.
- C2: Pre-executiestructuur review: Een menselijke expert kan het plan (via .ncn narratief) verifiëren voordat er ook maar één LLM-call plaatsvindt.
- C3: Scope-gebonden selectieve herberekening: Het aanpassen van een stap triggert alleen de herberekening van afhankelijke downstream-stappen.
Gedeployeerd Ecosysteem: Vier productieworkflows die bewijzen dat het systeem werkt en een zelfonderhoudend ecosysteem vormen waar plannen elkaar produceren, debuggen en verfijnen.

Resultaten en Case Studies

Het paper presenteert vier gedeployerde plannen als bewijs:

PPT Generation: Genereert presentaties (~40s per dia) via een geneste lus. Toont volledige taalagnostiek (plan geschreven in het Chinees) en dat 60-70% van de knopen syntactisch is (geen LLM-kosten).
Code Assistant: Een ReAct-workflow voor software-engineering (explore, plan, implement, verify). Illustreert hoe de scope rule zorgt voor schone inputs (geen gemengde conversatiegeschiedenis) en efficiënte herberekening na wijzigingen.
NC Compilations: Zelf-hosted compilatie die natuurlijke taal specificaties omzet in uitvoerbare NormCode-plans (bijv. voor rapporten of contracten).
Canvas Assistant: Een ingebouwde agent die plannen debugt door verbinding te maken met externe AI-code editors (zoals Cursor), waardoor het Level 1 CBR-cyclus automatiseert.

Ecosysteem Status: Deze plannen vormen een gesloten lus: NC Compilations produceert plannen; deze plannen genereren Level 1 cases tijdens uitvoering; Canvas Assistant debugt mislukte runs; en Code Assistant breidt het platform uit. Dit realiseert cumulatief leren op systeemniveau.

Betekenis en Conclusie

NormCode Canvas biedt een fundamentele verschuiving in hoe LLM-workflows worden ontwikkeld en onderhouden. In plaats van te vertrouwen op fragiele conversatiegeschiedenissen, biedt het een structureel gegarandeerde isolatie van data en staat.

Duurzaamheid: Het maakt workflows "onderhoudbaar" door fouten lokaal te maken en herberekening te beperken tot wat nodig is.
Verantwoordelijkheid: Door pre-executiereview (C2) kunnen mensen de logica verifiëren voordat er kosten worden gemaakt of fouten worden gemaakt.
Cumulatief Leren: Het systeem leert niet alleen van individuele runs (Level 1), maar verbetert ook de onderliggende patronen en zelfs de compilatie-instrumenten zelf (Level 2).

Het paper claimt niet dat NormCode de kwaliteit van de eindoutput van LLMs universaal verbetert, maar dat het de inspecteerbaarheid, herzienbaarheid en beheersbaarheid van multi-stap workflows drastisch verbetert, wat essentieel is voor schaalbare en betrouwbare AI-toepassingen.