Je sleept een node op een canvas, verbindt twee pijlen en klikt op Run. Een paar seconden later bestaat er een account, is er een welkomstmail de deur uit, en is een record in je CRM up-to-date. Dus wat gebeurde er eigenlijk daartussenin?
Een Rylo-flow is een klein, eerlijk contract: wat je tekent, is wat er draait. Er is geen verborgen vertaallaag, geen gegenereerde code waar je op moet passen. Maar "eenvoudig te tekenen" en "eenvoudig onder de motorkap" zijn niet hetzelfde. Dit is de reis die een run aflegt.
1. Het canvas is de bron van waarheid
Elke flow is een graaf van getypeerde nodes — een startgebeurtenis, agent-taken, gateways, integraties en een einde. Als je ze verbindt, schets je geen diagram dat iemand later in software omzet; je definieert het uitvoerbare ding zelf. Elke node geeft aan wat hij nodig heeft (zijn invoer) en wat hij produceert (een benoemde uitvoer), zodat het canvas altijd weet welke data op elk punt verderop beschikbaar is.
2. Een run is een token die door de graaf loopt
Druk op Run en Rylo maakt een run: een geïsoleerde uitvoering met een eigen context. Een token komt binnen bij de start en loopt door de graaf, één node per keer. Elke node leest uit de gedeelde context, doet zijn werk en schrijft het resultaat terug onder zijn uitvoernaam — zodat een latere stap kan verwijzen naar {{context.customer}} zonder dat iemand de data met de hand hoeft te koppelen.
Bij de gateways wordt het interessant. Een beslissingsnode inspecteert de context en kiest een tak: escaleren of afronden, goedkeuren of markeren. De token volgt precies één pad, en de run legt vast welk — zodat de historie leest als een verhaal, niet als een lograwel.
Het diagram dat je in dertig seconden aan een collega kunt uitleggen, is hetzelfde artefact dat in productie draait. Dat is het hele punt.
3. Agents doen de vage stukken
Sommige nodes zijn deterministisch — een API aanroepen, een rij wegschrijven, een mail versturen. Andere zijn agent-taken: je beschrijft de klus in gewone taal en de agent gebruikt de tools die je eraan hebt gekoppeld om het voor elkaar te krijgen. De flow blijft de baas over de orchestratie (volgorde, vertakking, retries); de agent neemt het oordeel binnen één enkele stap voor zijn rekening. Die twee zaken gescheiden houden is wat het systeem debugbaar maakt.
4. Integraties maken het echt
Een flow die alleen nadenkt, is speelgoed. De connector-nodes zijn de plek waar een run de buitenwereld raakt — je e-mail, databases, interne API's, CRM. Doordat elke integratie zijn eigen node is, is een storing afgebakend en zichtbaar: je ziet precies de stap die een systeem niet kon bereiken, voert alleen die stap opnieuw uit en gaat verder.
5. Elke run is observeerbaar
Als de token het einde bereikt, krijg je geen mysterieus "klaar". Je krijgt een tijdlijn: welke nodes liepen, wat elk produceerde, waar een mens ingreep, hoe lang het duurde. Dat verslag is wat een flow verandert van "het werkte op mijn machine" in iets waar een ops-team om 3 uur 's nachts op kan vertrouwen.
Van canvas naar productie is een korte reis, juist omdat er geen omweg is. Je tekent het proces, een token loopt erdoorheen, en de systemen die je hebt verbonden komen in beweging. De magie zit hem niet in slimheid — het is dat er niets verborgen is.
Benieuwd hoe jouw eerste flow eruit zou zien?
Demo aanvragen
