Enterprise Information & Graph-Native Intelligence
Structureer systemen.Begrijp relaties.Bouw echte software.
YiENTi representeert processen, relaties, afhankelijkheden en softwarestructuren expliciet, in plaats van uitsluitend te vertrouwen op taalgebaseerde context.
- YiENTi Enterprise
- Intelligent Enterprise Information
- YiENTi Intelligence
- Graph-Native Intelligence Engine
YiENTi combineert een Intelligent Enterprise Information-platform met een Graph-Native Intelligence Engine. Het kan waar nuttig taalmodellen gebruiken, maar het kernredeneermodel is structureel, procesbewust en onafhankelijk van één enkele LLM-aanbieder.
Een gebeurtenis activeert een proces. Context en regels worden relevant. De gateway leidt tot een beslissing.
- Sinds 2010
- Evolutie van Logical Board naar YiENTi
- Twee pijlers
- Enterprise Information + Intelligence Engine
- LLM-optioneel
- Aanbieders zijn vervangbare componenten
- In gebruik
- Kerntechnologie in de engineering van ACCENTSYS
Het YiENTi-platform
Eén visie. Twee kerntechnologieën.
YiENTi is een overkoepelende technologie met twee afzonderlijke, onderling verbonden pijlers. De ene weerspiegelt de operationele realiteit van een organisatie. De andere redeneert over gestructureerde context — binnen YiENTi Enterprise en daarbuiten.
- Gestructureerde enterprise-informatie
- Procesintelligentie
- Graph-native redeneren
- Intelligentie voor software-engineering
YiENTi Enterprise
Intelligent Enterprise Information
Verbind mensen, processen, systemen, taken, kennis en operationele context in een gestructureerde enterpriseomgeving.
Ontdek YiENTi EnterpriseYiENTi Intelligence
Graph-Native Intelligence Engine
Redeneer over relaties, processen, status, context, softwarestructuren en multimodale informatie.
Ontdek YiENTi IntelligenceYiENTi staat centraal
YiENTi vormt het centrum. Al het andere is ermee verbonden.
YiENTi is de kern voor structurele intelligentie en engineering. Cloudplatforms, taalmodellen, Playwright, IDE's en lokale AI-tooling zijn gekoppelde systemen rondom YiENTi, elk met een eigen rol. Ze zijn niet YiENTi zelf.
Gestructureerde modellering
Waarover YiENTi redeneert · → YiENTi
BPMN · Use cases · Activiteiten · Sequenties · Klassen · Data-/entiteitsmodellen
Generatieve AI
Extern · vervangbaar · ↔ YiENTi
OpenAI · Anthropic · Perplexity · Gemini · Lovable · Zapier · Pickaxe · Grok · Jasper · Abacus.AI · Relevance AI · Notion AI · En binnenkort meer · Lokale / alternatieve modellen
Developertooling
Ontwikkelomgeving · ↔ YiENTi
Visual Studio Code · OpenCode
Lokale infrastructuur / modelinfrastructuur
Modellen lokaal draaien · ↔ YiENTi
Ollama · Lemonade · Andere compatibele lokale modelworkflows
Testen
Validatie van echt gedrag · ↔ YiENTi
Playwright · Abacus.AI · ChatGPT Work · Visuele validatie · Functionele validatie
Deployment
Waar gegenereerde software draait · YiENTi →
AWS · Microsoft Azure · Google Cloud · Private infrastructuur (toekomst)
Echte software
Gebouwd met YiENTi · YiENTi →
Elk ACCENTSYS-product
De structurele kern
Taal is een interface.
De graaf is het model.
Deze structuren zijn geen decoratieve diagrammen. Ze representeren de voor machines begrijpelijke toestand van systemen en processen: het model waarover YiENTi redeneert.
- BPMN
- Procesmodellen
- Activiteitendiagrammen
- Use cases
- Samenwerkingsdiagrammen
- Sequentiediagrammen
- Klassenmodellen
- Entiteits-/datamodellen
- Regels
- Afhankelijkheden
- Toestand
- Requirements
- User stories
Meting · een kernfunctie van YiENTi
Structureer het. Meet het. Leer ervan.
Meting is geen dashboardfunctie. YiENTi koppelt de uitvoering van een proces aan wat die uitvoering daadwerkelijk oplevert — en zet dit om in machinaal begrijpelijke kennis over hoe werk in werkelijkheid presteert.
01 · YiENTi Enterprise
Procesuitvoering
- Taak AHoog
- Taak BNormaal
- Taak CNormaal
Prioriteit en gewicht maken deel uit van de structuur.
02 · Meting
Wat er daadwerkelijk gebeurde
Werk & inspanning
- Prioriteit
- Taak
- Tijd / inspanning
- Taakgewicht / hoeveelheid
- Tijd in verhouding tot taakgewicht
- Kwantitatieve prestaties
Output & resultaat
- Kwaliteit
- Herwerk / nieuw vervolgwerk
- Inhoud die in het eindproduct terechtkomt
- Hergebruik
- Efficiëntie
Mensen & vermogen
- Rollen
- Competenties
- Vaardigheden
- Onbenut potentieel
03 · YiENTi AI
Redeneert over meetbare werkelijkheid
Leren · verbeteren · hergebruiken
YiENTi meet niet alleen hoe lang iemand heeft gewerkt. Het kan inspanning in verband brengen met de structuur, het gewicht, het resultaat, de kwaliteit en het hergebruik van het werk.
Tijd in verhouding tot taakgewicht · schematisch
Taak A
Taak B
Dezelfde uren. Ander gewicht. Een ander prestatiebeeld.
Structuur
YiENTi Enterprise
Biedt de gestructureerde operationele en procescontext: processen, taken, rollen, prioriteiten en het gewicht van het werk.
Werkelijkheid
Meting
Legt vast wat er binnen die structuur daadwerkelijk gebeurt: inspanning, resultaat, kwaliteit, herwerk en hergebruik.
Redeneren
YiENTi AI
Redeneert over die meetbare werkelijkheid — niet alleen over beschrijvingen van hoe het werk zou moeten verlopen.
YiENTi leert niet alleen van beschrijvingen van werk. Het kan redeneren over gestructureerde processen en de meetbare resultaten die daaruit voortkomen.
Deze koppeling maakte al deel uit van de YiENTi-architectuur die in 2016 werd gepresenteerd: operationele processen gekoppeld aan meetbare output en aan YiENTi AI.
Pijler A · Intelligent Enterprise Information
YiENTi Enterprise
YiENTi Enterprise verbindt mensen, processen, systemen en kennis in één gestructureerde operationele omgeving.
Een intelligent platform voor bedrijfsinformatie om de relaties tussen mensen, werk, processen, systemen en informatie te modelleren en te beheren. Integratie is een van de mogelijkheden — niet de definitie ervan.
- Mensen
- Rollen
- Competenties
- Teams
- Taken
- Projecten
- Activiteiten
- Processen
- Middelen
- Systemen
- Documenten
- Communicatie
- Gebeurtenissen
- Regels
- Data
- Kennis
- Metingen
- Beslissingen
- Afhankelijkheden
- Enterprise-workflows
Diagram A · YiENTi Enterprise Information
Pijler B · Graph-Native Intelligence Engine
YiENTi Intelligence
YiENTi Intelligence is een graph-native intelligence engine, ontworpen om te redeneren over entiteiten, relaties, processen, context, softwarestructuren en visuele informatie.
De rol ervan reikt verder dan het YiENTi Enterprise-platform. De kerntechnologie van YiENTi Intelligence wordt intern al gebruikt in de softwareengineering-workflows van ACCENTSYS; het zelfstandige platform is nog in ontwikkeling.
Een ander pad naar algemene machine-intelligentie.
Voorbij YiENTi Enterprise
YiENTi Intelligence is niet slechts de AI-module binnen YiENTi Enterprise. Het is ontworpen als een herbruikbare intelligentielaag, en software die ermee is ontworpen, maakt niet automatisch deel uit van het Enterprise-platform:
- Softwareengineering bij ACCENTSYSIn intern gebruik
- Andere ACCENTSYS-productenRichting
- Toekomstige externe systemenRichting
- Andere use cases voor gestructureerd redenerenRichting
Diagram B · YiENTi Intelligence-graaf
Structurele context
- Entiteiten
- Relaties
- Context
- Toestand
- Regels
- Afhankelijkheden
- Visuele structuren
- Kennis
YiENTi Intelligence Graph
Verbonden, persistent en expliciet — de redeneercontext zelf.
Redeneerfuncties
- Begrijpen
- Redeneren
- Vergelijken
- Voorspellen
- Aanbevelen
- Plannen
- Orkestreren
Hoe YiENTi werkt
Van gestructureerde werkelijkheid naar redeneren — en terug.
YiENTi Enterprise representeert wat er bestaat, wie erbij betrokken is, wat er gebeurt, hoe werk verloopt, wat waarvan afhankelijk is en in welke staat de organisatie zich bevindt. YiENTi Intelligence redeneert over die gestructureerde context.
- 01Enterprise
Representeren
Mensen, systemen, informatie, taken, processen en context worden gestructureerde, onderling verbonden informatie.
- 02Intelligence
Begrijpen
YiENTi Intelligence redeneert over relaties, afhankelijkheden, toestand en context.
- 03Intelligence
Beslissen
Regels, beperkingen, historische context en redeneren ondersteunen beslissingen.
- 04Beide
Orkestreren
Acties, systemen en workflows kunnen worden gecoördineerd binnen vastgelegde regels en verantwoordelijkheden.
- 05Enterprise
Leren / Bijwerken
De gestructureerde omgeving verandert naarmate het werk vordert en nieuwe informatie beschikbaar komt.
Een continu proces: elke bijgewerkte toestand wordt de context voor de volgende redeneerronde.
Gestructureerde intelligentie · niet LLM-first
Taal is een interface.
De graaf is het model.
Grote taalmodellen zijn nuttige generatieve taalcomponenten. YiENTi kan ze inzetten waar ze helpen, maar is voor zijn bron van waarheid niet afhankelijk van gegenereerde tekst. Processen, relaties, toestanden, afhankelijkheden en structuren worden expliciet gemodelleerd.
YiENTi representeert de structuur achter de informatie.
- Processen worden gerepresenteerd als processen.
- Relaties worden gerepresenteerd als relaties.
- Afhankelijkheden worden gerepresenteerd als afhankelijkheden.
- Toestand wordt gerepresenteerd als toestand.
Taal is één van de manieren waarop mensen met die structuur werken.
LLM-first systemen ontlenen een groot deel van hun gedrag aan probabilistische modelinferentie. De kern van de redeneercontext van YiENTi is een expliciete structurele representatie van entiteiten, relaties, processen, toestand en afhankelijkheden.
De vraag is niet alleen welke invoer een systeem accepteert. Het gaat erom of de operationele waarheid ervan bestaat als een probabilistisch gegenereerde representatie, of als expliciete gestructureerde toestand.
Gestructureerde intelligentie versus LLM-first redeneren
Waar taalmodellen uitblinken
- Tekstgeneratie
- Samenvatten
- Vertalen
- Interactie in natuurlijke taal
- Informatie-extractie
- Ideeën genereren
- Documentondersteuning
Waar structuur expliciet moet blijven
- Exacte procestoestand
- Herhaalbaarheid
- Traceerbaarheid
- Integriteit van afhankelijkheden
- Correctheid van workflows
- Consistentie van softwarearchitectuur
- Persistent gestructureerd geheugen
Probabilistische AI kan het proces ondersteunen. Ze hoeft het proces niet te bepalen.
Gegenereerde taal kan onzeker zijn. Expliciete proces- en graaftoestand hoeft niet uit gegenereerde tekst te worden gereconstrueerd. YiENTi is ontworpen om kritieke procestoestand, afhankelijkheden en operationele waarheid buiten probabilistische taalgeneratie te houden, zodat er minder op wordt vertrouwd waar structurele nauwkeurigheid en herhaalbaarheid ertoe doen.
Modelonafhankelijke taallaag
YiENTi kan LLM's gebruiken. Het is er niet van afhankelijk om te weten wat het systeem is.
Vervangbare providers
- OpenAI-modellen
- Anthropic-modellen
- Lokale modellen
- Open modellen
- Toekomstige providers
Taallaag
- Tekstgeneratie
- Samenvatten
- Vertalen
- Interactie in natuurlijke taal
- Contentondersteuning
Architectuur van YiENTi Intelligence
Graaf, toestand, processen, regels en afhankelijkheden, onafhankelijk van de gekozen modelprovider.
Taalmodellen zijn optionele, vervangbare componenten die in YiENTi kunnen worden ingeplugd waar generatieve mogelijkheden nuttig zijn. Ze zijn componenten van de architectuur, niet het structurele kernmodel voor redeneren.
Procesachtergrond
Van procesbegrip naar machinaal redeneren.
YiENTi is gebouwd rond het idee dat complexe systemen niet betrouwbaar te begrijpen zijn als hun relaties en processen alleen bestaan als documenten of beschrijvingen.
Processen, activiteiten, rollen, events en afhankelijkheden moeten bestaan als expliciete, door machines te begrijpen structuren.
- Activiteiten
- Taken
- Events
- Gateways
- Conversaties
- Choreografieën
- Samenwerking
- Swimlanes
- Data
- Rollen
- Competenties
- Resources
- Projecten
- Processtructuren
- Meting
- Informatiestromen
Visueel en structureel redeneren
YiENTi beschrijft een proces niet alleen. Het representeert het proces.
Activiteiten, afhankelijkheden, toestanden, actoren en informatiestromen worden expliciete onderdelen van de redeneercontext. Visuele en diagrammatische structuren kunnen expliciet worden gerepresenteerd en erover kan worden geredeneerd.
- Activiteitendiagrammen
- Procesdiagrammen
- Samenwerkingsdiagrammen
- Systeemarchitectuur
- Afhankelijkheidsgrafen
- Rollen
- Events
- Toestandsovergangen
- Informatiestroom
Software engineering
Softwareontwikkeling zonder context telkens opnieuw op te bouwen uit prompts.
YiENTi houdt structurele context bij over systemen, processen en afhankelijkheden, zodat engineeringbeslissingen kunnen worden beredeneerd als onderdeel van een samenhangend model.
Gangbare ontwikkeling met LLM-ondersteuning
- Prompt
- Gegenereerde output
- Review
- Nieuwe prompt
- Opnieuw opgebouwde context
Bij elke iteratie wordt de context opnieuw opgebouwd.
Het engineeringmodel van YiENTi
- Requirements
- Expliciet gestructureerd model
- Systemen · processen · afhankelijkheden
- Redeneren
- Implementatie
- Validatie
- Bijgewerkte structurele toestand
Context blijft behouden als structuur en evolueert mee met het systeem.
Modelgedreven software-engineering
Van model naar software.
YiENTi gokt software niet op basis van prompts. Het gebruikt gestructureerde systeemrepresentaties, verbindt meerdere views van hetzelfde systeem en redeneert daarover heen — en kan het genereren van software op basis van die modellen ondersteunen of uitvoeren.
Gebouwd met YiENTi.
Niet afhankelijk van YiENTi.
YiENTi kan software ontwerpen en genereren op basis van gestructureerde modellen. De resulterende applicatie draait onafhankelijk van YiENTi.
YiENTi maakt deel uit van het engineeringproces — niet van een verplichte runtime-afhankelijkheid.
- 01
Requirements
- 02
EPICs /
User Stories - 03
Use cases
- 04
Activiteiten-/
procesmodellen - 05
Collaboratie-/
sequentiemodellen - 06
Klassen-/
datamodellen - 07
Architectuur /
redeneren - 08
Gegenereerde implementatie
- 09
Validatie
- 10
Standalone software
Conceptuele keten. Lees van links naar rechts, rij voor rij.
Modellagen waarover YiENTi redeneert
Geen losse tekeningen, maar verbonden projecties van één onderliggend systeemmodel.
- EPICs
- User Stories
- Use cases
- Activiteitendiagrammen
- Collaboratiediagrammen
- Sequentiediagrammen
- Klassendiagrammen
- Data-/entiteitsmodellen
- BPMN-/procesmodellen
- Regels
- Afhankelijkheden
- Toestanden
YiENTi tijdens het engineeren
- Requirements
- Modellen
- Redeneren
- Architectuur
- Generatie
- Validatie
Resulterende applicatie
- Frontend
- Backend
- Database
- API's
- Bedrijfslogica
- Integraties
draait onafhankelijk
Een gegenereerde applicatie heeft in productie geen YiENTi-runtime, cloud, agent of verbinding nodig — tenzij een specifiek product bewust dergelijke diensten gebruikt. Software die met YiENTi is gemaakt, maakt bovendien niet automatisch deel uit van het YiENTi Enterprise-platform.
Diagrammen zijn geen documentatie achteraf
In YiENTi zijn modellen niet louter plaatjes die software documenteren nadat die is gebouwd. Ze vertegenwoordigen de structuur waaruit over software kan worden geredeneerd en waaruit software kan worden gevalideerd en gegenereerd.
Een softwaresysteem kan worden beschreven via complementaire views — epics, user stories, use cases, activiteiten-, collaboratie-, sequentie- en klassendiagrammen, entiteit-relatiemodellen, processen, toestanden, regels en afhankelijkheden. Dit zijn geen losse tekeningen. Het zijn projecties van één onderliggend systeemmodel, en YiENTi is ontworpen om daarover heen te redeneren, zodat een wijziging in één view tegen de andere kan worden geanalyseerd.
Visueel betekent niet beeldherkenning. Een vak, knooppunt, kant, gateway of relatie is niet slechts een pixel. Het heeft een gedefinieerde betekenis — en die betekenis wordt onderdeel van het redeneermodel.
YiENTi maakt een verbonden representatie van het systeem, zodat requirements, processen, softwarestructuren en data niet als losstaande documenten hoeven te bestaan.
Meerdere views, één systeemmodel
- 01User story
Wat de gebruiker nodig heeft
“Als klant wil ik een artikel aan mijn winkelwagentje toevoegen, zodat ik het later kan bestellen.”
- 02Use case
Wat de actor wil bereiken
- 03Activiteit
Hoe het proces verloopt
- 04Collaboratie
Welke componenten samenwerken
- 05Sequentie
In welke volgorde interacties plaatsvinden
- 06Klasse / gegevens
Welke objecten en relaties er bestaan
- 07Implementatie
Gegenereerd uit de structuur
// generated from the model class Cart { items: Article[] add(a: Article): void checkout(): Order }
- 08Applicatie
Draait zelfstandig
Eén systeem, vele projecties. “Winkelwagentje” heeft in elke weergave dezelfde betekenis. Illustratief voorbeeld.
Codegeneratie is geen LLM-codegeneratie
YiENTi hoeft de applicatie niet te raden op basis van een prompt. Het werkt vanuit een expliciet model van wat de applicatie is.
LLM's kunnen waar nuttig helpen bij teksten, documentatie, labels, interpretatie van natuurlijke taal en codesuggesties. De softwarearchitectuur hangt niet uitsluitend af van probabilistisch gegenereerde broncode.
Prompt-first generatie
YiENTi modelgedreven
- PromptExpliciet gestructureerd model
- AI schrijft een deel van de codeExpliciete systeemrelaties en redeneren
- Context per verzoek opnieuw opgebouwdRegelgebaseerde generatie waar passend
- Broncode als enige waarheidModel als machineleesbare bron van waarheid
YiENTi lijkt meer op een intelligente engineeringomgeving die werkt als een compiler voor complexe systemen, dan op een AI-afhankelijkheid die in elke applicatie is ingebouwd.
De hier getoonde flow is conceptueel. De exacte interne pipeline kan afwijken, en niet elke fase wordt als volledig geautomatiseerd gepresenteerd. Traceerbaarheid, consistentiecontroles, impactanalyse en synchronisatie tussen modellen beschrijven de richting van de modelgedreven aanpak.
Model- en developertooling
YiENTi zet de juiste intelligentie in voor de juiste taak.
Generatieve modellen versnellen taken waarbij probabilistische generatie efficiënt is. YiENTi behoudt het gestructureerde systeemmodel, de procescontext en de meetbare status.
Gedelegeerd aan generatieve modellen
- UI-iteratie
- Tekstgeneratie
- Formulering
- Documentatie
- Snel generatief werk
- Geselecteerde codeerondersteuning waar passend
Behouden door YiENTi
- Gestructureerd systeemmodel
- Procescontext
- Meetbare status
Generatieve AI
Extern · vervangbaar
- OpenAI
- Anthropic
- Perplexity
- Gemini
- Lovable
- Zapier
- Pickaxe
- Grok
- Jasper
- Abacus.AI
- Relevance AI
- Notion AI
- En binnenkort meer
- Lokale / alternatieve modellen
Lokale infrastructuur / modelinfrastructuur
Modellen lokaal draaien
- Ollama
- Lemonade
- Andere compatibele lokale modelworkflows
Developertooling
Ontwikkelomgeving
- Visual Studio Code
- OpenCode
Dit zijn gekoppelde systemen met afzonderlijke rollen. Ze maken geen deel uit van YiENTi zelf en bieden niet allemaal dezelfde mogelijkheden. Namen van derden zijn handelsmerken van hun respectieve eigenaren; er wordt geen samenwerking of goedkeuring geïmpliceerd.
Testen & validatie
Van model naar geverifieerd gedrag.
Gegenereerde code is niet het doel — correct gedrag is dat wel. Playwright kan worden gebruikt om te controleren of de daadwerkelijke applicatie zich gedraagt en wordt weergegeven zoals verwacht, waardoor een feedbacklus ontstaat tussen model, implementatie, daadwerkelijke UI en validatie.
- 01
YiENTi
Model & redeneren
- 02
Gegenereerde /
aangepaste applicatie Implementatie
- 03
Playwright
Inspecteert de draaiende app
- 04
Visuele + functionele validatie
Weergave en gedrag zoals verwacht?
- 05
Feedback
Terug in de engineeringiteratie
Playwright is een test- en validatietool — geen onderdeel van de AI-laag.
Geautomatiseerde deployment
Gebouwd met YiENTi. Niet afhankelijk van YiENTi.
Met YiENTi ondersteunde workflows kunnen software automatisch uitrollen naar AWS, Microsoft Azure en Google Cloud. YiENTi is geen hostingprovider en de gedeployde applicatie draait niet binnen YiENTi.
YiENTi is ontworpen om infrastructuuronafhankelijk te blijven. Toekomstige deployment-opties zijn bedoeld om naast publieke cloudplatforms ook private en door de klant beheerde infrastructuur te omvatten.
YiENTi engineeringomgeving
Waar software wordt gemodelleerd, gegenereerd, gevalideerd en uitgebracht.
Gestructureerde modellen
BPMN, use cases, klassen, data
YiENTi
Structureel model & redeneren
Implementatie / generatie
Broncode geproduceerd of aangepast
Playwright-validatie
Visuele en functionele controles van de draaiende app
Deployment-pipeline
Geautomatiseerde build en release
- Bevat het gestructureerde model
- Genereert of wijzigt de implementatie
- Valideert het echte gedrag
- Start de geautomatiseerde deployment
Runtime-omgeving van de applicatie
Waar de voltooide applicatie draait.
- AWS
- Microsoft Azure
- Google Cloud
- Private infrastructuurToekomst
Standalone applicatie
Draait zonder YiENTi als runtime-afhankelijkheid
Alleen de applicatie draait hier — geen YiENTi-runtime en geen verplichte verbinding met YiENTi.
Alleen op providerniveau weergegeven. Private en door de klant beheerde infrastructuur is een toekomstige richting, geen productieklare optie vandaag.
Productbewijs
Geen labdemo. Echte software.
Het volledige huidige applicatieportfolio van ACCENTSYS is gebouwd met door YiENTi ondersteunde engineering, waarbij YiENTi zelf als engineeringplatform dient.
Het bewijs is het volledige huidige ACCENTSYS-portfolio — geen geselecteerde subset. Door YiENTi ondersteunde engineering is de manier waarop ACCENTSYS software bouwt, in elk domein waarin het actief is.
7 eigen ACCENTSYS-applicaties en 1 engineeringproject voor een klant, allemaal ontwikkeld met door YiENTi ondersteunde engineering
Eigen ACCENTSYS-applicaties
Publieke sector
Arbeitsmarktvollzug
Gebouwd met YiENTiBezoeken Arbeitsmarktvollzug (opent in een nieuw tabblad)Streaming en media
Castovia
Gebouwd met YiENTiBezoeken Castovia (opent in een nieuw tabblad)Gezinsorganisatie
Kicaly
Gebouwd met YiENTiBezoeken Kicaly (opent in een nieuw tabblad)Dienstverlenende bedrijven
Merclino
Gebouwd met YiENTiBezoeken Merclino (opent in een nieuw tabblad)Onderwijs
SchoolApp
Gebouwd met YiENTiBezoeken SchoolApp (opent in een nieuw tabblad)Sportverenigingen
STV Portal
Gebouwd met YiENTiBezoeken STV Portal (opent in een nieuw tabblad)Softwarelicenties
xcess
Gebouwd met YiENTiBezoeken xcess (opent in een nieuw tabblad)
Engineeringproject voor een klant
Klantproject · Loxy International AG
LOXY Time
Gebouwd met YiENTiBezoeken LOXY Time (opent in een nieuw tabblad)
Ontwikkeld door ACCENTSYS AG voor de klant met door YiENTi ondersteunde engineering. Klantprojecten zijn externe engineeringreferenties en maken geen deel uit van het eigen SaaS-productportfolio van ACCENTSYS AG.
Deze lijst is rechtstreeks overgenomen uit het productregister van ACCENTSYS, inclusief de indeling in eigen applicaties en klantprojecten, zodat nieuwe items hier automatisch verschijnen. LOXY Time wordt hieronder in detail besproken, omdat de engineeringinspanning ervan is gemeten.
Bekijk het portfolioGebouwd met YiENTi. Niet afhankelijk van YiENTi.
YiENTi ondersteunt hoe deze producten worden ontwikkeld — door experts gestuurd, niet als autonome generatie van elke regel code. De producten zelf draaien onafhankelijk en hebben YiENTi niet nodig tijdens runtime.
Engineeringreferentie van een klant · LOXY Time
Engineering met ondersteuning van YiENTi, gedemonstreerd aan de hand van echte enterprise-software.
LOXY Time is een praktijkgericht enterprise-engineeringproject dat laat zien hoe softwareontwikkeling met ondersteuning van YiENTi werkt bij complexe operationele workflows, wettelijke vereisten, dataverwerking en systeemintegratie.
LOXY Time is een platform voor transport en naleving van regelgeving, ontwikkeld door ACCENTSYS AG voor Loxy International AG. Het dient als praktijkgerichte engineeringreferentie die de mogelijkheden van softwareontwikkeling met ondersteuning van YiENTi laat zien. LOXY Time maakt geen deel uit van het portfolio van eigen SaaS-producten van ACCENTSYS AG.
Geïmplementeerd in LOXY Time
- Verwerking van digitale tachograaf-DDD-bestanden · Gen1, Gen2 V1, Gen2 V2
- Bestuurders- en voertuiggegevens
- Regelgevingscontroles en naleving
- Workflows en rapportages
- Integraties en bulkverwerking van data
- Geautomatiseerde kwaliteitsborging en regressietests
Intern gebruik is niet hetzelfde als commerciële beschikbaarheid. Het zelfstandige YiENTi-platform is nog in ontwikkeling.
YiENTi compute-strategie
YiENTi draait waar de rekenkracht is.
YiENTi is niet gebonden aan een specifieke cloud- of GPU-provider. Het kan werken overal waar voldoende CPU, GPU, geheugen en ondersteunende rekenresources beschikbaar zijn. Kleinere workloads kunnen lokaal draaien, terwijl complex gestructureerd redeneren aanzienlijke externe of dedicated rekencapaciteit kan vereisen.
Meer beschikbare rekenkracht verhoogt niet alleen de snelheid. Het stelt YiENTi in staat om tegelijkertijd te werken over grotere samenhangende proces-, graaf- en systeemcontexten.
YiENTi-workload
Rekenvereisten
- CPU
- GPU
- Geheugen
- Opslag / I/O
Geleverd door een van de volgende
Lokaal
- High-end workstation
- Lokale server
Externe rekenkracht
- Alibaba Cloud
- AWS
- Microsoft Azure
- Google Cloud
- Andere geschikte providers
Privé / dedicated
- Private infrastructuur
- Dedicated rekenkracht
Lokale uitvoering
Kleinere YiENTi-workloads kunnen lokaal draaien. Complexere workloads kunnen de beschikbare CPU-, GPU- en geheugenresources van zelfs high-end engineeringsystemen volledig benutten.
Externe rekenkracht vandaag
ACCENTSYS huurt momenteel externe rekenkracht van onder meer Alibaba Cloud en AWS-infrastructuur in de Verenigde Staten. Cloudleveranciers leveren capaciteit. Het zijn geen architectonische afhankelijkheden.
- Huidig
Vandaag · Flexibele rekenkracht
- Gehuurde externe rekenkracht
- Alibaba Cloud
- AWS
- Andere geschikte providers
- Lokale uitvoering voor kleinere workloads
YiENTi draait overal waar de vereiste CPU, GPU, het geheugen en de ondersteunende resources beschikbaar zijn.
- Richting voor opschaling
Opschaling · Dedicated rekenkracht
- Gereserveerde / dedicated capaciteit
- Private rekenomgevingen
- Dedicated servers of clusters
- Workloadspecifieke infrastructuur
- Meer controle over prestaties en kosten
Nog niet geïmplementeerd. De richting naarmate YiENTi-workloads groeien.
- Visie voor de lange termijn
Lange termijn · ACCENTSYS-rekeninfrastructuur
- Door ACCENTSYS beheerde rekenkracht
- Dedicated high-performance infrastructuur
- Mogelijk eigen datacenterinfrastructuur
ACCENTSYS beheert vandaag geen eigen datacenter.
Microsoft Azure en Google Cloud zijn aanvullende mogelijke rekenbronnen — geen latere fasen. De drie kaarten beschrijven de infrastructuurstrategie; de providers zijn daarbinnen uitwisselbare bronnen van capaciteit.
Provideronafhankelijk
YiENTi is in principe niet afhankelijk van Alibaba Cloud, AWS, Microsoft Azure of Google Cloud.
Afhankelijk van rekenkracht
De praktische beperking is voldoende rekenkracht voor de workload: CPU, GPU, systeemgeheugen, VRAM, opslag / I/O, netwerkdoorvoer en parallelle rekencapaciteit.
Commerciële strategie · Visie
Dedicated YiENTi-infrastructuur op de lange termijn is bedoeld om de commerciële opschaling van de ACCENTSYS-productportfolio te volgen, met Merclino als commerciële prioriteit voor de nabije termijn. Succesvolle commercialisering van de portfolio is bedoeld om de financiering van steeds meer dedicated YiENTi-rekencapaciteit te helpen ondersteunen. Merclino is een commerciële prioriteit, geen technisch bijzonder geval: elk huidig ACCENTSYS-product is gebouwd met door YiENTi ondersteunde engineering.
Rekenbeperking
In huidige interne workloads kan het gestructureerd redeneren van YiENTi grofweg een orde van grootte meer rekenkracht vereisen dan conventionele LLM-first workflows.
YiENTi redeneert over graafstructuren, processen, toestanden, afhankelijkheden, metingen, meerdere modelweergaven en de relaties daartussen — samen met historie en validatieresultaten. YiENTi ruilt rekenefficiëntie in voor rijkere structurele context.
Gebaseerd op interne workloads van ACCENTSYS; geen onafhankelijke benchmark.
Waarom meer rekenkracht ertoe doet
Extra rekenkracht doet meer dan de verwerkingstijd verkorten. Het stelt YiENTi in staat om tegelijkertijd te redeneren over grotere samenhangende contexten:
- Processen
- Graafrelaties
- Afhankelijkheden
- Toestand
- Historie
- Meting
- Softwaremodellen
- Meerdere modelweergaven
- Validatiecontext
Minder structuur
- Minder rekenkracht
- Probabilistische reconstructie van context
Rijk structureel model
- Meer rekenkracht
- Expliciete toestand, processen, relaties en meetbare context
Oorsprong
YiENTi ontwikkelt zich sinds 2010.
De oorsprong van YiENTi gaat terug tot 2010, toen het project begon als Logical Board bij Grandes Planos S.A. De technologie evolueerde later tot YiENTi, waarbij gestructureerde bedrijfsinformatie wordt gecombineerd met een steeds geavanceerdere intelligentielaag.
2010
Logical Board
Oorsprong bij Grandes Planos S.A.
Het project begint als Logical Board bij Grandes Planos S.A., gericht op gestructureerde bedrijfsinformatie, processen, taken en relaties.
2016
YiENTi
Eerste presentatie van YiENTi bij Swisscom AG
YiENTi – Intelligent Enterprise Information. De gepresenteerde architectuur omvatte al:
- Enterprise Information
- YiENTi AI
- Gestructureerde processen
- Meting
- Op graaf- en procesgebaseerde intelligentie
Nu
YiENTi Enterprise + YiENTi Intelligence
Voortzetting en technische evolutie van de architectuur uit 2016
Ondersteunt nu al echte software engineering bij ACCENTSYS met behulp van:
- Expliciete systeemmodellen
- Gestructureerde processen
- Redeneren op grafen
- Meting
- Modelgedreven engineering
- Generatie en validatie
Volgende
Real Intelligence / AGI
Ontwikkelrichting
Verdere ontwikkeling richting steeds algemenere intelligentie, gebaseerd op gestructureerd redeneren, meetbare werkelijkheid en expliciete systeemmodellen.
Visie / onderzoeksrichtingOnderzoeksrichting op langere termijn
Algemene en mogelijk bovenmenselijke machine-intelligentie.
“Volgende” beschrijft een ontwikkelrichting, geen bereikte capaciteit. YiENTi claimt geen AGI of superintelligentie.
Van kunstmatige intelligentie naar real intelligence
ACCENTSYS gebruikt de term Real Intelligence voor een richting voorbij probabilistische taalgeneratie: intelligentie die kan redeneren over expliciete processen, relaties, toestand, metingen en gevolgen.
Real Intelligence is terminologie van het bedrijf ACCENTSYS, geen gevestigde wetenschappelijke term.
Al in de architectuur van 2016
De scheiding tussen bedrijfsinformatie en machine-intelligentie maakte al deel uit van de YiENTi-architectuur die in 2016 werd gepresenteerd.
Processen die gekoppeld zijn aan meetbare output, een graaf van bedrijfsinformatie en een AI-laag die daarover redeneert. De architectuur van YiENTi is niet ontstaan als reactie op de recente opkomst van grote taalmodellen.
Waarom nu
De architectuur ging de huidige AI-infrastructuur vooraf.
De fundamentele richting bestond in 2016 al. Wat veranderde, is de rekenkracht die beschikbaar is om deze op zinvolle schaal uit te voeren. De aanzienlijk grotere rekencapaciteit van vandaag maakt een steeds complexere uitvoering van die architectuur mogelijk. De huidige implementatie is niet identiek aan die van 2016; het is een substantiële technische evolutie ervan.
Met meer rekenkracht kan YiENTi tegelijkertijd werken over grotere samenhangende proces-, graaf- en softwarecontexten.
Het architectonische verschil
Een LLM kan een diagram interpreteren. YiENTi kan de structuur onderdeel van het model maken.
Processen, gateways, activiteiten, klassen, sequenties, relaties en afhankelijkheden kunnen expliciete objecten in de redeneercontext blijven.
Beeldinterpretatie
Multimodale taalmodellen kunnen tekst, afbeeldingen en diagrammen interpreteren. De structuur wordt afgeleid uit de prompt.
Een plaatje van een proces, op verzoek geïnterpreteerd.
Structurele representatie
In YiENTi kunnen processen, relaties, toestanden en afhankelijkheden bestaan als expliciete, machineleesbare structuren, in plaats van alleen als informatie die uit prompts wordt afgeleid.
- Activiteit
- Gebeurtenis
- Gateway
- Actor
- Sequentie
- Klasse
- Relatie
- Toestand
- Afhankelijkheid
- Data-entiteit
- Procespad
YiENTi kijkt niet alleen naar een diagram. De structuur die door dat diagram wordt weergegeven, kan deel worden van het systeemmodel.
Meerdere modelweergaven
Verschillende diagrammen worden verschillende weergaven van één samenhangend systeemmodel.
- Requirements
- User stories
- Use cases
- Activiteitendiagrammen
- BPMN
- Samenwerking
- Sequentie
- Klassenmodellen
- Datamodellen
- Systeemafhankelijkheden
Software engineering
Niet alleen gegenereerde code. Een model van het systeem erachter.
YiENTi hanteert een fundamenteel andere benadering van software engineering dan LLM-first-systemen. In plaats van telkens op gegenereerde taal te vertrouwen om de systeemcontext te reconstrueren, onderhoudt YiENTi expliciete structurele representaties van het systeem.
LLM-first-lus
- Prompt
- Gegenereerde code
- Review
- Nieuwe prompt
- Gereconstrueerde context
- ↺
De systeemcontext wordt in elke cyclus opnieuw uit taal gereconstrueerd.
YiENTi-lus
- Gestructureerde requirements
- Expliciet proces-/systeemmodel
- Afhankelijkheden
- Redeneren
- Implementatie
- Validatie
- Gemeten resultaat
- Bijgewerkt model
- ↺
Het systeemmodel blijft bestaan en wordt bij elk gemeten resultaat bijgewerkt.
Productbewijs
- Arbeitsmarktvollzug
- Castovia
- Kicaly
- Merclino
- SchoolApp
- STV Portal
- xcess
Engineeringproject voor een klant
- LOXY Time · Loxy International AG
Het volledige huidige applicatieportfolio van ACCENTSYS is gebouwd met door YiENTi ondersteunde engineering, waarbij YiENTi zelf als engineeringplatform fungeert. LOXY Time, een klantproject dat ACCENTSYS AG ontwikkelde voor Loxy International AG, is een enterprise-engineeringproject uit de praktijk dat door YiENTi ondersteunde softwareontwikkeling laat zien bij complexe operationele workflows, wettelijke vereisten, gegevensverwerking en systeemintegratie.
Architectuur
Twee technologieën, één samenhangende architectuur.
Enterprise-informatie wordt een gestructureerde operationele graaf. YiENTi Intelligence redeneert erover, en de resultaten vloeien terug naar de enterprise-status of naar gekoppelde systemen. Dezelfde intelligentielaag werkt ook buiten YiENTi Enterprise.
Diagram C · Integratie
Samenwerking
YiENTi Enterprise
Enterprise Information Platform
Gestructureerde operationele graaf
Wat er bestaat · wie erbij betrokken is · wat van wat afhangt
YiENTi Intelligence
Graph-Native Intelligence Engine
Redeneren · Beslissen · Orkestratie
Enterprise-platform
Bijgewerkte enterprise-status
Externe systemen
Gekoppelde interfaces
De bijgewerkte status wordt de context voor de volgende redeneerstap.
Voorbij YiENTi Enterprise
YiENTi Intelligence
Herbruikbare intelligentielaag
ACCENTSYS software engineering
Kerntechnologie voor intern gebruik
Andere ACCENTSYS-producten
Ontwikkelrichting
Toekomstige externe systemen
Ontwikkelrichting
Andere use cases voor gestructureerd redeneren
Ontwikkelrichting
Huidige ontwikkeling
Transparant over waar YiENTi nu staat.
YiENTi-platform
Het zelfstandige YiENTi-platform is in ontwikkeling en is nog niet commercieel beschikbaar.
YiENTi Intelligence · kerntechnologie
YiENTi ondersteunt het engineering bij ACCENTSYS al, terwijl het zelfstandige platform zich verder ontwikkelt.
Human-in-the-loop · huidige maturiteit
YiENTi is vandaag door experts gestuurd.
Het huidige systeem levert aanzienlijke hefboomwerking voor engineering wanneer het wordt bediend door mensen die processen en systeemstructuur begrijpen. De kracht ontstaat door het combineren van gestructureerde modellen, procesbegrip en door machines ondersteund redeneren.
Kennis die YiENTi vandaag vermenigvuldigt
- BPMN
- Procesmodellering
- Systeemarchitectuur
- Software engineering
- Bedrijfsworkflows
- Gestructureerde modellen interpreteren
YiENTi is nog geen afgerond massaproduct dat iedereen zonder domeinkennis kan gebruiken.
Richting · geen belofte met datum
Vandaag
Door experts gestuurd structureel engineering
Straks
Meer geautomatiseerd modelleren, redeneren, testen en opleveren
Lange termijn
Steeds autonomer system engineering
De YiENTi-filosofie
Van kunstmatige intelligentie naar Real Intelligence.
Intelligentie is meer dan plausibele taal produceren. Het vereist inzicht in relaties, context, processen, gevolgen en hoe informatie in de loop van de tijd verandert. YiENTi is de aanpak van ACCENTSYS voor dit probleem.
“Real Intelligence” beschrijft de filosofie van YiENTi en ACCENTSYS — het is geen gevestigde wetenschappelijke categorie.
Strategische groei
De volgende fase opschalen.
YiENTi wordt al gebruikt om echte software te bouwen. De volgende fase draait om het opschalen van productisering, rekencapaciteit en commercialisering. YiENTi maakt deel uit van het bredere technologieportfolio van ACCENTSYS.
De beperkende factoren zijn kapitaal, schaalvergroting en rekencapaciteit — niet de vraag of YiENTi werkt.
Intern bewezen
Centraal in de software-engineering van ACCENTSYS.
Gebruikt in echte producten
Achter het huidige productportfolio van ACCENTSYS.
Schaal hangt af van middelen
Kapitaal, rekencapaciteit en voortgezette ontwikkeling.
ACCENTSYS
Ontwikkeld door ACCENTSYS AG, Zwitserland.
YiENTi vervult bij ACCENTSYS twee rollen: een enabling technologielaag binnen de software-engineering van ACCENTSYS en een toekomstig zelfstandig platform.
Geïnteresseerd in de bredere platformstrategie achter YiENTi? Ontdek ACCENTSYS, het technologieportfolio en de huidige strategische groeironde.
Voor partnerships, technologiegesprekken, strategische samenwerking en investeringen.