Rubbr Book a demo

Platform

The building blocks of your factory.

A platform team gets agents that work on day one, built on six blocks that are code and configuration you can read, review and program. This page says how each block works.

Rules

Nothing ships outside your rules

A missing or invalid policy blocks every ship action. Thirteen kernel rules cannot be disabled.

Record

Every decision is on the record

State is derived from the policy at the base commit plus a journal, so each requirement traces to a line of YAML.

Context

Answers say what they rest on

The catalogue records, the code graph suggests, the source shows. Only the pinned source confirms.

Isolation

No credentials in the sandbox

The agent loop and its credentials stay outside. Each run gets a fresh microVM.

01 · Rubbr Workflows v0.3 · active development

Workflows that know what each result rests on.

A workflow runtime that records, beside what ran, what each result depends on. When a result is refuted later, it repairs only what rested on it.

Version 0.3, in active development. The research paper is under review. Open-source release expected mid-December 2026.

Why now

A person can no longer be the ledger.

Build systems

what exploded
Sources and build rules.
what the tool keeps
What each artefact was built from. Rebuilds only what changed.

Terraform

what exploded
Cloud resources.
what the tool keeps
What exists and the configuration it came from. Changes only what differs.

Rubbr Workflows

what exploded
Workflows, now that AI makes them cheap to write, with steps that are predictions made by language models.
what the tool keeps
What each result rests on, fact or prediction. Repairs only what lost its support.

The difference: a build invalidates from file hashes. Here the invalidation is late evidence from the world, and side effects are corrected, not recomputed.

The case

A step that succeeds, and is refuted later.

A diagnosis and a patch are predictions. Tests pass, the deploy succeeds, and fifteen minutes later the metrics say no. That verdict says the diagnosis and the fix are not both right; it does not say which. This is one executed run.

Incident workflowexecuted run
1 / 5

Every step succeededAn execution log says healthy. Two of these results are predictions.

Fifteen minutes later: noThe verdict refutes the outcome only. It does not say which prediction was wrong.

Replace the patchThe runtime does not guess. Your handler, code or an agent you declare, looks at the evidence and restarts at the patch. Deployment 1 is corrected, not re-run.

No again: replace the diagnosisThe handler restarts one step earlier. Only what rested on the diagnosis is redone.

YesThree deployments, two corrections, context produced once. A fourth no would have stopped the run at its limit.

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

What the diagram shows: a late verdict refutes one result, and repair replaces only what rested on the wrong prediction. The accent marks what changed at each step.

What you write

Write the happy path, then declare which result depends on which.

The workflow is ordinary code, one line per step. A second file declares what the code cannot say: what to watch after a side effect, and who decides when a result proves wrong. Each number links a note to the lines it is about.

integrated-incident.rubbrthe workflow · lines 59 to 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.rubbrwhat it declares · lines 92 to 202

The deployment is watched for 15 minutes. Its result is known only then, and correct is how it is undone if it must be replaced.

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

When the outcome is refuted, a handler takes over. It may restart the run at two declared points only, the patch or the diagnosis, and at most twice.

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

An agent is mandated to weigh the new evidence and decide. It reads the run so far and the prediction that failed, then says where the mistake lies: in the patch or in the diagnosis.

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

Then the runtime takes control back. The advice names one of the declared entries, and the runtime calls it: there is no dispatch code to write. It replaces that step and everything that rested on it, corrects the deployment through its receipt, and watches the new outcome.

Side effects are never run twice: a replay reuses the receipt, a replaced one gets its declared correction, and an uncertain delivery is looked up, never retried blind.

Beyond Temporal

Beyond Temporal: the repairs you would otherwise write by hand.

Temporal gives durable replay, retries, timers and sagas you write by hand. None of that is new here, and a Temporal workflow could host this runtime. The difference is what is recorded: a saga log records what happened; a dependency graph records what depended on what.

TemporalRubbr Workflows
A step that succeeded, refuted laterBranches and loops in your code.The outcome is refuted, and repair restarts at a declared point, within limits.
Undoing a side effectA saga you write.A declared correction, tied to the original receipt.
"What depended on what?"Read the code.Query it: it is recorded state.

The runtime enforces the checks you write; it does not decide by itself that a result is true.

Research paper

Under review

The full model, its guarantees and the comparison with build systems and durable execution. Published here when the review is complete.

Open source

Mid-December 2026

The runtime, its language and a set of example scenarios, as runnable source.

02 · Rules as code

What may ship is a file in your repository.

.rubbr/policy.yaml is plain YAML under a strict schema, with no expression language. It declares areas, an acyclic graph of ship actions, and one rule engine of when and require.

  • Evaluated at the patch's base commit. A change that edits the policy is governed by the old one.
  • Risk is measured on the patch. Catalogue anchors, graph callers, judged facts and the reviewer can only raise it.
  • Lowering risk is a recorded human act. A developer may lower it with a reason, for that patch identity only.
  • Judged facts are recorded with the model, the instruction, the input hashes and the reason.
  • Approvals bind to one revision.
  • State is derived, from the policy at the base commit plus the journal. Every requirement traces to a YAML line.

The kernel

Thirteen rules cannot be disabled by any policy. Four of them:

  • A receipt never comes from the coding agent.
  • No model output satisfies a requirement.
  • A missing or invalid policy blocks everything.
  • An unknown outcome fences the subject, with no automatic retry.
Four changes, one policy · Nordwind ERP
1 / 4

Rename a labelOne translation file. Only the base rule matches.

Change invoicingThe patch touches the invoicing area and is measured at medium risk. Two more rules match.

Reply to a customerNot a patch: a different ship action, with its own subject and its own rule.

Touch paymentsThe payments rule applies whatever the risk level, beside the others.

.rubbr/policy.yamlexcerpt
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 } }

Measured on the patch

  • files1 · htdocs/langs/en_US/bills.lang
  • areas touchednone
  • risklow
  • files2 · …/facture/class/invoice.class.php and its test
  • areas touchedinvoicing
  • riskmedium, raised by a catalogue anchor
  • subjecta drafted reply, not a patch
  • areas touchednot applicable
  • risknot measured
  • files3 · under htdocs/compta/paiement/
  • areas touchedpayments
  • riskhigh, raised by graph callers

What the rules require

  • basechecks pass, nothing blocking left to settle, a confirmation
  • basechecks, nothing blocking, a confirmation
  • medium_and_upa developer approves the patch; the spec is agreed
  • qaQA approves the deployment before release
  • support_leadthe support lead approves this reply
  • basechecks, nothing blocking, a confirmation
  • medium_and_upa developer approves the patch; the spec is agreed
  • payments_ownerthe finance owner approves the patch
  • qaQA approves the deployment before release

Who is needed

The product manager.

The product manager, a developer, QA.

The support lead.

The product manager, a developer, the finance owner, QA.

What the view shows: the same file answers four different changes, and each requirement on the right is the highlighted rule on the left.

Approvals go stale

Host rules make an approval stale first: higher risk, a newly touched area, a different patch outside the approved files. Otherwise an independent reviewer, never the coding agent, judges whether the new revision is structural.

Receipts

A performer acts and returns a receipt for one revision: a provider the operator installed, or a result observed through your source control, CI and monitoring. The receipt never comes from the coding agent.

Decision replay

Decisions are pure functions of the policy at the base commit and the journal, so a past decision is replayed from its record and gives the same result.

03 · Sandboxes

A fresh computer for every run.

Each run gets its own microVM, cloned copy-on-write from a template built from your Dockerfile. The application, the tests and a browser run there, and nowhere else.

0.4 swarm unit suite
0.7–0.8 sbrowser check
0.5 mscall round trip into the sandbox
9–23 swhole session
~70 stemplate prepared, once

Measured on our test project, on a Mac with Apple's hypervisor.

Sleep and warm wake

A sandbox sleeps while nothing runs in it, and wakes warm for the next tool call.

Checkpoints

A run's sandbox can be checkpointed, and restored from that point.

Where it runs

MicroVMs run on Apple's hypervisor on a Mac, and on Firecracker in the cloud.

Layers of a sandbox
1 / 3

A run startsOnly the top layer is created, as a copy-on-write clone of the template. Nothing below is rebuilt.

You bump a language versionYour toolchain is rebuilt, and so is everything above it. The two layers below are reused.

Rubbr ships a security fixThe fix is in the base system, so every layer above is rebuilt, once. Runs then start from the new 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
What the diagram shows: a change to a layer rebuilds that layer and everything above it, never anything below.
Where compute is used during a 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
What the diagram shows: the same session, drawn at the same length. With the agent outside, the sandbox computes only during tool calls and is idle while the model thinks. The sandbox sleeps during those gaps.

The security idea: the agent loop and its credentials live outside the sandbox, and the tool call is the security boundary. The computer where code runs then holds no secrets. A computer with no secrets can be disposable.

04 · Product context

Three sources, and an answer that says which.

Agents and people ask about the product in business words. Answers draw on three sources of different authority, and the host enforces how each may be quoted.

Functional catalogue

what it is
Features in business words, each anchored to a file, lines and a hash. Produced by one pipeline with one final reviewer, exported immutable, published with a receipt and a read-back.
what it can establish
What a feature is for, and where to start reading.
what it cannot
That the list is complete, or that the code still does it.

Code graph

what it is
One-hop call leads around a symbol.
what it can establish
Where to look next: navigation leads, not verified relationships.
what it cannot
Isolation. A missing edge proves nothing.

Source at a pinned commit

what it is
Your Git repository, read at one commit.
what it can establish
What the code does. It is the only confirmation.
what it cannot
What the code does at any other commit.

The phrasing rule, enforced by the host: the catalogue records, the code graph suggests, the source shows.

Questions

People and agents ask over all three sources, and each statement in the answer cites the one it rests on.

Versions

A catalogue version belongs to one Git commit of your repository. A new commit updates the catalogue for what changed, and an answer reads the catalogue and the source at the same commit.

05 · Extensibility

One plugin mechanism, used by the product itself.

Everything is a plugin: the agent loop, the model adapter, the rules engine, each card on screen. A plugin provides or consumes a service, registers a tool, intercepts an event, or adds an interface component.

The plugin map45 plugins · 5 agent presets · 7 contracts
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
What the diagram shows: agents depend on contracts, never on a provider, and everything else is a plugin, grouped here by what it does. Dashed chips are yours: your own agents and plugins are added through the same mechanism. Changing a provider is a configuration change.

Contracts, not vendors

Agents depend on a contract: model, coding agent, shell, tickets, documents, messages, source control. Each has interchangeable providers, chosen in configuration.

Bring your coding agent

The implementation step runs the built-in agent, Codex or Claude Code. Whichever runs, the receipt comes from the host or an integration, never from the agent.

Your tools

Jira, Confluence, Slack, GitHub and CI are providers. Every write keeps a receipt and is never retried when uncertain. MCP connects approved read tools.

The trust split

Only the operator installs executable plugins. A repository supplies typed YAML, in layers that can only tighten. It cannot grant itself a permission.

06 · Background agents

Agents that keep working, inside the same rules.

Background work comes in two forms. Both are bounded by policy, budget and access rights, and neither has a private path to production.

Two ways to run in the background
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.
What the diagram shows: the same base bounds both forms. A workflow follows a path written in advance; a free agent finds its path, inside limits.

Workflows

Declared steps, checks you write and a ledger. When a result turns out wrong, repair restarts at a declared point, a limited number of times. Use them when the path is known.

Free agents

A goal, an owner and a budget. The agent chooses its own path, for exploratory work: triage, investigation, watching for drift.

How a long-running agent works

A long-running agent
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
What the diagram shows: events are admitted in two stages, a resident coordinator routes each task to a worker, and the owner receives a report. The owner can stop a worker, and a restart resumes from durable state.
  • A coordinator stays resident. It routes work and never executes it.
  • Each task runs in its own worker, with its own session and sandbox.
  • Events wake it: a schedule, a ticket, a review comment, a CI result.
  • Code decides who may start work. A model only judges whether a written rule applies.
  • State is durable. A restart resumes; it does not repeat an outside action.

What bounds it. The repository's policy, a budget per run, and the access rights of its owner. A background agent proposes. Anything that ships goes through the same gates as a person's change.

See it on your own codebase.

Book a demo