RPA is two regex bets. If you want to know whether a bot will hold up, read those regexes.

The thesis

A robotic process automation system has one mechanical job: take a recording made yesterday, walk the live screen today, and decide whether what is on the screen now is the same thing the recording was made against. If yes, run the recorded step. If not, pause. Everything else (the recorder, the executor, the queue, the retry policy) is downstream of that one decision.

The decision is not made on raw screen captures. The screens are captured as accessibility trees, the way a screen reader sees them, and the trees are compared. The interesting question is how. Two trees are never byte-identical between runs. Window positions shift. Internal ids get recomputed. The visible content of an input field changes the moment a user types into it. Without a rule for which differences matter, every comparison would scream change and every bot would pause every run.

So the rule is: throw away the bytes that are known to be volatile before comparing. What remains is the substrate of the bet. RPA is a bet that what remains is enough.

The bet, in two regexes

Mediar publishes its desktop runtime as the Terminator project at github.com/mediar-ai/terminator under MIT. The diff layer lives incrates/terminator/src/ui_tree_diff.rs. The compact YAML path is the most legible. Here is the function that runs before any two captures are compared.

// crates/terminator/src/ui_tree_diff.rs

pub fn remove_ids_and_bounds_from_compact_yaml(yaml_str: &str) -> String {
    // Remove #id patterns (e.g., #12345, #abc-def-123)
    let id_re = Regex::new(r" #[\w\-]+").unwrap();
    let result = id_re.replace_all(yaml_str, "");

    // Remove bounds patterns: "bounds: [x,y,w,h]"
    let bounds_re = Regex::new(r"bounds: \[[^\]]+\],?\s*").unwrap();
    bounds_re.replace_all(&result, "").to_string()
}

// Before: - [Button] Submit #id123 (bounds: [10,20,100,30], focusable)
// After:  - [Button] Submit (focusable)

The first regex finds a leading space, then a hash, then a run of word characters or hyphens. It deletes them. That is the rule for stripping the unique id token the platform attaches to every UI element. The second regex finds the four-coordinate bounds block in square brackets and deletes that too, along with any trailing comma and whitespace.

The companion JSON path makes the same bet a different way. Instead of regex, it walks the parsed tree and drops two map keys.

// crates/terminator/src/ui_tree_diff.rs

pub fn remove_ids(value: &Value) -> Value {
    match value {
        Value::Array(arr) =>
            Value::Array(arr.iter().map(remove_ids).collect()),
        Value::Object(obj) => {
            let mut new_obj = serde_json::Map::new();
            for (key, val) in obj.iter() {
                if key != "id" && key != "element_id" {
                    new_obj.insert(key.clone(), remove_ids(val));
                }
            }
            Value::Object(new_obj)
        }
        _ => value.clone(),
    }
}

Two regexes for the line-oriented format, two key drops for the tree-oriented format. Both express the same bet. Read them once and you understand more about what an RPA system can and cannot do than you would learn from any vendor brochure.

The diff layer in flight

The two regexes do not run on their own. They are step one of a short pipeline that runs every time the executor needs to decide whether a recorded step still matches the live screen. The diagram below is the call shape.

The Compare actor is thesimple_ui_tree_difffunction in the same file. It uses thesimilarcrate to do a line-based diff over the cleaned trees and returns None when there are no differences and Some(diff) otherwise. Replay reads that result and either continues or pauses for human review. The whole loop is deterministic. There is no model in it.

Three consequences of that bet

The two-regex strip is one design choice, but the choice cascades. Here is what flows downstream of it.

The bet is not a hack. It is the operating spec of the category. Once you accept that the diff layer trusts role and name and distrusts ids and coordinates, the rest of the bot design follows. A recorder that stored XPath would be making a different bet. A recorder that stored bitmap hashes would be making a worse one.

The counterargument

The fair counterargument is that vision-based RPA, the variety that watches a screen as pixels and asks a model what is on it, does not need this bet at all. It can match a button by appearance and reach back into the screen at runtime regardless of whether the underlying tree exposes a useful name. That is true, and it is also the wrong way to think about it.

Vision RPA makes a different bet. It bets that a button looks roughly the same across releases, that font rendering has not changed, that anti-aliasing is stable, that an icon set has not been refreshed, that the viewport DPI matches. Those bets are also sometimes wrong. The maintenance shape is different (the failures cluster around visual refreshes rather than id renumberings) but the shape exists. The honest claim is not that one bet is free and the other is expensive. The honest claim is that the accessibility-tree bet is what survives the failure modes that actually occur in legacy desktop ERPs, banking cores, and EHRs, because those vendors are required by their customers and by regulation to maintain the accessibility surface across releases.

On a brand-new SaaS app with no accessibility commitments and a visual designer who reflows the canvas every quarter, neither bet is great. That is the right place for an LLM-driven browser agent, not for traditional RPA at all.

What this changes for the buyer

The reason to pay attention to those 144 lines is not academic. The dollars on the contract are downstream of them. A bot that survives a vendor release runs the workflow. A bot that does not survive pages a human and cuts a maintenance ticket. The difference between those two outcomes is whether the diff layer chose to throw away the bytes that the vendor was free to change.

Closed-source RPA hides this decision. UiPath, Automation Anywhere, and Blue Prism do not publish the equivalent of ui_tree_diff.rs. There is no way for a buyer to read which attributes the diff layer trusts and which it strips. The implementation is opaque, the bet is implicit, and the failure mode is whatever bug the vendor has not caught yet. The pitch is reliability and the proof is a slide deck.

Open source flips that. The buyer can read the file, run the tests, fork the repo, and build the desktop binary themselves. Mediar ships the runtime that wraps this file as a desktop app and charges $0.75 per minute of runtime, but the file itself is MIT licensed and small enough to be read in one sitting. The reason the company is comfortable shipping this in the open is exactly that the bet is correct: when you see what attributes the diff layer keeps and which it throws away, the design defends itself.