The browser you can use. The code you never have to invite in.

The ordinary click is the difficult part

A finance analyst opens a supplier portal, changes a number in a spreadsheet, and copies a reference into an internal system. Nothing about that sequence feels like a security event. Yet the browser is downloading and executing code, maintaining an authenticated session, and moving data between organizations. It is simultaneously a workspace, a software delivery channel, and a boundary between different kinds of trust.

Browser isolation changes where part of that work happens. A remote environment executes the website while the endpoint receives a representation it can interact with. The user should still recognize the application. The security team should be able to identify where its code ran, which data crossed the boundary, and what happened when the session ended.¹

The difficult question is not whether a remote page can appear on a screen. Remote desktops have answered that. It is whether isolation can disappear into daily work without disappearing from the security architecture. A sticky text cursor, an inaccessible dialog, or a lost keyboard shortcut can matter as much to adoption as an impressive demonstration of malware containment.

Separate execution from representation

A browser turns application state into a visual scene. That scene can be transported in different ways. Pixel streaming sends rendered images. DOM reconstruction sends a transformed representation of page structure. A vector-oriented rendering path operates closer to drawing instructions: describe what to paint, then reproduce the result at the receiving end. Each choice creates different bandwidth, fidelity, compatibility, and security obligations.²

Antara uses Network Vector Rendering, or NVR, with Skia in its RBI architecture. Skia is a graphics engine; CanvasKit brings its drawing capabilities to WebAssembly. Those are useful building blocks for reproducing a scene, but they do not constitute a complete isolation system. The browser process, renderer protocol, input channel, file handling, and session lifetime all remain part of the design.³

That distinction matters during procurement. “Uses Skia” tells you something about graphics. It does not tell you how the service isolates tenants, validates messages, handles a renderer fault, or retires credentials. Ask for an architecture conversation that follows one input event and one sensitive file all the way through the system.

There is no single number called “fast”

Imagine pressing a key. The browser may display a local response quickly, while a server-dependent result must still travel to another machine and back. Input feedback, remote execution, and final presentation are different stages. An interface can feel immediate in one task and sluggish in another without changing its advertised network latency.

The Event Timing API provides a way to reason about the delay and processing associated with user interactions. It is useful evidence, but the measurement still needs a defined task. Typing into a text field, opening a large workbook, and submitting a form do not exercise the same dependencies.⁴

The graph is an arithmetic budget, not an Antara benchmark. It holds remote execution and presentation constant and changes only the round-trip network delay. The lesson is practical: moving a service closer to users can help; eliminating an unnecessary round trip can help; choosing an efficient rendering path can help. None removes the need to measure the complete application interaction.

An evaluation should include the median and a tail percentile such as p95, where slow cases become visible. Repeat tasks during realistic congestion and loss. Record where the user is, where isolation runs, and where the application runs. A single average from an ideal connection can hide precisely the conditions that generate support tickets.

A familiar page is more than a screenshot

High visual fidelity is necessary, but it is not sufficient. Enterprise applications depend on text selection, international input methods, password managers, accessibility APIs, printing, file pickers, and sometimes browser or device integrations. A page may look correct while the workflow is unusable. Published RBI compatibility guidance is a reminder that these boundaries need explicit treatment.⁵

Choose tasks from actual roles rather than a vendor’s favorite web pages. A procurement user and a developer will produce different test suites. Include exceptions that have historically driven people to bypass security controls. The aim is to discover friction while changing the design is still easy, not after an organization has committed to a broad rollout.

Isolation gives the auditor a better question

Antara’s agentic packet auditor adds an investigation layer to the access and browsing story. The useful question is not merely “Was there a connection?” It is “Which identity, browser session, destination, and policy decision explain this action?” Correlating those events can turn a vague report about a failed upload into a specific account of where the action stopped.

That evidence needs boundaries of its own. A session identifier is not a license to retain every page a person sees. Decide which events are collected, how sensitive fields are redacted, who can inspect them, and when they expire. An auditor should explain uncertainty when an observation is missing. It should not invent intent from a packet count or treat every failed request as an attack.

Make ordinary work the acceptance test

The strongest RBI demonstration is deliberately unremarkable: a person completes their work, the application behaves as expected, and the organization can account for the execution and data boundaries. The technology is sophisticated so that the workflow does not have to be.

Begin with a narrow application set and a representative user group. Agree on completion criteria before testing. Compare outcomes against the existing environment, then investigate the differences. Antara’s NVR/Skia architecture and agentic auditing belong in that process together: one concerns how the work reaches the screen; the other helps explain how the work was governed.

• Map browser execution, rendering, identity, and data movement separately.
• Test complete tasks across realistic regions and network conditions.
• Review accessibility and controlled transfers alongside visual fidelity.
• Require evidence for performance claims and a recovery path for failures.