Strada Launches Browser Automation: Agents Now Operate Web Portals and Systems That Don't Have APIs

Introduction

A large share of insurance work still happens inside systems that were never meant to connect to anything else. When one of those systems has no API, getting data in and out of it is a manual job. Someone logs into a portal, makes the change, moves to the next case, and repeats that throughout the day.

Browser automation handles that work instead. Strada's agents can operate web-based systems the way a person does, reading the screen and acting on what is there. Starting today, carriers, MGAs, wholesalers, and TPAs can automate back-office work in the portals and legacy systems they already use, with every run recorded and written back into the system of record.

From intake to execution

Insurance work rarely lives in one place. A servicing request might start with a customer call, draw on data from one system, and end with an update in another. Strada's voice, chat, and email agents already cover the front of that, handling the conversation and pulling out what matters. What stayed manual was the last step: getting that information into a system with no API.

That is the step browser automation takes over. The front-office agent gathers what is needed, and a browser agent carries it into the system to complete the task. Teams can automate work in the systems they already run without waiting on a new integration. A servicing request moves from the first customer interaction to the updated record without anyone shepherding it from one stage to the next.

How it works

Browser automation works like the rest of Strada. There is no code to write. You perform the task once, and the agent takes it from there.

We will follow one task the whole way through: updating the lienholder on a policy after a policyholder asks to change it. It is routine servicing work that normally means logging into a policy system by hand.

Step 1: Record the task once

Open a browser navigation node, start recording, and perform the task the way you always have. For the lienholder change, that means logging into the policy system, pulling up the policy, going to the lienholder section, and entering the new company. Strada captures each step as you go.

While you record, Strada's models work out the path through the system. From then on, the agent follows the same path every time, so its runs stay predictable. If the interface shifts in a small way, a button moves or a label is renamed, the agent adjusts and continues rather than breaking. It handles only minor changes on its own. Anything larger, and it stops and escalates instead of guessing its way through a screen it does not recognize.

Step 2: Strada builds the workflow

When you stop the recording, Strada turns the session into a workflow the agent can run. The path is fixed, but the data is not. In each case the agent pulls the values it needs from your systems, so a single recorded task can work through one policy after another, each with its own details.

Step 3: Launch a run

The agent then runs on its own. When a lienholder change comes in, it logs into the policy system, finds the policy, updates the lienholder, and saves the record, filling in that case's details as it goes. The task you recorded once runs as often as you need, with no one at the keyboard.

The agent checks the record before it acts, so it does not repeat a change that has already been made or move a setting the wrong way. Once it is finished, it reloads the screen and reads back the result rather than assuming the click landed. If what it finds does not match what it expected, the run stops.

Step 4: Review every run

Every run is recorded start to finish as video and saved to the run library. You can play back any run and see what the agent did: the screens it opened, the fields it touched, and the values it entered. A supervisor can spot-check a run the way they would review a new hire's work, and compliance has a record of what the agent did on each case.

Access is set up the way an insurer would want it. The agent logs in through a dedicated account you create, scoped to the permissions you grant, and you can revoke it at any time. Its credentials are injected at runtime and never reach the model, so there is nothing to leak. Strada keeps no separate copy of the data the agent handles. The only thing that persists is the session recording.

Built to run in production

Recording a task is the straightforward part. What matters is how the agent behaves once it runs unattended against real policies, and that is where most of the work went.

You set the rules through your own SOPs, and the agent stays within them. It can reach only the pages and elements you have approved, so it cannot stray into parts of the system it has no reason to open. Any action that can be undone is reversible, and destructive actions are gated separately, with a person's sign-off required before they proceed. For the tasks that carry the most risk, you can add an approval step so nothing final happens until someone confirms it.

None of this has to be proven in production first. Any workflow can run in a dry-run against a sandbox, so you can see exactly how the agent behaves before it touches a live system. And when a run does stop, you know immediately. The mismatch that halts it also sends alerts into Slack, email, and your ticketing system, so someone catches it in the moment rather than hours later.

Built into Strada's workflows

Browser automation runs inside the same workflows as your voice, chat, and email agents, rather than off to the side as a separate tool.

Consider the lienholder change from the beginning. A customer calls to update their lienholder, a voice agent works through the conversation and confirms the details, and once the call ends the browser agent opens the policy system and makes the change. The voice agent confirms the outcome to the caller only after the browser checks have passed, so the confirmation carries weight. Each call recording links to the browser session it triggered, giving you a single trail from the conversation to the update in the system.

The front-office agents are good at gathering and structuring information. Browser automation gives that information a way into the systems that used to require a person.

Conclusion

The systems without APIs have long been the hardest part of insurance operations to automate, which is why so much of this work has stayed manual. Browser automation brings them into Strada's operating layer, alongside the voice, chat, and email agents already running in production.

And one task is only the start. Once an agent can operate a system, the same setup extends to address changes, payment dates, document retrieval, and policy updates across that system. The return is clear: coverage after hours, shorter handle times, and no team time spent on routine changes.

Browser automation is available today for carriers, MGAs, wholesalers, and TPAs.

To see how it works, book time with our team: https://www.getstrada.com/book-a-demo.