1. Inleiding

Robotische procesautomatisering deed een bescheiden belofte en hield die, een tijdlang, ook. Waar een mens gegevens verplaatste tussen systemen die niet met elkaar konden praten, inloggen op een portaal, cijfers kopiëren naar een spreadsheet, ze intoetsen in een ERP, kon een RPA-bot worden geleerd hetzelfde te doen, op dezelfde knoppen in dezelfde volgorde klikken, sneller en zonder te vermoeien. De aantrekkingskracht was dat het geen enkele wijziging aan de onderliggende systemen vergde: de bot bediende de bestaande schermen precies zoals een mens dat deed, zodat een afdeling een proces in weken kon automatiseren zonder te wachten tot de IT-afdeling een interface bouwde. Op die basis werd RPA een van de snelst geadopteerde bedrijfstechnologieën van het afgelopen decennium.

Het probleem zit in het woord robotisch. Een RPA-bot begrijpt de taak niet; hij herhaalt een opname. Hij weet dat het factuurtotaal in het derde vak op het tweede tabblad staat, niet wat een factuurtotaal is, dus wanneer het portaal opnieuw wordt vormgegeven en het vak verschuift, past de bot zich niet aan, hij faalt, en als hij stilzwijgend faalt blijft hij het verkeerde getal boeken totdat iemand het opmerkt. Elk proces dat een organisatie draait, bevindt zich in een omgeving die afdrijft: software wordt bijgewerkt, formulieren worden opnieuw vormgegeven, leveranciers sturen een nieuwe opmaak, een regelgeving voegt een veld toe, er komt een randgeval dat de opname nooit heeft gezien. Tegen een afdrijvende omgeving is een bevroren regelset een slinkend bezit. De branchenaam voor het gevolg is botonderhoud, en het is het stille schandaal van het vakgebied: een groot deel van de inspanning in een volwassen RPA-programma gaat niet naar het automatiseren van nieuw werk, maar naar het repareren van automatiseringen die de wereld kapot heeft gemaakt, zodat de bedrijfskosten in de loop van de tijd stijgen en de businesscase van onderaf wordt uitgehold.

Dit artikel gaat over wat RPA vervangt, en waarom de vervanging een ander soort ding is dan een snellere bot. Een capabele AI-agent, een model dat een scherm of een document kan lezen, kan redeneren waar het voor dient, gereedschappen kan aanroepen en zijn eigen werk kan controleren, kan de administratieve taak doen die RPA deed, maar dat is niet de interessante bewering, want hetzelfde brosse ding doen met een duurdere motor is geen vooruitgang. De interessante bewering is dat een agent kan doen wat een bot structureel niet kan: hij kan de automatisering verbeteren vanuit zijn eigen werking. Telkens wanneer hij een geval afhandelt, genereert hij bewijs, wat hij deed, of het resultaat werd aanvaard, waar hij aarzelde of werd gecorrigeerd, en dat bewijs kan worden teruggekoppeld om te herzien hoe de automatisering zich de volgende keer gedraagt. Automatisering houdt op een eenmaal gemaakte en daarna vervallende opname te zijn en wordt een lus die beter wordt naarmate hij vaker draait. Wij noemen dit recursieve automatisering, en het is de eerste van de twee hoekstenen van dit artikel.

De tweede hoeksteen is degene die de eerste veilig maakt, en zonder haar is de recursie een last in plaats van een bezit. Een lus die haar eigen gedrag verandert op grond van haar eigen uitvoer is, in regeltechnische termen, een terugkoppelingssysteem, en terugkoppelingssystemen kunnen convergeren of op hol slaan. Een agent die aan zichzelf wordt overgelaten om zich bij te stellen tegen een ruizig signaal, zal de ruis najagen, de maat optimaliseren die hem is gegeven in plaats van de uitkomst die hij moest dienen, en achteruitgaan op manieren die niemand heeft gekozen. De discipline die een zelfverbeterende lus verandert van een gevaar in een betrouwbare motor van verbetering is niet nieuw; de industrie beschikt er sinds de jaren 1920 over en heeft haar de afgelopen dertig jaar geformaliseerd als Six Sigma, waarvan de operationele kern de DMAIC-cyclus is: Define het doel en de toleranties, Measure wat er werkelijk gebeurt, Analyse de bronnen van fouten en variatie, Improve door een weloverwogen wijziging, en Control zodat de winst behouden blijft en niet verloren gaat. Gelezen als een projectmethodologie is DMAIC vertrouwd. Gelezen als de besturingsstructuur van een zelfverbeterende automatisering, continu uitgevoerd in plaats van eenmalig, is het precies de regelaar die de recursieve lus nodig heeft, en de koppeling is het onderwerp van dit artikel.

De bijdrage is een betoog en een klein model, geen benchmark. Paragraaf 2 plaatst de bewering tegen de staat van dienst van RPA, intelligente automatisering, continue verbetering en AI-agents. Paragraaf 3 zet uiteen waarom een bot met vaste regels vervalt, met een model van afdrijving en onderhoud. Paragraaf 4 beschrijft de recursieve lus die een agent mogelijk maakt. Paragraaf 5 is het hart van het artikel: DMAIC als de besturingsstructuur die de lus laat convergeren, met de Control-fase als een non-regressieratel. Paragraaf 6 leidt de vervangingsvoorwaarde af, een enkel getal dat zegt wanneer de agent de bot inhaalt. Paragraaf 7 volgt een geconstrueerde casus over crediteurenadministratie; Paragrafen 8 tot en met 11 trekken de gevolgen voor hoe een automatiseringsfunctie wordt gerund, beantwoorden bezwaren, stellen grenzen en concluderen. De vraag die overal speelt is: zodra automatisering kan leren van haar eigen uitvoering, wat houdt haar bij het leren van het juiste, en wanneer maakt dat de opgenomen bot overbodig?

2. Achtergrond

2.1 RPA en zijn plafond

RPA werd in de informatiesysteemliteratuur gekarakteriseerd als “lichtgewicht” automatisering: software die de presentatielaag van bestaande systemen bedient in plaats van hun gegevens of logica, zodat zij door de business wordt ingezet, buiten het traditionele IT-project om, tegen ongewijzigde back-ends (van der Aalst, Bichler & Heinzl, 2018; Hofmann, Samp & Urbach, 2020). Het vroege casusbewijs was oprecht positief over kosten en snelheid (Lacity & Willcocks, 2016; Willcocks, Lacity & Craig, 2015). Dezelfde literatuur benoemde, naarmate het vakgebied volwassen werd, het plafond. Syed et al. (2020) identificeren, in een overzicht van de stand van het RPA-onderzoek en de praktijk, de afhankelijkheid van stabiele, gestructureerde invoer en de kwetsbaarheid van bots voor interface- en proceswijzigingen als terugkerende, onopgeloste thema’s, en plaatsen onderhoud en governance onder de centrale uitdagingen van het vakgebied; Wewerka en Reichert (2023), die het vakgebied systematisch in kaart brengen, catalogiseren beperkte uitzonderingsafhandeling en onderhoudsinspanning onder de hardnekkige problemen ervan. Het plafond is geen gebrek van een bepaald product; het is inherent aan automatiseren door nabootsing van het oppervlak. Een bot codeert hoe een competent persoon toevallig klikte, niet wat de taak vereist, en de kloof tussen die twee is precies de ruimte die de omgeving heeft om hem te breken.

2.2 Van RPA naar intelligente en agentische automatisering

Praktijkmensen reageerden door intelligentie aan de bot vast te schroeven: optische tekenherkenning om documenten te lezen, een classificator om ze te sorteren, een model om de ongestructureerde invoer aan te kunnen die RPA niet aankon. Deze intelligente automatisering of hyperautomatisering verbreedde het bereik van invoer dat een pijplijn kon aanvaarden, maar liet de besturingsstructuur ongewijzigd, een vaste orkestratie met slimmere componenten op vaste posities ingebouwd, en zo erfde zij dezelfde brosheid een laag hoger. De recentere verschuiving is van een andere aard. Een AI-agent bezet geen vaste positie in een met de hand getekende stroom; hij krijgt een doel en een verzameling gereedschappen en beslist over de stappen, waardoor hij variatie kan opvangen die een vaste orkestratie zou hebben gebroken, en, omdat hij over de taak redeneert in plaats van een opname af te spelen, kan hem worden gevraagd uit te leggen, te controleren en te herzien wat hij deed. De agentliteratuur in machine learning geeft de mechaniek, redeneren afwisselen met gereedschapsgebruik (Yao et al., 2023), reflecteren op mislukte pogingen om het bij de volgende beter te doen (Shinn et al., 2023), en het bredere overzicht van autonome agents (Wang et al., 2024). Onze belangstelling gaat niet uit naar het mechanisme in abstracto, maar naar een gevolg voor de bedrijfsvoering: de uitvoering van een agent levert inspecteerbaar bewijs op, en bewijs is wat een lus nodig heeft om te verbeteren.

2.3 Continue verbetering is ouder dan de machine

Het idee dat een proces vanuit zijn eigen uitvoer gemeten en verbeterd zou moeten worden, is geen AI-idee; het is het fundament van het twintigste-eeuwse kwaliteitsmanagement, en het artikel leunt er bewust op. Shewhart (1931) onderscheidde de variatie die inherent is aan een stabiel proces, common cause, van de toewijsbare, special cause, variatie die aangeeft dat er iets is veranderd, en gaf de regelkaart als het instrument dat ze uit elkaar houdt, zodat men reageert op werkelijke verschuivingen en niet op ruis, precies de faalwijze van een onbeheerste leerlus; de moderne statistische behandeling is Montgomery (2024). Deming (1986) bouwde het managementsysteem eromheen en maakte de Plan–Do–Study–Act-cyclus van iteratieve verbetering populair. Six Sigma (Harry & Schroeder, 2000; Pyzdek & Keller, 2023) verpakte de praktijk in DMAIC en koppelde haar aan een gekwantificeerd defectpercentage; de academische behandelingen geven haar een theorie (Linderman et al., 2003) en een eerlijk verslag van haar spanning met innovatie (Benner & Tushman, 2003). Eén lijn staat bijzonder dicht bij dit artikel: Box’ (1957) evolutionary operation, die een productieproces liet draaien als een traag, voortdurend experiment, dat aan de instellingen ervan morrelde en behield wat de opbrengst aantoonbaar verbeterde, is recursieve zelfverbetering onder statistische beheersing, decennia vóór de term, en het is de juiste voorouder van wat een agent nu doet op de snelheid van software.

2.4 Terugkoppeling, variëteit en de grenzen van een vaste regel

De cybernetica levert de reden waarom een vaste bot het moet verliezen van een variërende wereld. Ashby’s (1956) wet van de vereiste variëteit stelt dat een regelaar verstoring slechts kan opvangen in verhouding tot de variëteit die hij zelf kan voortbrengen: alleen variëteit kan variëteit vernietigen. Een RPA-bot heeft er, per constructie, bijna geen, één respons per opgenomen pad, dus hij kan alleen een omgeving reguleren die die paden nooit verlaat, en elke werkelijke omgeving doet dat uiteindelijk wel. Een agent die wordt beheerst door een leerlus vervaardigt variëteit op aanvraag, door een respons te genereren op een geval waarvoor hij niet expliciet was gebouwd, en daarom kan hij een bewegend doel volgen dat een vaste regel niet kan. Wiener (1948) gaf het grondleggende verslag van besturing door terugkoppeling, en de machine-learningtraditie van leren uit een beloningssignaal (Sutton & Barto, 2018) en van organisaties die leren door fouten te corrigeren (Argyris & Schön, 1978) zijn hetzelfde principe op andere schalen. De bijdrage hier is deze twee oude kennisgebieden samen te brengen op een nieuw object: de agent levert de variëteit, en DMAIC levert de besturing die de variëteit op het doel gericht houdt.

3. Waarom een bot met vaste regels vervalt

Het bezwaar tegen RPA is niet dat het faalt op dag één; het is dat het gebouwd is om optimaal te zijn op dag één en elke dag daarna te verslechteren. Leg een proces vast en zet een bot in die een deel van zijn gevallen correct afhandelt. De omgeving drijft dan, in een zeker tempo, weg van de toestand waartegen de bot werd opgenomen: formulieren veranderen, systemen worden geüpgraded, nieuwe varianten van invoer komen binnen, beleidsregels voegen een stap toe. Elke toename van afdrijving verandert sommige gevallen die de bot placht af te handelen in gevallen die hij nu verkeerd afhandelt, zodat het foutenpercentage van de bot ruwweg stijgt in verhouding tot de opgebouwde afdrijving. Tussen ingrepen door,

waarbij $\varepsilon_0$ het foutenpercentage bij ingebruikname is, $t$ de tijd is, en $\delta$ de afdrijvingssnelheid is, het tempo waarin de wereld de opname achter zich laat. Het enige wat $\varepsilon^{\mathrm{rpa}}$ verlaagt, is een mens: een engineer merkt het defect op, neemt het pad opnieuw op, en zet het foutenpercentage terug richting $\varepsilon_0$, tegen een prijs, en tot de volgende afdrijving. De bot tekent daarom een zaagtand, klimmend met afdrijving en dalend bij elke handmatige reparatie, en verbetert nooit op zijn oorspronkelijke ontwerp, omdat niets erin leert. Zijn gemiddelde fout over de levensduur wordt bepaald door hoe snel de wereld beweegt ($\delta$) en hoe vaak de organisatie het zich kan veroorloven iemand te sturen om hem te repareren.

Twee kenmerken van dit beeld doen ertoe. Ten eerste is het onderhoud reactief en onbegrensd: naarmate een bestand van bots groeit, groeit de afdrijving die zij gezamenlijk opbouwen mee, zodat de onderhoudsinspanning stijgt met het aantal automatiseringen in plaats van met het nieuwe werk dat wordt geautomatiseerd, wat het mechanisme is waardoor de bedrijfskosten van een RPA-programma zijn besparingen voorbijstreven. Ten tweede is het falen vaak stilzwijgend: een bot die een waarde uit het verkeerde veld boekt, werpt geen fout op, hij produceert een plausibel, verkeerd resultaat, en de kosten daarvan worden alleen begrensd door hoe lang het onopgemerkt blijft. Een vaste regel in een bewegende wereld is niet louter beperkt; het is een last waarvan de organisatie de omvang niet beheerst.

4. Recursieve automatisering: de lus die een bot niet kan sluiten

Een agent verandert het beeld omdat zijn uitvoering een informatiebron is die kan worden teruggewend op de automatisering zelf. Wanneer een agent een geval verwerkt, laat hij een spoor na: de invoer die hij zag, de stappen die hij koos, de gereedschapsaanroepen die hij deed, de uitvoer die hij produceerde, en, cruciaal, het stroomafwaartse signaal of die uitvoer werd aanvaard, gecorrigeerd of teruggedraaid. Dat spoor is bewijs over waar de automatisering sterk is en waar zij zwak is, en omdat het gedrag van de agent wordt uitgedrukt in dingen die kunnen worden bewerkt, zijn instructies, de voorbeelden die hem worden gegeven, de gereedschappen en controles die hij moet gebruiken, de routering van moeilijke gevallen, kan dat bewijs worden teruggekoppeld als een herziening. De automatisering verbetert vanuit haar eigen werking. Waar vergelijking (1) alleen een externe hand heeft om de fout te verlagen, verlaagt de recursieve lus haar van binnenuit, elke cyclus:

Hier is $\varepsilon_k$ het foutenpercentage na $k$ cycli, is $g \in (0,1)$ de verbeterwinst, de fractie van de herstelbare fout die een cyclus verwijdert, en is $\varepsilon_\ast$ de onherleidbare bodem, het residu dat het proces niet kan afwerpen omdat het echte dubbelzinnigheid, ontbrekende informatie of onherleidbaar oordeel weerspiegelt, de wezenlijke in plaats van toevallige moeilijkheid van de taak. Iteratie van vergelijking (2) geeft de gesloten vorm

een geometrische daling van de startfout naar de bodem. Dit is de vorm waarop de kwaliteitstraditie altijd heeft gemikt en de vorm die een bot nooit kan tekenen, want een bot heeft geen $g$: zijn verbeterwinst is nul, en vergelijking (2) valt terug op een constante die alleen door handmatige resets wordt onderbroken. Het verschil tussen RPA en agentische automatisering is in dit model het verschil tussen $g = 0$ en $g > 0$: tussen een automatisering die alleen van buitenaf kan worden gerepareerd en een die zichzelf van binnenuit verbetert.

Drie voorwaarden maken $g$ positief en houden dat zo, en alle drie zijn dingen die de uitvoering van de agent levert en die van een bot niet. Er moet een signaal zijn: een meetbare uitkomst voor elk geval, zodat beter en slechter uit elkaar te houden zijn. Er moet toewijsbaar bewijs zijn: sporen die rijk genoeg zijn om te lokaliseren waarom een geval misging, niet louter dat het misging. En er moet een bewerkbaar oppervlak zijn: hendels, prompts, voorbeelden, gereedschappen, routering, die een herziening daadwerkelijk kan verzetten. Een agent produceert alle drie als bijproduct van het werken; een opgenomen bot produceert er geen van, wat de diepere reden is waarom hij niet kan leren. Maar een positieve $g$ is nog geen veilige $g$. Een lus die zichzelf herziet tegen een signaal kan de fout net zo gemakkelijk verhogen als verlagen, als het signaal ruizig is, de toewijzing verkeerd, of de wijziging een regressie. $g$ betrouwbaar positief maken, cyclus na cyclus, is de taak van de besturingsstructuur, en dat is DMAIC.

5. DMAIC als de besturingsstructuur

De centrale bewering van het artikel is dat de discipline die een zelfverbeterende lus verandert van een gevaar in een betrouwbare motor al bestaat, volledig uitgewerkt, in de Six Sigma-DMAIC-cyclus, mits zij niet wordt gelezen als een eenmalig verbeterproject maar als de permanente besturingsstructuur van de automatisering, continu uitgevoerd. Elke fase levert iets wat de recursieve lus van Paragraaf 4 nodig heeft om haar winst positief en haar richting zuiver te houden; Figuur 1 tekent de cyclus en Tabel 3 brengt elke fase in kaart met haar rol.

Define. De lus heeft een doel nodig dat niet de proxy is die zij in de verleiding zal zijn na te jagen. Define benoemt de uitkomst die de automatisering dient, de toleranties die als succes tellen, en een eerlijke schatting van de bodem $\varepsilon_\ast$ waaronder verdere inspanning verspilling is, zodat de lus het bedrijfsresultaat optimaliseert en niet een handig surrogaat ervoor. De meeste op hol geslagen terugkoppelingsfalen zijn Define-falen: de lus verbeterde precies wat haar werd opgedragen, en dat was het verkeerde.

Measure. Er is geen verbeterwinst zonder een signaal, en Measure is de fase die er een vervaardigt, door elk geval te instrumenteren zodat de uitkomst, de correcties en de momenten van aarzeling worden vastgelegd, niet anekdotisch bemonsterd. Dit is de moderne vorm van Shewharts inzicht dat je niet kunt verbeteren wat je niet meet, en het is ook waar process mining (van der Aalst, 2016) zijn plaats verdient, door uit de eigen event-logs te reconstrueren wat het proces werkelijk deed, in plaats van uit hoe men zich voorstelde dat het liep.

Analyse. De karakteristieke fout van een leerlus is te reageren op ruis alsof het signaal was, zichzelf bijstellen tegen de normale spreiding van een stabiel proces en gaan zwalken. Analyse is de bewaker: zij scheidt common-cause-variatie, die met rust moet worden gelaten, van special-cause-variatie, waarop moet worden gehandeld, en zij wijst de actionabele fout toe aan een oorzaak die specifiek genoeg is om te verhelpen. Dit is Shewharts (1931) onderscheid dat precies het werk doet waarvoor het is uitgevonden, nu een automatisering behoedend voor het najagen van haar eigen staart.

Improve. Pas nu wordt een wijziging doorgevoerd: een herziening van de instructies van de agent, zijn voorbeelden, zijn gereedschappen, zijn controles, of de routering die een klasse van moeilijke gevallen naar een mens of een gespecialiseerd pad stuurt. Improve is de mutatiestap van de lus, de plek waar de winst $g$ daadwerkelijk wordt gerealiseerd, en zij komt bewust ná meting en analyse zodat de wijziging antwoordt op een gediagnosticeerde oorzaak in plaats van op een onderbuikgevoel.

Control. Control is de fase die het geheel veilig maakt, en het is waar de recursieve automatisering het scherpst verschilt van zowel een bot als een onbeheerst leersysteem. Een voorgestelde wijziging wordt niet aangenomen omdat zij beter lijkt; zij wordt alleen aangenomen als wordt gemeten, tegen achtergehouden gevallen, dat zij de uitkomst niet verslechtert, en anders wordt zij verworpen en de vorige versie behouden. Formeel, waarbij we $\widehat{\varepsilon}(m)$ schrijven voor de gemeten fout van een kandidaatherziening $m$,

waarbij $\gamma \ge 0$ een betrouwbaarheidsmarge is die voorkomt dat de poort door ruis voor de gek wordt gehouden. De poort heeft een precies effect op de lus: zij maakt de foutenreeks monotoon in verwachting,

zodat verbetering zich opstapelt en nooit wordt teruggegeven. Dit is wat de rauwe recursie van vergelijking (2) verandert van een toevalswandeling die overal heen kan drijven in een ratel die alleen maar aandraait, en het is de discipline die Statistical Process Control een eeuw geleden aan de maakindustrie heeft bijgedragen, nu toegepast op een automatisering die zichzelf herschrijft. Control doet ook de weinig glamoureuze andere helft van haar werk: zij standaardiseert en houdt de winst vast, door de verbeterde versie met haar vangrails op haar plaats te verankeren zodat de volgende cyclus begint vanaf de nieuwe bodem en niet de oude.

De koppeling is waar het om gaat. Recursie zonder DMAIC is een lus die met evenveel gemak kan verbeteren als verwoesten; DMAIC zonder recursie is het periodieke verbeterproject dat kwaliteitsteams altijd met de hand hebben uitgevoerd, begrensd door hoe vaak mensen kunnen samenkomen. Een agent die DMAIC uitvoert als zijn eigen permanente besturingsstructuur krijgt beide: de snelheid en reikwijdte van softwareverbetering en de convergentiegarantie van statistische beheersing.

6. De vervangingsvoorwaarde

We kunnen nu precies zeggen wanneer de agent de bot inhaalt. De twee automatiseringen staan tegenover dezelfde afdrijvende wereld, met dezelfde afdrijvingssnelheid $\delta$. De bot heeft geen interne winst en dus, volgens vergelijking (1), klimt zijn fout met afdrijving totdat een mens hem reset. De agent voert zijn DMAIC-lus uit met cyclustijd $\tau$, de tijd om één herziening te meten, te analyseren, voor te stellen en te poorten, en winst per cyclus $g$, terwijl diezelfde afdrijving $\delta$ zijn fout omhoog duwt. Over continue tijd combineren de twee krachten zich:

een leerterm die de fout omlaag trekt naar de bodem en een afdrijvingsterm die haar omhoog duwt. De stationaire toestand ervan, waar de lus precies gelijke tred houdt met de wereld, is

zodat de automatisering zich op een begrensde afstand boven de bodem houdt, bepaald door de verhouding tussen hoe snel de wereld afdrijft en hoe snel de lus leert. De bot, met $g \to 0$, heeft helemaal geen eindige stationaire toestand: zijn fout wordt alleen begrensd door het onderhoudsschema. Definieer het dimensieloze vervangingsgetal

de verhouding van de fout die een cyclus verwijdert tot de fout die afdrijving toevoegt over diezelfde cyclus. Wanneer $\Sigma > 1$ verwijdert de lus sneller fouten dan de omgeving ze injecteert en convergeert de automatisering naar een smalle band boven de bodem; wanneer $\Sigma \gg 1$ zit zij in wezen op de bodem. De agent vervangt de bot precies wanneer hij een beheerste lus kan draaien met $\Sigma > 1$, wat een uitspraak is over drie beheersbare grootheden: verhoog de winst $g$ met betere meting en toewijzing, verkort de cyclus $\tau$ met automatisering van de lus zelf, en de agent verslaat elke vaste bot in elke omgeving waarvan de afdrijving $\delta$ eindig is. Figuur 2 stelt de twee trajecten tegenover elkaar. De praktische lezing is dat vervanging geen kwestie is van de vraag of de agent op dag één slimmer is dan de bot, dat is hij vaak niet, maar van de vraag of zijn lus, onder besturing, sneller draait dan de wereld draait; en zodra dat zo is, lopen de zaagtand van de bot en de afdaling van de agent voorgoed uiteen.

7. Een geconstrueerde casus: crediteurenadministratie

De casus is geconstrueerd, niet waargenomen: de cijfers ervan zijn illustratief en intern consistent, en zij is bedoeld om de grootheden van het model plausibele waarden te laten aannemen, niet om een resultaat te rapporteren. Beschouw de crediteurenfunctie van een middelgrote groep die leveranciersfacturen in vele formaten over meerdere portalen ontvangt en die elke factuur moet matchen aan een inkooporder en een goederenontvangst, coderen, en ter betaling boeken. Het is het archetypische RPA-doelwit, hoogvolume, in regels te beschrijven, saai, en de archetypische RPA-teleurstelling, omdat de formaten voortdurend afdrijven en elke leverancier een uitzondering is die staat te gebeuren.

Het RPA-bestand van de groep handelt de schoonste leveranciersopmaken af en routeert al het overige naar mensen. Bij ingebruikname boekte het ongeveer 55 procent van de facturen rechtstreeks door, maar in de loop van achttien maanden drukten drie portaalupdates en een golf van nieuwe leveranciers het straight-through-percentage omlaag en het stilzwijgende foutenpercentage omhoog, zodat een vast team een groot deel van zijn week besteedt aan het heropnemen van kapotte bots en het najagen van verkeerde boekingen, Tabel 1 geeft de kolom van vóór. Het vervangen van de opgenomen bots door een agent die elke factuur leest voor wat zij is, haar matcht door te redeneren in plaats van op vaste coördinaten, en echte uitzonderingen naar een mens routeert, en het verpakken van die agent in een permanente DMAIC-lus, het straight-through-percentage is datgene wat Measure volgt, de correcties van elke week zijn het bewijs waaraan Analyse werkt, de prompts, voorbeelden en matchingcontroles van de agent zijn wat Improve herziet, en een achtergehouden steekproef is de poort die Control toepast, verandert zowel het niveau als de richting ervan. De agent begint slechts een weinig beter dan de bot maar, omdat zijn lus sneller draait dan de portalen afdrijven ($\Sigma > 1$), daalt zijn uitzonderingspercentage cyclus na cyclus naar de bodem die wordt gezet door de facturen die werkelijk menselijk oordeel vereisen, terwijl de onderhoudslast omkeert: in plaats van dat engineers opnames repareren, wordt het werk het beoordelen van de voorgestelde wijzigingen van de lus bij de Control-poort. Tabel 1 volgt de grootheden van het model door de casus heen.

8. Wat verandert er voor het bedrijfsmodel

Een agent in de plaats stellen van een bot is geen één-op-één-ruil van motoren onder dezelfde motorkap; het verandert wat de automatiseringsfunctie doet en waar zij goed in moet zijn. Tabel 2 zet de twee naast elkaar. De grootste verandering is waar de menselijke inspanning heen gaat. Onder RPA is het terugkerende menselijke werk reparatie: het vinden en heropnemen van de bots die de wereld kapot heeft gemaakt, een reactieve taak die meeschaalt met de omvang van het bestand en niets nieuws voortbrengt. Onder een DMAIC-beheerste agent is het terugkerende menselijke werk de Control-poort: het beoordelen van de door de lus voorgestelde herzieningen en het beslissen wat vast te leggen, een taak die meeschaalt met het verbetertempo in plaats van met de omvang van het bestand en die elke keer dat zij wordt gedaan een betere automatisering oplevert. De vaardigheden veranderen navenant, van het scripten van robots tegen schermen naar het definiëren van uitkomsten, het instrumenteren van processen en het beoordelen van bewijs, oftewel van automatiseringsengineering richting de discipline van kwaliteitsmanagement, nu uitgevoerd op de snelheid van software.

Er is een tweede verandering, in governance. Een systeem dat zijn eigen gedrag herschrijft, is krachtiger dan een opname en vraagt om meer verantwoording, niet minder, en DMAIC levert het auditspoor als bijproduct: elke vastgelegde wijziging antwoordt op een gemeten oorzaak, is door een vastgelegde poort gegaan, en kan worden toegewezen en teruggedraaid, zodat een zelfverbeterende automatisering, mits goed uitgevoerd, beter inspecteerbaar is dan de ondoorzichtige bot die zij vervangt, niet minder. De Control-fase is evenzeer een compliance-instrument als een kwaliteitsinstrument. Dit doet er het meest toe waar automatisering gereguleerd werk raakt, en het is dezelfde discipline, gemeten wijziging achter een poort, waarvoor wij elders in ons onderzoek naar gereguleerde IT hebben gepleit.

9. Bezwaren en weerleggingen

Een agent is per geval veel duurder dan een bot. Per geval, vandaag de dag, vaak wel, en voor een smalle, stabiele, hoogvolume taak waarvan de omgeving werkelijk niet afdrijft, kan een opgenomen bot de zuinige keuze blijven, en niets hier zegt het tegendeel. Het argument bijt waar de omgeving afdrijft, wat de meeste plekken zijn, want daar zijn de werkelijke kosten van de bot niet zijn prijs per geval maar zijn onderhoudsstaart en zijn stilzwijgende fouten, en de lus van de agent betaalt zijn hogere stuksprijs terug door beide weg te nemen. De vergelijking die gemaakt moet worden is de kosten over de levensduur tegen een afdrijvende omgeving, niet de stuksprijs op dag één.

Dit is gewoon RPA met een model eraan vastgeschroefd, wat de leveranciers al verkopen. Het is het tegenovergestelde. Een model in een vaste orkestratie schroeven, intelligente automatisering zoals die doorgaans wordt verkocht, behoudt de brosse besturingsstructuur en maakt de componenten ervan slimmer, dus het verhoogt het plafond een beetje en erft het verval. De bewering hier gaat over de besturingsstructuur zelf: het vervangen van de vaste orkestratie door een beheerste lus die de automatisering herschrijft vanuit haar eigen uitvoer. De motor is de kleinere helft van de verandering; de lus is de grotere.

Een zelfverbeterend systeem dat zijn eigen gedrag verandert, is een risico dat je niet kunt beheersen. Het is een risico, en onbeheerst is het een ernstig risico, wat de hele reden is waarom de tweede hoeksteen van het artikel een besturingsdiscipline is en geen model. Een agent die zichzelf bijstelt tegen een ruizig signaal zonder Analyse-fase en zonder Control-poort zal inderdaad afdrijven en achteruitgaan. Het antwoord is niet de lus te verbieden maar haar te beheersen met de methode die de maakindustrie een eeuw lang heeft gebruikt om zelfbijstellende processen te beheersen: meten, signaal van ruis scheiden, wijzigen tegen een gediagnosticeerde oorzaak, en alleen vastleggen wat een poort bewijst de zaak niet te verslechteren. Een beheerste lus legt meer verantwoording af dan een bot, niet minder.

Uw model is te eenvoudig; werkelijke fout daalt niet geometrisch. Het model is een bewuste vereenvoudiging en de constanten ervan zijn niet gemeten; het doel ervan is de structuur leesbaar te maken, dat een bot $g = 0$ heeft en een beheerste agent $g > 0$, en dat vervanging ervan afhangt of de lus de afdrijving voorbijstreeft. De geometrische vorm is het generieke gedrag van een proportionele regelaar tegen een bodem, geen precieze empirische wet, en Paragraaf 10 zegt dat ook. Het vervangingsgetal $\Sigma$ is bedoeld als een manier van denken, niet als een getal om tot op drie decimalen te citeren.

10. Beperkingen

Dit is een op de praktijk gericht betoog met een bewust eenvoudig model, en de grenzen ervan horen helder te zijn. Het model van Paragrafen 3 tot en met 6 is illustratief: de lineaire afdrijving van vergelijking (1), de constante winst van vergelijking (2) en de enkele bodem $\varepsilon_\ast$ zijn vereenvoudigingen gekozen omwille van de leesbaarheid, en werkelijke afdrijving is schoksgewijs, werkelijke winst neemt af naarmate de bodem nadert, en de bodem zelf beweegt mee als de taak verandert; het vervangingsgetal $\Sigma$ is een lens, geen gemeten grootheid, en wij hebben het niet tegen veldgegevens geschat. Het betoog is afgebakend tot processen die afdrijven en die een bruikbaar uitkomstsignaal dragen; een werkelijk stationaire, hoogvolume taak kan nog steeds de voorkeur geven aan een opgenomen bot, en een proces zonder meetbare uitkomst onthoudt de lus het signaal waarvan het hele mechanisme afhangt. De bewering gaat over een besturingsstructuur, niet over een product, en de specifieke agenttechnologie is jong en beweegt snel; een lezer zou de structuur moeten behouden, een beheerste recursieve lus verslaat een bevroren regel in een bewegende wereld, en de componenten opnieuw moeten bezien naarmate zij veranderen. Ten slotte is de winst nooit eerlijker dan de Measure- en Control-fasen: een organisatie die slecht instrumenteert, of de poort laat vervallen tot een stempelautomaat, krijgt de risico’s van de recursie zonder de convergentie ervan, wat een reden is om de discipline serieus te nemen, geen gebrek van het idee.

11. Conclusie

Robotische procesautomatisering deed iets nuttigs door op te nemen hoe een mens een systeem bedient en dat af te spelen, maar zij automatiseerde het oppervlak van een taak en bevroor het, en een bevroren regel in een bewegende wereld vervalt: zijn fout klimt met afdrijving, zijn onderhoudsrekening stijgt met zijn bestand, en zijn ergste falen zijn stilzwijgend. AI-agents vervangen haar niet door dezelfde regels met een duurdere motor af te spelen, maar door een lus te sluiten die een opname niet kan sluiten, door de automatisering te verbeteren vanuit haar eigen uitvoering, cyclus na cyclus. Die recursie is de eerste hoeksteen en, op zichzelf, evenzeer gevaar als hulp. De tweede hoeksteen is wat haar betrouwbaar maakt: de DMAIC-cyclus, gelezen niet als een eenmalig project maar als de permanente besturingsstructuur van de automatisering, Define het doel en de bodem, Measure elk geval, Analyse signaal van ruis, Improve tegen een gediagnosticeerde oorzaak, en Control met een poort die alleen vastlegt wat aantoonbaar de zaak niet verslechtert, zodat verbetering een ratel wordt en geen gok. In het model van het artikel is het verschil het verschil tussen een verbeterwinst van nul en een winst die betrouwbaar positief wordt gehouden, en de agent haalt de bot precies in wanneer zijn beheerste lus sneller fouten wegneemt dan de wereld ze injecteert. De engineering die volgt gaat minder over het model dat de factuur leest dan over de lus die eromheen is gebouwd, en de discipline die die lus nodig heeft is er een die de industrie een eeuw lang in bezit heeft gehad en nu kan uitvoeren op de snelheid van software. Automatiseer de taak, meet wat er gebeurt, verbeter tegen wat je meet, en laat niets de automatisering veranderen waarvan een poort niet heeft aangetoond dat het beter is. Een bot is een foto van een proces; een beheerste agent is het proces dat leert. Dat is de vervanging, en het is het geheel ervan.

Bijlage A. DMAIC uitvoeren als de besturingslus van een automatisering

De onderstaande praktijken zijn wat een recursieve automatisering doet convergeren in plaats van afdrijven. Geen ervan is nieuw voor AI; elk is de kwaliteitstraditie toegepast op een automatisering die zichzelf herschrijft.

Referenties

Argyris, C., & Schön, D. A. (1978). Organizational learning: A theory of action perspective. Addison-Wesley. ISBN 978-0-201-00174-3.

Ashby, W. R. (1956). An introduction to cybernetics. Chapman & Hall. http://pcp.vub.ac.be/books/IntroCyb.pdf

Benner, M. J., & Tushman, M. L. (2003). Exploitation, exploration, and process management: The productivity dilemma revisited. Academy of Management Review, 28(2), 238–256. https://doi.org/10.2307/30040711

Box, G. E. P. (1957). Evolutionary operation: A method for increasing industrial productivity. Journal of the Royal Statistical Society: Series C (Applied Statistics), 6(2), 81–101. https://doi.org/10.2307/2985505

Deming, W. E. (1986). Out of the crisis. MIT Center for Advanced Engineering Study. ISBN 978-0-911379-01-0.

Harry, M. J., & Schroeder, R. (2000). Six Sigma: The breakthrough management strategy revolutionizing the world’s top corporations. Currency/Doubleday. ISBN 978-0-385-49437-3.

Hofmann, P., Samp, C., & Urbach, N. (2020). Robotic process automation. Electronic Markets, 30(1), 99–106. https://doi.org/10.1007/s12525-019-00365-8

Lacity, M., & Willcocks, L. P. (2016). Robotic process automation at Telefónica O2. MIS Quarterly Executive, 15(1), 21–35. https://aisel.aisnet.org/misqe/vol15/iss1/4/

Linderman, K., Schroeder, R. G., Zaheer, S., & Choo, A. S. (2003). Six Sigma: A goal-theoretic perspective. Journal of Operations Management, 21(2), 193–203. https://doi.org/10.1016/S0272-6963(02)00087-6

Montgomery, D. C. (2024). Introduction to statistical quality control (8th ed.). Wiley. ISBN 978-1-119-72309-7.

Pyzdek, T., & Keller, P. A. (2023). The Six Sigma handbook (6th ed.). McGraw-Hill. ISBN 978-1-26-514399-2.

Shewhart, W. A. (1931). Economic control of quality of manufactured product. D. Van Nostrand. ISBN 978-0-87389-076-2 (ASQ reprint).

Shinn, N., Cassano, F., Gopinath, A., Narasimhan, K., & Yao, S. (2023). Reflexion: Language agents with verbal reinforcement learning. In Advances in Neural Information Processing Systems 36 (NeurIPS 2023). https://arxiv.org/abs/2303.11366

Sutton, R. S., & Barto, A. G. (2018). Reinforcement learning: An introduction (2nd ed.). MIT Press. ISBN 978-0-262-03924-6.

Syed, R., Suriadi, S., Adams, M., Bandara, W., Leemans, S. J. J., Ouyang, C., ter Hofstede, A. H. M., van de Weerd, I., Wynn, M. T., & Reijers, H. A. (2020). Robotic process automation: Contemporary themes and challenges. Computers in Industry, 115, 103162. https://doi.org/10.1016/j.compind.2019.103162

van der Aalst, W. M. P. (2016). Process mining: Data science in action (2nd ed.). Springer. https://doi.org/10.1007/978-3-662-49851-4

van der Aalst, W. M. P., Bichler, M., & Heinzl, A. (2018). Robotic process automation. Business & Information Systems Engineering, 60(4), 269–272. https://doi.org/10.1007/s12599-018-0542-4

Wang, L., Ma, C., Feng, X., Zhang, Z., Yang, H., Zhang, J., Chen, Z., Tang, J., Chen, X., Lin, Y., Zhao, W. X., Wei, Z., & Wen, J.-R. (2024). A survey on large language model based autonomous agents. Frontiers of Computer Science, 18(6), 186345. https://doi.org/10.1007/s11704-024-40231-1

Wewerka, J., & Reichert, M. (2023). Robotic process automation: A systematic mapping study and classification framework. Enterprise Information Systems, 17(2), 1986862. https://doi.org/10.1080/17517575.2021.1986862

Wiener, N. (1948). Cybernetics: Or control and communication in the animal and the machine. MIT Press. ISBN 978-0-262-73009-9.

Willcocks, L. P., Lacity, M., & Craig, A. (2015). The IT function and robotic process automation (The Outsourcing Unit Working Research Paper Series). London School of Economics and Political Science, LSE Research Online item 64519. http://eprints.lse.ac.uk/64519/

Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., & Cao, Y. (2023). ReAct: Synergizing reasoning and acting in language models. In International Conference on Learning Representations (ICLR 2023). https://arxiv.org/abs/2210.03629