Rubbr Demander une démo

Plateforme

Les briques de votre factory.

Une équipe plateforme obtient des agents opérationnels dès le premier jour, bâtis sur six briques : du code et de la configuration que vous pouvez lire, relire et programmer. Cette page explique comment fonctionne chaque brique.

Règles

Rien n'est livré hors de vos règles

Une politique absente ou invalide bloque toute action de livraison. Treize règles du noyau ne peuvent pas être désactivées.

Trace

Chaque décision est tracée

L'état est dérivé de la politique au commit de base et d'un journal : chaque exigence renvoie à une ligne de YAML.

Contexte

Les réponses disent sur quoi elles reposent

Le catalogue consigne, le graphe de code suggère, la source montre. Seule la source épinglée confirme.

Isolation

Aucun identifiant dans la sandbox

La boucle de l'agent et ses identifiants restent à l'extérieur. Chaque exécution reçoit une microVM neuve.

01 · Rubbr Workflows v0.3 · en développement actif

Des workflows qui savent sur quoi repose chaque résultat.

Un moteur de workflows qui enregistre, en plus de ce qui s'est exécuté, ce dont dépend chaque résultat. Quand un résultat est réfuté plus tard, il ne répare que ce qui reposait dessus.

Version 0.3, en développement actif. L'article de recherche est en cours d'évaluation. Publication en open source prévue mi-décembre 2026.

Pourquoi maintenant

Une personne ne peut plus tenir le registre.

Systèmes de build

ce qui a explosé
Les sources et les règles de build.
ce que l'outil retient
Ce à partir de quoi chaque artefact a été construit. Ne reconstruit que ce qui a changé.

Terraform

ce qui a explosé
Les ressources cloud.
ce que l'outil retient
Ce qui existe et la configuration dont cela provient. Ne modifie que ce qui diffère.

Rubbr Workflows

ce qui a explosé
Les workflows, maintenant que l'IA les rend peu coûteux à écrire, avec des étapes qui sont des prédictions de modèles de langage.
ce que l'outil retient
Ce sur quoi repose chaque résultat, fait ou prédiction. Ne répare que ce qui a perdu son appui.

La différence : un build invalide à partir d'empreintes de fichiers. Ici, l'invalidation est une preuve tardive venue du monde réel, et les effets de bord sont corrigés, pas recalculés.

Le cas

Une étape qui réussit, puis est réfutée plus tard.

Un diagnostic et un correctif sont des prédictions. Les tests passent, le déploiement réussit, et quinze minutes plus tard les métriques disent non. Ce verdict dit que le diagnostic et le correctif ne sont pas tous deux justes ; il ne dit pas lequel est faux. Ceci est une exécution réelle.

Workflow d'incidentexécution réelle
1 / 5

Toutes les étapes ont réussiUn journal d'exécution dit que tout va bien. Deux de ces résultats sont des prédictions.

Quinze minutes plus tard : nonLe verdict ne réfute que le résultat observé. Il ne dit pas quelle prédiction était fausse.

Remplacer le correctifLe moteur ne devine pas. Votre gestionnaire, du code ou un agent que vous déclarez, examine les preuves et reprend au correctif. Le déploiement 1 est corrigé, pas réexécuté.

Encore non : remplacer le diagnosticLe gestionnaire reprend une étape plus tôt. Seul ce qui reposait sur le diagnostic est refait.

OuiTrois déploiements, deux corrections, un contexte produit une seule fois. Un quatrième non aurait arrêté l'exécution à sa limite.

Contextdoneproduced once Diagnosis D1Diagnosis D2predictionsuspectnew versionheld Patch F1Patch F2Patch F3predictionsuspectnew versionheld Checks and permitdonekeptredone Deployment 1Deployment 2Deployment 3donekeptfirst correctedsecond correctedlive Outcome · 15 minwaitingrefutedconfirmed
deployments 123corrections 012

predictionfact

Ce que montre le schéma : un verdict tardif réfute un résultat, et la réparation ne remplace que ce qui reposait sur la mauvaise prédiction. L'accent marque ce qui a changé à chaque étape.

Ce que vous écrivez

Écrivez le chemin nominal, puis déclarez quel résultat dépend de quel autre.

Le workflow est du code ordinaire, une ligne par étape. Un second fichier déclare ce que le code ne peut pas dire : ce qu'il faut observer après un effet de bord, et qui décide quand un résultat se révèle faux. Chaque numéro relie une note aux lignes qu'elle concerne.

integrated-incident.rubbrle workflow · lignes 59 à 89
workflow incident(input: Data) -> Data on worker { let independent = await ops.context(input); let diagnosis = await ops.diagnose(input); ⋯ let patch = await ops.patch(selected); ⋯ let permit = await ops.permit(patch); let deployment = await ops.deployment({ patch: patch, diagnostic_context: diagnostic_context, permit: permit }); let outcome = await ops.outcome(prediction_for( ⋯ )); return outcome;}
integrated-incident-installation.rubbrses déclarations · lignes 92 à 202

Le déploiement est observé pendant 15 minutes. Son résultat n'est connu qu'au bout de ce délai, et correct est la façon de l'annuler s'il doit être remplacé.

deployment { ⋯ side_effect { operation: deployment awaits: [{ outcome: outcome ⋯ window: "15m" receipt: self correction: correct

Quand le résultat est réfuté, un gestionnaire prend le relais. Il ne peut relancer l'exécution qu'à deux points déclarés, le correctif ou le diagnostic, et deux fois au plus.

semantic { on { kind: invalid node: outcome } handler: semantic.reconsider entries { patch { ⋯ diagnosis { ⋯ limits { ⋯ max_replacements: 2
integrated-semantic-recovery.rubbrle gestionnaire · extrait

Un agent est mandaté pour examiner les nouveaux éléments et décider. Il lit l'exécution jusque-là et la prédiction qui a échoué, puis dit où se trouve l'erreur : dans le correctif ou dans le diagnostic.

type Advice = {action: Entry, finding: Text, proposal: Proposal};workflow reconsider(f: Context) -> Advice on worker { return await investigate({history: f.history, prediction: f.prediction});}

Puis le moteur reprend la main. L'avis désigne l'une des entrées déclarées, et c'est le moteur qui l'appelle : aucun code d'aiguillage à écrire. Il remplace cette étape et tout ce qui en dépendait, corrige le déploiement grâce à son reçu, et observe le nouveau résultat.

Les effets de bord ne sont jamais exécutés deux fois : un rejeu réutilise le reçu, un effet remplacé reçoit sa correction déclarée, et une livraison incertaine est vérifiée, jamais retentée à l'aveugle.

Au-delà de Temporal

Au-delà de Temporal : les réparations que vous écririez sinon à la main.

Temporal apporte le rejeu durable, les nouvelles tentatives, les minuteries et des sagas que vous écrivez à la main. Rien de cela n'est nouveau ici, et un workflow Temporal pourrait héberger ce moteur. La différence tient à ce qui est enregistré : un journal de saga enregistre ce qui s'est passé ; un graphe de dépendances enregistre ce qui dépendait de quoi.

TemporalRubbr Workflows
Une étape réussie, réfutée plus tardDes branches et des boucles dans votre code.Le résultat observé est réfuté, et la réparation reprend à un point déclaré, dans des limites.
Annuler un effet de bordUne saga que vous écrivez.Une correction déclarée, liée au reçu d'origine.
« Qu'est-ce qui dépendait de quoi ? »Lisez le code.Interrogez-le : c'est un état enregistré.

Le moteur applique les contrôles que vous écrivez ; il ne décide pas de lui-même qu'un résultat est vrai.

Article de recherche

En cours d'évaluation

Le modèle complet, ses garanties et la comparaison avec les systèmes de build et l'exécution durable. Publié ici une fois l'évaluation terminée.

Open source

Mi-décembre 2026

Le moteur, son langage et un ensemble de scénarios d'exemple, sous forme de code source exécutable.

02 · Règles en tant que code

Ce qui peut être livré est un fichier de votre repository.

.rubbr/policy.yaml est un simple fichier YAML soumis à un schéma strict, sans langage d'expressions. Il déclare des zones, un graphe acyclique d'actions de livraison, et un moteur de règles unique fait de when et de require.

  • Évaluée au commit de base du correctif. Un changement qui modifie la politique est régi par l'ancienne.
  • Le risque est mesuré sur le correctif. Les ancres du catalogue, les appelants du graphe, les faits jugés et le relecteur ne peuvent que le relever.
  • Abaisser le risque est un acte humain enregistré. Un développeur peut l'abaisser en donnant une raison, pour cette identité de correctif uniquement.
  • Les faits jugés sont enregistrés avec le modèle, l'instruction, les empreintes des entrées et la raison.
  • Les approbations sont liées à une seule révision.
  • L'état est dérivé de la politique au commit de base et du journal. Chaque exigence renvoie à une ligne de YAML.

Le noyau

Treize règles ne peuvent être désactivées par aucune politique. Quatre d'entre elles :

  • Un reçu ne vient jamais de l'agent de code.
  • Aucune sortie de modèle ne satisfait une exigence.
  • Une politique absente ou invalide bloque tout.
  • Un résultat inconnu isole le sujet, sans nouvelle tentative automatique.
Quatre changements, une politique · Nordwind ERP
1 / 4

Renommer un libelléUn seul fichier de traduction. Seule la règle de base s'applique.

Modifier la facturationLe correctif touche la zone de facturation et son risque est mesuré comme moyen. Deux règles de plus s'appliquent.

Répondre à un clientPas un correctif : une autre action de livraison, avec son propre sujet et sa propre règle.

Toucher aux paiementsLa règle des paiements s'applique quel que soit le niveau de risque, en plus des autres.

.rubbr/policy.yamlextrait
areas: invoicing: paths: ["htdocs/compta/facture/**"] payments: paths: ["htdocs/compta/paiement/**"] reason: "Money moves here: finance agrees"actions: implement: subject: patch performer: { rubbr: git.commit_to_main } rules: - id: base require: - { checks: pass } - { settled: blocking } - { confirm: { by: [pm] } } - id: medium_and_up when: { risk: { at_least: medium } } require: - { approval: { of: patch, by: developer } } - { document: { kind: spec, agreed_by: pm } } - id: payments_owner when: { touches: [payments] } require: - { approval: { of: patch, by: finance_owner } } deploy: subject: main_commit after: [implement] release: subject: deployment after: [deploy] rules: - id: qa when: { risk: { at_least: medium } } require: - approval: { of: { deployment: deploy }, by: qa } customer_reply: subject: reply performer: { rubbr: tickets.post_reply } rules: - id: support_lead require: - { approval: { of: reply, by: support_lead } }

Mesuré sur le correctif

  • fichiers1 · htdocs/langs/en_US/bills.lang
  • zones touchéesaucune
  • risquefaible
  • fichiers2 · …/facture/class/invoice.class.php et son test
  • zones touchéesinvoicing
  • risquemoyen, relevé par une ancre du catalogue
  • sujetun brouillon de réponse, pas un correctif
  • zones touchéessans objet
  • risquenon mesuré
  • fichiers3 · sous htdocs/compta/paiement/
  • zones touchéespayments
  • risqueélevé, relevé par des appelants du graphe

Ce que les règles exigent

  • basecontrôles réussis, plus rien de bloquant à régler, une confirmation
  • basecontrôles, rien de bloquant, une confirmation
  • medium_and_upun développeur approuve le correctif ; la spec est validée
  • qala QA approuve le déploiement avant la mise en production
  • support_leadla responsable du support approuve cette réponse
  • basecontrôles, rien de bloquant, une confirmation
  • medium_and_upun développeur approuve le correctif ; la spec est validée
  • payments_ownerle responsable finance approuve le correctif
  • qala QA approuve le déploiement avant la mise en production

Qui doit intervenir

Le product manager.

Le product manager, un développeur, la QA.

La responsable du support.

Le product manager, un développeur, le responsable finance, la QA.

Ce que montre la vue : le même fichier répond à quatre changements différents, et chaque exigence à droite correspond à la règle surlignée à gauche.

Les approbations se périment

Les règles de l'hôte périment d'abord une approbation : un risque plus élevé, une zone nouvellement touchée, un correctif différent hors des fichiers approuvés. Sinon, un relecteur indépendant, jamais l'agent de code, juge si la nouvelle révision est structurelle.

Reçus

Un exécutant agit et renvoie un reçu pour une révision : un fournisseur installé par l'opérateur, ou un résultat observé à travers votre gestion de sources, votre CI et votre monitoring. Le reçu ne vient jamais de l'agent de code.

Rejeu des décisions

Les décisions sont des fonctions pures de la politique au commit de base et du journal : une décision passée se rejoue à partir de sa trace et donne le même résultat.

03 · Sandboxes

Une machine neuve pour chaque exécution.

Chaque exécution reçoit sa propre microVM, clonée en copy-on-write à partir d'un template construit depuis votre Dockerfile. L'application, les tests et un navigateur s'y exécutent, et nulle part ailleurs.

0,4 ssuite unitaire à chaud
0,7–0,8 scontrôle dans le navigateur
0,5 msaller-retour d'un appel dans la sandbox
9–23 ssession entière
~70 spréparation du template, une fois

Mesuré sur notre projet de test, sur un Mac avec l'hyperviseur d'Apple.

Veille et réveil à chaud

Une sandbox se met en veille quand rien ne s'y exécute, et se réveille à chaud pour l'appel d'outil suivant.

Points de reprise

La sandbox d'une exécution peut être sauvegardée en un point de reprise, puis restaurée à partir de ce point.

Où il s'exécute

Les microVM tournent sur l'hyperviseur d'Apple sur un Mac, et sur Firecracker dans le cloud.

Les couches d'une sandbox
1 / 3

Une exécution démarreSeule la couche du haut est créée, comme un clone copy-on-write du template. Rien n'est reconstruit en dessous.

Vous montez une version de langageVotre chaîne d'outils est reconstruite, ainsi que tout ce qui est au-dessus. Les deux couches du dessous sont réutilisées.

Rubbr livre un correctif de sécuritéLe correctif est dans le système de base : toutes les couches au-dessus sont donc reconstruites, une fois. Les exécutions partent ensuite du nouveau template.

built onthe layer below The runone per run · discarded after created · copy-on-write clonenext runs clone the new template Your recipesdependencies · fixtures reusedrebuilt Your toolchainfrom your Dockerfile reusedrebuilt · the layer that changedrebuilt Rubbr workerruns the tool calls reusedrebuilt Base systemmaintained by Rubbr reusedrebuilt · the layer that changed
Ce que montre le schéma : un changement dans une couche reconstruit cette couche et tout ce qui est au-dessus, jamais ce qui est en dessous.
Où le calcul est utilisé pendant une session
Agent inside a container container modeltoolmodeltoolmodeltoolmodeltool The container, with the agent's credentials in it, is held from the first second to the last. Agent outside, sandbox on call Rubbr service modelmodelmodelmodel sandbox tooltooltooltool
Ce que montre le schéma : la même session, dessinée à la même longueur. Avec l'agent à l'extérieur, la sandbox ne calcule que pendant les appels d'outils et reste inactive pendant que le modèle réfléchit. Elle se met en veille pendant ces intervalles.

L'idée de sécurité : la boucle de l'agent et ses identifiants vivent hors de la sandbox, et l'appel d'outil est la frontière de sécurité. La machine où le code s'exécute ne détient alors aucun secret. Une machine sans secret peut être jetable.

04 · Contexte produit

Trois sources, et une réponse qui dit laquelle.

Les agents et les personnes posent leurs questions sur le produit avec les mots du métier. Les réponses puisent dans trois sources d'autorité différente, et l'hôte impose la façon dont chacune peut être citée.

Catalogue fonctionnel

ce que c'est
Des fonctionnalités décrites avec les mots du métier, chacune ancrée à un fichier, des lignes et une empreinte. Produit par un pipeline unique avec un seul relecteur final, exporté immuable, publié avec un reçu et une relecture de contrôle.
ce que cela peut établir
À quoi sert une fonctionnalité, et par où commencer la lecture.
ce que cela ne peut pas établir
Que la liste est complète, ou que le code le fait toujours.

Graphe de code

ce que c'est
Des pistes d'appels à un saut autour d'un symbole.
ce que cela peut établir
Où regarder ensuite : des pistes de navigation, pas des relations vérifiées.
ce que cela ne peut pas établir
L'isolation. Une arête absente ne prouve rien.

Source à un commit épinglé

ce que c'est
Votre repository Git, lu à un commit donné.
ce que cela peut établir
Ce que fait le code. C'est la seule confirmation.
ce que cela ne peut pas établir
Ce que fait le code à un autre commit.

La règle de formulation, imposée par l'hôte : le catalogue consigne, le graphe de code suggère, la source montre.

Questions

Les personnes et les agents interrogent les trois sources, et chaque affirmation de la réponse cite celle sur laquelle elle repose.

Versions

Une version du catalogue appartient à un commit Git de votre repository. Un nouveau commit met à jour le catalogue pour ce qui a changé, et une réponse lit le catalogue et la source au même commit.

05 · Extensibilité

Un seul mécanisme de plugins, utilisé par le produit lui-même.

Tout est plugin : la boucle de l'agent, l'adaptateur de modèle, le moteur de règles, chaque carte à l'écran. Un plugin fournit ou consomme un service, enregistre un outil, intercepte un événement ou ajoute un composant d'interface.

La carte des plugins45 plugins · 5 agents préconfigurés · 7 contrats
Agentsinstructions, model, tools Contractswhat agents depend on Providerschosen in configuration Pluginseverything is a plugin, grouped by what it does changecodingreviewbackgroundpersonalyour agent modelcoding agentshellticketsdocumentsmessagessource control multi-providerbuilt-inCodexClaude CodelocalOS sandboxcontainerremote machineJiraConfluenceSlackGitHub + CI product contextsourcesanalysesskillssession searchrules and approvalsrulesship actionschecksapprovalsquestionscredentialssettingsworkspaces and executionworkspaceworktreesshellOS sandboxremote sandboxSSHterminalbackground jobscode runtimepreviewagent loopgoalplantodoguardcompactionsub-agentsteamcode and filesfilesLSPdeliverablesattachmentstools and integrationsMCPwebbrowser usecomputer userecordstriggersscheduleswebhookshooksinterface, record, platformconversationjournalstoragetelemetrySDKyoursyour pluginyour toolyour integration
Ce que montre le schéma : les agents dépendent de contrats, jamais d'un fournisseur, et tout le reste est plugin, regroupé ici par fonction. Les pastilles en pointillés sont les vôtres : vos propres agents et plugins s'ajoutent par le même mécanisme. Changer de fournisseur est un changement de configuration.

Des contrats, pas des éditeurs

Les agents dépendent d'un contrat : modèle, agent de code, shell, tickets, documents, messages, gestion de sources. Chacun a des fournisseurs interchangeables, choisis en configuration.

Apportez votre agent de code

L'étape d'implémentation exécute l'agent intégré, Codex ou Claude Code. Quel que soit celui qui s'exécute, le reçu vient de l'hôte ou d'une intégration, jamais de l'agent.

Vos outils

Jira, Confluence, Slack, GitHub et la CI sont des fournisseurs. Chaque écriture garde un reçu et n'est jamais retentée en cas d'incertitude. MCP connecte des outils de lecture approuvés.

Le partage de la confiance

Seul l'opérateur installe des plugins exécutables. Un repository fournit du YAML typé, en couches qui ne peuvent que restreindre. Il ne peut pas s'accorder lui-même une permission.

06 · Background agents

Des agents qui travaillent en continu, dans les mêmes règles.

Le travail en arrière-plan prend deux formes. Toutes deux sont bornées par la politique, le budget et les droits d'accès, et aucune n'a de voie privée vers la production.

Deux façons de travailler en arrière-plan
more deterministicmore exploratory Rubbr WorkflowsFree agent declared stepsyour checksledgerbounded repair goalcoordinatorworkersfindings the path is written in advancethe path is found, inside limits policy · budget · access rights A background agent proposes. What ships goes through the same gates as a person's change.
Ce que montre le schéma : le même socle borne les deux formes. Un workflow suit un chemin écrit à l'avance ; un agent libre trouve son chemin, dans des limites.

Workflows

Des étapes déclarées, des contrôles que vous écrivez et un registre. Quand un résultat se révèle faux, la réparation reprend à un point déclaré, un nombre limité de fois. Utilisez-les quand le chemin est connu.

Agents libres

Un objectif, un propriétaire et un budget. L'agent choisit son propre chemin, pour le travail exploratoire : tri, enquête, surveillance des dérives.

Comment fonctionne un agent de longue durée

Un agent de longue durée
stop follow-ups go straight to the worker Triggersschedule · ticketcomment · CI result Admission rules in code judgement by a model Coordinatorroutes, never executes Workerbudgetsession · sandboxWorkerbudgetsession · sandboxWorkerbudgetsession · sandbox Reportproposals Ownerdecides Durable statetasks · decisions · pending actionsa restart resumes here
Ce que montre le schéma : les événements sont admis en deux temps, un coordinateur résident route chaque tâche vers un worker, et le propriétaire reçoit un rapport. Le propriétaire peut arrêter un worker, et un redémarrage reprend à partir de l'état durable.
  • Un coordinateur reste résident. Il route le travail et ne l'exécute jamais.
  • Chaque tâche s'exécute dans son propre worker, avec sa propre session et sa propre sandbox.
  • Des événements le réveillent : une planification, un ticket, un commentaire de revue, un résultat de CI.
  • Le code décide qui peut lancer un travail. Un modèle juge seulement si une règle écrite s'applique.
  • L'état est durable. Un redémarrage reprend ; il ne répète pas une action extérieure.

Ce qui le borne. La politique du repository, un budget par exécution et les droits d'accès de son propriétaire. Un background agent propose. Tout ce qui est livré passe par les mêmes validations que le changement d'une personne.

Essayer Rubbr sur votre propre code.

Demander une démo