Compliance you can trust.

Imagine a night three years ago when a bank’s anti-money laundering system accidentally cleared a transaction. Now the auditors have shown up, and your leadership wants to know exactly why. The rules have changed, the data is gone, and the subject matter expert has moved on. How long until you can produce a full root cause analysis?

With a classical system, you’re lucky to have traces and logs. With ObzenFlow, you have a fully replayable tape.

Keep reading.

Learn how every stage here maintains a durable, append-only output tape, and everything written to its tape becomes execution instructions downstream. That’s how you build an audit-friendly durable workflow.

See the four ways

Run the demo yourself.

ObzenFlow's own overnight monitoring example runs one synthetic day of transactions against a simulated risk engine and case system, with nothing to install but Cargo.

View it on GitHub

Four ways ObzenFlow helps you navigate every audit.

Challenges with monitoring

In 2024, the FCA fined Metro Bank £16.7 million over monitoring failures that began in June 2016. Records its system rejected sat in Bad Data folders, reviewed only intermittently, and the transactions it missed weren’t reviewed until 2022.

Where ObzenFlow fits

ObzenFlow can’t tell you a feed is complete or a rule is right, but it archives all journals to durable storage by default, and unlike logs, journals represent execution and are directly replayable by the framework and auditable by the CLI. Auditability is one of the main features and one of the reasons we built the framework.

Make every risk engine call a first-class effect.

In ObzenFlow, an external integration, like one with an AML rules engine, is a first-class side effect handled by the framework’s algebraic effects system. This system allows all non-deterministic code to safely run during live processing, but also safely replay during audit and even resume after an unforeseen crash. It handles all of these scenarios elegantly. You usually can’t read the rules inside a vendor’s engine, so the only way to explain a verdict is to show the request score sent and the response it got back. ObzenFlow records the response with its rules version, and the input and fingerprint that reproduce the request.

risk_engine.rs · stages.rs · flow.rs
// risk_engine.rs
#[obzenflow::port]
#[async_trait]
pub trait RiskEnginePort {
    #[effect(type = "aml.score_transaction", exactly_once)]
    async fn score(
        &self,
        request: &ScoreRequest,
        key: &IdempotencyKey,
        ctx: &EffectContext,
    ) -> Result<outcome![TransactionCleared | AlertRaised], EffectError>;
}

// stages.rs
#[obzenflow::command(through = RiskEnginePort)]
#[derive(Clone, Debug)]
pub struct Scorer;

// flow.rs
stages: {
    score = effectful_transform!(
        ProfiledTransaction -> {
            TransactionCleared,
            AlertRaised,
            ScoreUnavailable,
        }
        => scorer
    );
    // …
},

Never silently drop another transaction.

In ObzenFlow, every stage is an event-sourced state machine with two journals, one for the records it produces and an error journal for the records it can’t process. From the moment the source reads a transaction, every stage either processes it or writes it to its error journal, and obzenflow show lists and counts every record in an error journal, so a rejected transaction is in the morning’s count.

$ obzenflow show "$RUN"
SOURCE ERROR (stage: transactions, error journal: 19)
runtime.source.record_rejected ← transactions()

  Stage                 Data records  Error records
  account_history                 91              0
  fx_rates                       138              0
  transactions                   276   3 Validation
  alerts                          12              0
  daily_profile                    4              0
  day_totals                       1              0
  open_case                       12              0
  price                          276              0
  profile                        276              0
  score                          276              0
  case_register                   12              0
  cleared                        268              0
  totals_report                    1              0
  unopened_alerts                  0              0
  unscored                         0              0

Records in an error journal were delivered but not processed.

Delivery guarantees are validated.

In ObzenFlow, every edge carries a transport contract, and every edge into a register carries a delivery contract too. At the end of the night the runtime reconciles every handoff against the journals, with no code from you. transactions wrote 276 records and profile read 276. open_case sent 12 cases and case_register receipted all 12, none missing. Each result is journaled with the night, so a handoff that loses a record fails that night rather than six years later.

obzenflow show --include-runtime · aml_overnight_monitoring
RUNTIME (stage: profile, journal: 10)
runtime.contract.verification_passed ← profile
⋮
{
  "upstream": "transactions",
  "upstream_journal": 4,
  "contract_name": "TransportContract",
  "phase": "final",
  "advertised_writer_seq": 276,
  "consumed_count": 276
}

RUNTIME (stage: case_register, journal: 12)
runtime.contract.verification_passed ← case_register
⋮
{
  "upstream": "open_case",
  "upstream_journal": 8,
  "contract_name": "DeliveryContract",
  "phase": "final",
  "consumed_total": 12,
  "receipted_total": 12,
  "missing_count": 0,
  "orphan_count": 0
}

Play back any past night, then run it again under new rules.

In ObzenFlow, every run is archived with evidence of all inputs, outputs and decisions made. This follows formal automata theory and is how this works without locking you into databases to support it. A manifest is written during every run which contains all journals, and those journals are replayable tapes.

  1. Play the night back

    --replay-from replays a historical manifest regardless of how much time has gone by. Preserve the manifest on long-term storage and audit years later. The effects system makes sure you can replay even without access to a historical risk engine or case system.

  2. Run it again under new rules Coming soon

    We’re building support for swapping out the systems you replay against, such as a risk engine running new rules. It’s the next big evolution of our algebraic effects system.

Build your next monitoring flow on ObzenFlow.

ObzenFlow is open source. Star the project to follow its progress, or start a tutorial and build something yourself.

Have a question? Ask it in GitHub Discussions.