A recorder-first read of an enterprise RPA platform

RPA Automation Anywhere is a recorder plus a runtime. The recorder format is where the architecture cracks.

Automation Anywhere is an enterprise RPA vendor. The product, in plain shape, is two pieces: a recorder (Bot Creator, with the Object Cloning command as the load-bearing capture mode) and a runtime (Control Room plus Bot Runner). The recorder serializes UI elements as a property fingerprint, the runtime replays the fingerprint at execution time. Most pages on this topic stop at a feature list. This one stops at the format itself, because the format is what decides whether your bots break on a Tuesday morning after a vendor UI release.

M
Matthew Diakonov
11 min

Direct answer (verified 2026-05-08)

What is RPA Automation Anywhere, in one sentence.

Automation Anywhere is an enterprise RPA platform whose recorder (Bot Creator, Object Cloning) captures UI element fingerprints and whose runtime (Control Room, Bot Runner) replays them. “RPA Automation Anywhere” is shorthand for that recorder-plus-runtime model.

Authoritative source: the vendor Object Cloning documentation and the Control Room architecture overview.

1. The recorder is the part that decides everything else.

Every RPA platform looks like a control plane in the marketing material (governance, scheduling, queues, audit), and every RPA platform is a recorder format underneath. The control plane is commodity. The format is not. What the recorder captures, and what it discards, is the bet the platform is making about which UI changes count as “the same workflow” on Tuesday and which count as a new one.

Automation Anywhere’s Object Cloning command sits at the most conservative end of that bet. It captures roughly twenty properties per element, including left, top, width, height, state, path, name, value, and a technology token. Almost anything that changes in the rendered UI shows up as a delta against that fingerprint. The runtime tries to relocate the element by matching the fingerprint, and when the match fails (vendor reflow, DPI change, validation step inserted ahead of the field, theme update), it raises an error and a developer is re-pointed to the recorder client to capture again.

That is the design intent. It is also why an Automation Anywhere center of excellence has a permanent maintenance backlog, not a one-time implementation cost. The format is where the cost lives.

2. What Object Cloning actually serializes.

Below is a representative serialized element fingerprint. The property names match what the vendor documentation describes the recorder as capturing for the STANDARD technology (Windows controls). The shape is the point: pixel-adjacent coordinates, a path token, a state token, and the visible name all travel together as a single match unit.

Same button, two recorder formats

<!-- Automation Anywhere Object Cloning: serialized element fingerprint -->
<!-- Captured by Bot Creator. Replayed at runtime by Bot Runner. -->
<element>
  <technology>STANDARD</technology>
  <name>Post invoice</name>
  <path>Toolbar/Group/Button[3]</path>
  <left>847</left>
  <top>234</top>
  <width>92</width>
  <height>28</height>
  <state>Focused, Enabled</state>
  <value></value>
  <html_innertext></html_innertext>
</element>
<!--
A vendor UI release that nudges the toolbar three rows down,
inserts a validation step in front of the button, or renames a
path segment will invalidate this fingerprint at runtime.
The bot raises 'Unable to perform Click action (TYPE_024)'
and a developer has to re-record the element.
-->
0% fewer fields in the match

A click on a static button on a static page works fine in either format. The difference shows up the first time the underlying surface changes. The fingerprint on the left has roughly ten independent ways to invalidate; the match on the right has two (role and name), and a screen-reader user would notice exactly the same two changes if either one drifted.

3. The other recorder format, in source.

The recorder Mediar ships does the opposite of what Object Cloning does. It treats the pixel stream as noise and only serializes events whose meaning survives a layout change. The function below is the literal filter, copied from the desktop agent’s source file. Six event types pass through. Everything else is dropped before the workflow file is authored.

apps/desktop/src-tauri/src/recording_processor.rs

Three things are worth pointing at in that filter. First, there is no mouse_move, scroll, or raw_keystroke case; those are explicitly dropped at the source rather than recorded and post-filtered, because keeping them around is what tempts a recorder to identify elements by where the cursor went. Second, text_input_completed is the aggregated final value after a focus loss, not a stream of keydown events; the recorded artifact says “the user typed 30 March 2026 into the date field,” not “the user pressed 3 then 0 then space then M….” Third, the file path is stable: you can grep for is_meaningful_event_type in the public Terminator SDK on github.com/mediar-ai/terminator and read the same six-event filter.

4. The runtime: how a recorded artifact reaches the OS.

Automation Anywhere’s runtime is Control Room (orchestration, credentials, scheduling, audit) plus Bot Runner (the local agent on the machine that hosts the target app). A bot is dispatched from Control Room to a Bot Runner, the runner loads the recorded task, and at every step it asks the OS “find me the element that matches this fingerprint.” The accessibility-API runtime has a similar shape, but the question it asks the OS is different: “find me the element with this role and this name.” The diagram below traces the second shape end to end.

Accessibility-API runtime: recorder to OS, in one pass

RecorderWorkflow fileExecutorOS UIAwrites 6 event types (no pixel data)loads a deterministic .ts artifactfind { role, name }AccessibleElement (Role=Button, Name=Post invoice)click()ok

The model in this pipeline lives at authoring time (when the workflow file is generated from the recording), not at runtime. That matters for two reasons relevant to anyone replacing Automation Anywhere. The runtime stays deterministic, so the compliance team can read an audit log without needing to know what a model decided. And the cost of a step is the cost of an OS call (microseconds), not the cost of an LLM call (hundreds of milliseconds plus tokens).

6

Six event types pass the recorder filter. Mouse moves, scroll deltas, and raw keystrokes are explicitly dropped before any workflow file is authored. The pixel stream is never captured at all.

apps/desktop/src-tauri/src/recording_processor.rs:250-259

5. The economic shape that follows from the format.

A platform that captures roughly twenty properties per element spends most of its operating cost in two places: license fees that price the runtime per bot, and people who keep re-pointing the recorder when fingerprints invalidate. A platform that captures two properties per element does not have the second cost in the same shape, because most UI shifts do not invalidate a Role+Name match. The numbers below are typical of what an enterprise RPA buyer is comparing in 2026.

$0K to $500K+Typical Automation Anywhere annual contract
0+ propertiesCaptured per element by Object Cloning
0 propertiesUsed by an accessibility-tree Role+Name match
0%Cost cut on one F&B SAP B1 migration off RPA

The 70% number is from a specific deployment (an LG-customer F&B chain that moved a SAP B1 order-entry workload off UiPath onto Mediar; the same architectural argument applies to an Automation Anywhere migration on the same surface). The other numbers are the shape of the published vendor pricing and the literal property counts in the two recorder formats. None of them are a press-release quote and none are computed against an invented baseline.

6. The counterargument: when Automation Anywhere still wins.

Three cases. The first is when the workflow’s binding constraint is integration breadth into the Automation Anywhere ecosystem itself: the IQ Bot pre-built document classifiers, the Bot Store catalog, an existing center of excellence with sunk training cost, or a procurement office that needs the buyer’s existing master agreement. Those are real pieces of value and they do not transfer.

The second is when the target application exposes nothing useful through the OS accessibility tree. Some custom-rendered Direct2D canvases, certain remote-rendering stacks where the UI tree is empty on the local machine, and a small number of specialty industrial control surfaces fall into this bucket. On those, the best you can do is fall back to a vision-based recorder, which is a different category of bet from either Object Cloning or an accessibility-tree match.

The third is when the buyer has already spent enough on Automation Anywhere implementation that the sunk cost outweighs the maintenance cost the format imposes going forward. That is a financial argument, not a technical one, and it has an expiration date that the maintenance backlog itself eventually moves past.

7. Resolution: pick the format that survives a UI release.

The decision is at the recorder layer, not the dashboard layer. Two questions, in order. Does the workflow live on a surface that exposes a usable accessibility tree (SAP GUI, Oracle EBS, Jack Henry, Fiserv, FIS, Epic, Cerner, Office, most Win32 desktop apps, and any modern web app do)? If yes, an accessibility-API recorder will absorb most of the UI shifts your Object Cloning bots currently break on. Does the workflow run often enough that the maintenance backlog is a real cost line (more than ten times a week, or with a SLA on completion)? If yes, the format choice is load-bearing for the next 24 months of operating cost.

If the answer to either is no, the architectural argument here is weaker and a feature-list comparison is the right next step. If the answer to both is yes, the migration shape in the FAQ below (one workflow, two-week parallel run, cut over on zero divergence) is the cheapest way to find out whether the recorder format actually does what this page says it does on your specific surface.

Common questions about RPA Automation Anywhere

What does 'RPA Automation Anywhere' actually refer to?

Automation Anywhere is an enterprise RPA vendor whose platform is, in plain shape, two pieces: a recorder (Bot Creator, with the Object Cloning command as the load-bearing capture mode) and a runtime (Control Room plus Bot Runner). The recorder serializes an interacted-with UI element as a property fingerprint (left, top, state, path, name, value, technology). The runtime replays the recorded sequence and tries to relocate each element by matching that fingerprint at execution time. Everything else in the marketing surface (IQ Bot, Co-Pilot, Automation 360, autonomous agents) sits on top of, or extends, that recorder-plus-runtime core. When people search for 'RPA Automation Anywhere' they are almost always asking about that core.

Why does the Object Cloning recorder break when a vendor ships a UI release?

Because the fingerprint it serializes is overspecified for the surface it claims to abstract. Object Cloning captures, among other things, left, top, height, width, state, and a path token. Vendor UI releases routinely move elements by a few pixels (DPI changes, panel reflows, theme updates), change the state token (new validation step in front of an existing field), or rename a path segment. Any one of those changes invalidates the recorded match, and the bot raises a runtime error: 'Object not found,' 'Unable to perform Click action.' The fix is for a developer to re-record the element, which is why an Automation Anywhere center of excellence has a permanent maintenance backlog scaled to its bot count, not a one-time implementation cost.

What is the architectural alternative that does not have the same failure mode?

Identify elements by the role plus name tokens an OS accessibility tree exposes (the same interfaces a screen reader uses), not by recorded property fingerprints. A button that is rendered as Role=Button, Name='Post invoice', Focusable=true is found by 'Role=Button, Name=Post invoice' regardless of where on the screen it sits, what its internal path token is, or whether the surrounding panel reflowed yesterday. The recorder records the role and name and drops the rest. This is exactly what Mediar's recorder does: the recording_processor.rs file at lines 250 to 259 filters down to six event types and explicitly drops mouse moves, scroll deltas, and the pixel stream before the workflow file is ever authored.

Is the accessibility-API approach actually cheaper than Automation Anywhere, or just different?

Both, but the cheaper part is downstream of the architecture, not a separate pricing trick. Automation Anywhere's per-bot license sits in the high four figures per year; an enterprise contract typically lands in the $100K to $500K+ range for production scale. On top of that you pay for the implementation team (RPA developers certified on the platform) and you pay for the maintenance backlog every time a UI shifts. Mediar charges $0.75 per minute of runtime against a $10,000 prepay that converts to credits. The pricing is meaningfully lower at the meter, and the maintenance line is structurally smaller because most UI shifts do not invalidate a Role+Name match. One LG-customer F&B chain that moved a SAP B1 workload off UiPath onto Mediar reported 70% lower total cost; the same architecture argument applies to an Automation Anywhere migration.

When does Automation Anywhere still beat an accessibility-API approach?

When the workflow's binding constraint is integration breadth into the Automation Anywhere ecosystem itself: Co-Pilot for the business user, IQ Bot's pre-built document classifiers, the Bot Store catalog, an existing Automation Anywhere center of excellence with sunk training cost, or a procurement process that requires the buyer's existing master agreement. Also when the target surface is a piece of software that exposes nothing useful through the accessibility tree (some custom-rendered Direct2D canvases, certain remote-rendering stacks where the UI tree is empty on the local machine). Those are real cases. The argument on this page is not that accessibility-API replaces Automation Anywhere universally; it is that the recorder format is the part that decides whether the replacement holds, and on most enterprise surfaces (SAP GUI, Oracle EBS, Jack Henry, Fiserv, FIS, Epic, Cerner) it does.

How many event types does Mediar's recorder serialize, and how is that verifiable?

Six. button_click, browser_click, text_input_completed, browser_tab_navigation, application_switch, file_opened. The function is named is_meaningful_event_type and lives in apps/desktop/src-tauri/src/recording_processor.rs at lines 250 to 259. The Mediar product source is under the mediar-ai org on GitHub for the Terminator SDK and runs in the Mediar desktop binary; you can also read it in the open-source Terminator SDK at github.com/mediar-ai/terminator. Mouse moves, scroll deltas, and the raw keystroke stream are dropped before any workflow file is authored. That is the recorder format Object Cloning is, in effect, the inverse of: Object Cloning aggregates pixel-adjacent properties; this recorder discards them.

What does a reasonable migration off Automation Anywhere look like?

Pick one workflow that breaks the most often (the maintenance backlog already tells you which one). Record it once with the new tool against a real production surface. Run both in parallel for two weeks; treat any divergence as a recorder-format defect to be diagnosed in the same way you diagnose a stuck Object Cloning element today. Cut over the workflow when divergence drops to zero. Use the production data from that one workflow (wall-clock time saved, error rate, maintenance-touch count) to size the rest of the migration. The mistake is to size the migration off the marketing pitch instead of off your own one-workflow proof.

Read the recorder format on your own surface in 30 minutes.

Bring one workflow that breaks the most often on your current Automation Anywhere bots. We will record it once with the accessibility-API recorder and show you what the resulting workflow file looks like, line by line.