Research

Open Areas of Research

We’re approaching process foundation modeling as a stack of small, decomposable bets — learn more below.

• 1
  DG-JEPA objective designMasks, horizons, target subgraphs, and Petri/temporal auxiliaries that force DG-JEPA to learn a genuinely predictive latent process state

  Challenge

  Our central conjecture is that JEPA-style masked latent prediction on typed temporal graphs produces a more reusable representation than next-event, link-prediction, or feature-reconstruction objectives. Everything downstream of that conjecture depends on it being true — so it needs to be tested before any architectural elaboration is layered on top.

  Mitigation

  We plan to train families of DG-JEPA objectives that progressively mask events, object lifecycle phases, joins, handoffs, delay regions, exception paths, Petri firings, and future suffixes, comparing them against next-event, feature-reconstruction, link-prediction, graph-transformer-from-scratch, and Petri-only baselines on the same input substrate.

  Success will be judged by linear probes over the learned representations, rather than by loss curves: can we recover known latent process state — enabled actions, missing dependencies, branch type, conformance status, bottleneck class, feasible future subgraphs — at materially higher fidelity than the baselines do? Where early masks teach shortcuts (e.g. predicting source-system identifiers, exploiting label leakage), we’ll tighten the mask distribution, strip identifier features, and weight targets toward Petri/temporal supervision rather than raw labels.

• 2
  Temporal & multi-object representationPreserving valid time, transaction time, late corrections, concurrency, and long-range dependencies without leaking hindsight into training

  Challenge

  Real-world processes are bitemporal: facts arrive late, prior events get corrected, and any model that ignores the difference between “what was true at time t” and “what we now know was true at time t” will learn to peek at the future during training. Most prior work skirts this problem by treating event logs as flat sequences over a single time axis. For a foundation model, we cannot afford to.

  This data gap is itself one of the central reasons no PFM exists yet — the bitemporal analogue of the broader data-shape problem set out earlier. Public process-mining datasets — BPI Challenge logs, OCEL corpora — all record a single time axis per event; none of them capture when a fact was first known versus when it was later corrected.

  Mitigation

  Unfortunately, solving this isn’t just a matter of minor data-cleaning. Rather, it’s the kind of “data not existing in the right shape” gap that, until very recently, made even contemplating a model like this impossible. hgres — our typed, multi-temporal, provenance-aware graph substrate — is the infrastructure we’ve spent the past seven years building specifically to close it. Now that the substrate exists, we intend to be the first through the door it has opened. Our bitemporal training and evaluation sources are accordingly hgres-recorded production data, industrial partner audit logs (which many enterprise systems maintain natively), and Petrinaut-generated synthetic logs with controlled correction patterns — complementing the public non-bitemporal corpora used elsewhere in our benchmark.

  On top of those data sources, the modeling risk is whether we can actually exploit the bitemporal structure without leaking hindsight back into the model. We’ll construct explicit “as-known-at-time-t” training views and matched later-corrected target views, then compare three input regimes on the same downstream tasks: single-case flattening, object-centric views, and full bitemporal multi-object graphs. Our judgment criterion will be twofold: hindsight-leakage detection (does performance collapse when late corrections are hidden during training?) and head-to-head performance on tasks involving late events, concurrent branches, cross-object joins, and long-range dependencies. If full bitemporal graphs prove too noisy or too large to train on directly, we’ll fall back to typed neighborhood extraction around cases, objects, resources, policies, and Petri markings — preserving bitemporal semantics where they matter the most.

• 3
  Representation fusionCombining text/schema features, SSM embeddings, Petri markings, and graph encoders without representation collapse or modality overfitting

  Challenge

  A DG-JEPA-anchored hybrid pulls in transformer embeddings for text, SSM embeddings for long timelines, Petri markings for symbolic state, and graph encoders for relational structure. The risk is not that any one of these modalities is wrong; but that, mixed naively, the model leans on whichever modality is easiest to overfit (schema strings, source IDs, timestamps, Petri labels), and DG-JEPA stops learning process state at all.

  Mitigation

  We’ll train and probe each modality separately before composing them, then run controlled early-, late-, and gated-fusion variants, with leave-one-modality-out ablations. The judgment criterion is whether the model can still recover latent process state when individual modalities are masked at evaluation time, and whether removing the DG-JEPA objective itself causes the representation to collapse into the cheapest available modality.

  If fusion is unstable, we’ll fallback to a more modular architecture, with DG-JEPA owning the graph-state representation, and other modalities entering only through adapters or downstream task heads — buying us robustness at the cost of some end-to-end optimization.

• 4
  Scaling without losing the rare-but-importantSampling enterprise bitemporal graphs at training time while still retaining the exceptions, anomalies, and recoveries that matter most

  Challenge

  Enterprise process graphs are large, but most of their structure is repetitive. The interesting paths — anomalies, exceptions, compliance violations, recoveries — are by construction rare. Naïve graph sampling (random walks, uniform ego-graphs) systematically under-represents exactly the paths a PFM most needs to learn from.

  Mitigation

  We plan on using stratified bitemporal graph sampling: common paths for coverage, rare conformance and anomaly paths for sensitivity, and Petri-guided sampling around token deficits, disabled transitions, joins, and rework loops.

  Scaling experiments will vary graph size, temporal horizon, object count, mask size, and Petri-supervision density, mapping out the empirical scaling behavior — including whether rare-path recall improves disproportionately under Petri-guided sampling, and whether scaling is monotonic in graph and supervision density.

  If global sampling proves too expensive, we’ll move to hierarchical views — event neighborhoods, object lifecycles, case subgraphs, and process-level summaries — recomposed at inference time rather than fitted into a single training pass.

• 5
  Evaluation infrastructureTransfer-and-robustness benchmarks and ablations that robustly demonstrate concrete advantage over baselines

  Challenge

  Public process-mining benchmarks largely test next-event prediction on a single log — which is precisely the wrong question for a foundation model, and rewards exactly the behavior we critiqued in our technical deep-dive: overfitting local vocabularies. The benchmark that judges this — one that explicitly tests transfer, robustness, missing-structure inference, and constraint awareness — does not yet exist at scale. We must, therefore, build it.

  Mitigation

  The benchmark will cover zero- and few-shot transfer across domains, missing-state inference, conformance-aware prediction, future-subgraph prediction, bottleneck diagnosis, fragment retrieval, and robustness to renamed labels, missing events, late corrections, and schema shifts.

  Every claim of our PFM’s advantage will be tested against sequence models, GNNs, graph transformers, OCPM-native methods, Petri-only baselines, graph autoencoders, and hybrid variants. Negative results will be treated as informative: a loss to a sequence model on cross-domain transfer would tell us next-token prediction is more useful than we currently think; a loss to a Petri-only baseline on conformance would tell us we’re under-using symbolic structure. Each negative result narrows the design space.

• 6
  Intervention validityEnsuring RL- and simulation-driven recommendations reflect causal effects and hard constraints rather than confounded historical correlations

  Challenge

  The most consequential PFM use cases — should we escalate this case? add capacity here? change this policy? — are causal questions, not predictive ones. But most enterprise event logs are observational, confounded, and incomplete. A model that learns historical correlations and then proposes interventions on the basis of them is, in the worst case, dangerous.

  Mitigation

  RL is therefore deliberately placed downstream of DG-JEPA and Petri filtering: action proposals come from feasible-action sets defined by the Petri net, consequences are first evaluated in counterfactual simulation, and offline RL uses conservative estimators rather than aggressive exploration.

  We separate predictive validity (does the latent state forecast accurately?) from causal validity (would an intervention move outcomes in the predicted direction?), and stress-test the latter with causal probes, policy-change simulations, and backtests against natural interventions where they exist in the data.

  Our judgment criterion is whether DG-JEPA-conditioned simulators predict outcomes of held-out natural interventions, and whether causal probes survive distribution shifts that ordinary predictive probes do not. If causal validity does not arrive in step with predictive validity — which is the expected case — high-risk recommendations remain human-reviewed until enough real-world outcome feedback supports deployment.