In een eerdere post beschreef ik hoe ons Meeting Automation Center langzaam "uit de hand liep". Wat begon als een simpele automatisering, groeide uit tot een volwaardig platform met dashboards, configuratielagen en operationele controle. Niet omdat we dat vooraf zo hadden bedacht, maar omdat het bouwen ons daar naartoe duwde.
Die bouwreis maakte één ding duidelijk: dit verhaal gaat niet alleen over meetings. Het raakt aan iets groters. Aan een fundamentele verschuiving in hoe software zich verhoudt tot werk.
In deze post zoom ik daarom uit. Weg van onze eigen tooling, weg van implementatiedetails. Wat gebeurt er met software wanneer het niet langer vooral ondersteunt, maar daadwerkelijk werk uitvoert? En waar houdt "slimme SaaS" op, en begint iets anders?
Waarom het huidige softwaremodel vastloopt
De afgelopen twintig jaar is ons werkleven gedigitaliseerd in de vorm van SaaS. CRM's, projectmanagementtools, HR-systemen, portals, dashboards. Allemaal gebouwd met hetzelfde uitgangspunt: mensen helpen om hun werk efficiënter te doen.
En dat heeft enorm veel gebracht. Werk werd inzichtelijker, processen herhaalbaar, informatie toegankelijk.
Maar ondanks al die tools zijn we nog steeds een groot deel van onze tijd bezig met handmatig werk. We typen, klikken, kopiëren, plakken, schrijven mails, zetten taken door. Digitale hulpmiddelen, maar het werk zelf blijft opvallend mens-intensief.
Het zijn tools. Maar de gebruiker moet het werk nog steeds dóén.
We staan op een kantelpunt. Software verandert fundamenteel. En niet in de vorm van nóg een app, nóg een interface, nóg een feature.
De grote verschuiving: van applicaties naar autonome systemen
AI verandert niet alleen hoe we met software interacteren, maar wat software in essentie is.
In plaats van applicaties die draaien om schermen, knoppen en features, ontstaan er systemen die draaien om doelen en processen. Workflow-native software. Niet: "klik hier om iets te doen", maar: dit is het werk dat moet gebeuren – regel het.
Dat vraagt om software die context kan meenemen. Niet omdat het "alles begrijpt", maar omdat context expliciet wordt vastgelegd: in data, in templates, in regels, in voorkeuren, in rollen en rechten. Context is geen magie. Het is ontwerp.
En het vraagt om autonomie. Niet volledige autonomie, niet blind vertrouwen, maar wel systemen die zelfstandig stappen uitvoeren: samenvatten, structureren, verrijken, opvolgen, communiceren. Zonder dat er telkens een mens tussen hoeft te zitten.
Autonomie betekent hier nog niet "zelf beslissen", maar betrouwbaar uitvoeren binnen duidelijke kaders. Zonder inzicht, controle en begrenzing wordt autonomie geen vooruitgang, maar een risico.
Van tools naar capabilities
In deze manier van denken verschuift ook hoe software is opgebouwd. Grote, allesomvattende applicaties maken langzaam plaats voor kleinere bouwstenen: capabilities.
Een capability is geen feature en geen knop, maar een zelfstandige actie die software kan uitvoeren. Iets ophalen. Iets classificeren. Iets structureren. Iets opslaan. Iets communiceren. Met een duidelijk doel, een expliciet input- en outputcontract en duidelijke grenzen.
De kracht zit niet in de individuele capability, maar in hoe ze worden gecombineerd. Capabilities vormen samen workflows — niet hard gecodeerd als één vast proces, maar samenstelbaar op basis van hoe een organisatie werkt.
Daarmee verschuift iets fundamenteels. Het proces zelf wordt geen productfeature meer, maar een samenstelling van bouwstenen. De volgorde, de voorwaarden en de uitzonderingen liggen niet langer vast in code, maar worden expliciet gemaakt.
Tot dit punt voelt dit nog als "gewoon heel goed ingerichte SaaS". En eerlijk gezegd: tot hier is het dat ook.
Maar dan….
Van configureerbare workflows naar lerende systemen
Zolang software alleen uitvoert wat is ingesteld, blijft het configuratie. Hoe slim ook. Hoe flexibel ook. De mens ontwerpt het proces, de software voert het uit, en de mens past het weer aan als het niet goed werkt.
De volgende stap ontstaat op het moment dat software zicht krijgt op de kwaliteit van haar eigen output.
Wanneer een systeem (laten we als voorbeeld ons eigen Meeting Automation Platform nemen) kan zien waar mensen ingrijpen:
- notulen die worden aangepast
- taken die worden verwijderd
- mails die niet worden verstuurd
- workflows die opnieuw worden uitgevoerd
ontstaan er signalen. Geen fouten, maar feedback. Informatie over wat werkt en wat niet. Vanaf dat moment kan software meer doen dan uitvoeren. Het kan patronen herkennen en voorstellen doen:
"Deze template of prompt leidt vaak tot correcties." "Deze stap wordt bijna altijd overgeslagen." "Deze volgorde werkt in vergelijkbare contexten beter." "Wil je dit anders instellen?"
Hier verschuift autonomie van uitvoering naar verbetering.
Niet door processen zomaar om te gooien, maar door onderbouwde suggesties te doen. Eerst met de mens aan het stuur. Met bewijs. Met context. Met de mogelijkheid om te accepteren of te weigeren.
Hoe je dit precies bouwt is allesbehalve triviaal. Dat ontdekken we nu pas echt.
Waarom dit fundamenteel anders is dan slimme SaaS
Goede SaaS kan flexibel zijn. Configureerbaar. Uitbreidbaar. Maar het procesmodel ligt vrijwel altijd vast. Configuratie past parameters aan; het verandert zelden het proces zelf.
Software die haar eigen gedrag kan evalueren en daar consequenties aan verbindt, breekt door die grens heen. Workflows worden objecten die:
- versioned zijn
- gemeten worden
- vergeleken kunnen worden
- zich in de tijd ontwikkelen
Dat is geen hype en geen sciencefiction. Het is een logisch gevolg van systemen die op schaal werk uitvoeren en die output analyseren en gebruiken.
Wat dit betekent voor bedrijven en bouwers
Software wordt tailormade en persoonlijk, heeeel persoonlijk. Het past zich aan aan hoe het bedrijf werkt in plaats van andersom.
Voor bedrijven verschuift de vraag. Minder: "welke tools hebben we nodig?" Meer: "welk werk willen we autonoom laten gebeuren, en waar willen we inzicht en controle?"
Voor softwarebouwers verandert de rol minstens zo sterk. We ontwerpen niet alleen functies, maar gedrag. Niet alleen uitvoering, maar feedbackloops. Niet alleen code, maar systemen die begrijpen hoe goed ze presteren.
Dat vraagt om volwassenheid: logging, observability, versiebeheer, rollback. Niet als bijzaak, maar als fundament.
Tot slot
We zijn er nog lang niet. Systemen die leren zijn fragiel. AI maakt fouten. Soms subtiel, soms zichtbaar.
Maar juist daarom is dit moment interessant. Niet omdat alles al kan, maar omdat we nu ontdekken hoe software eruitziet wanneer het niet alleen ondersteunt, maar daadwerkelijk werk uitvoert… en langzaam leert hoe dat werk beter kan.
Software verschuift. Van tools naar workflows. Van workflows naar capabilities. Van capabilities naar systemen die kunnen verbeteren.
Niet in één grote sprong, maar in kleine, gecontroleerde stappen.
In de volgende post ga ik in op hoe wij dit proberen te bouwen in de praktijk. En… wat we leren in de weg daar naar toe. We zijn onvermoeibaar benieuwd naar alle mogelijkheden en ontdekkingen en bouwen naar de toekomst toe!