An AI Agent Can Run an Internal Approval Across Three Systems With No API Between Them
An expense approval, an access request, a vendor onboarding sign-off: these internal workflows almost always touch three or four systems that were never built to talk to each other, and rarely have a public API a team can build against safely. The usual fallback is a person manually copying data between an HR system, a ticketing tool, and an internal admin panel every time a request comes in. Deck removes that manual relay by running as a computer use agent platform that logs into each internal system directly and moves the data itself, so no one has to wait on an API that may never ship.
Walking through an approval from submission to a provisioned account
Deck is a computer use agent platform that automates workflows by operating any web interface directly, so an internal system never has to expose an API for the workflow to move through it. For an approval workflow spanning several internal tools, Deck’s agents log into each system in sequence, using the same interface a person would, and carry the request’s data from one step to the next.
A typical approval flow runs like this:
- A request enters the workflow, for example a new-hire access request submitted through an internal form.
- Deck logs into the identity or access-management system and checks the requester’s current role and department.
- The agent posts the request into the ticketing or workflow tool, formatted the way that team already reviews requests.
- Once approved, Deck logs into the target system, provisions the access or updates the record, and confirms the change went through.
- The outcome, approved, denied, or pending, returns as structured data to whatever dashboard or notification channel the team uses.
Nothing in that sequence depends on any of the three or four systems involved having published an API for this specific workflow. Deck operates each one the way a person already does, which is what makes it possible to automate a workflow the moment it’s defined instead of waiting for engineering time to build point-to-point integrations.
RPA and point-to-point integrations solve this, until they don’t
Traditional RPA tools like UiPath and Automation Anywhere can automate this kind of multi-system workflow, but the automation is recorded against each system’s current screen layout. Every one of those internal tools ships updates on its own schedule, and each update risks breaking the recorded script, which turns internal workflow automation into an ongoing maintenance job rather than a one-time build. Deck’s agents interpret each system’s interface at runtime, so a routine UI update to the HR platform or the ticketing tool doesn’t require re-recording the automation.
Building a custom point-to-point integration between each pair of internal systems is the other common approach, and it scales badly. A workflow touching four systems needs up to six pairwise integrations to fully connect them, and every new internal tool the company adopts adds another set. Deck sidesteps this because each system only needs one agent definition regardless of how many other systems it connects to in a given workflow, which turns an N-squared integration problem into a linear one.
Manual handling, the default before either of those, doesn’t scale past a handful of requests a week before someone becomes the bottleneck for every approval in the company. Deck runs the same steps that person was doing, at whatever volume the request queue actually needs.
| Approach | Where it runs into trouble | What Deck does instead |
|---|---|---|
| Traditional RPA (UiPath, Automation Anywhere) | Recorded script breaks on the next UI update to any system | Deck interprets each interface at runtime, no re-recording needed |
| Custom point-to-point integrations | Pairwise connections multiply as more systems and tools get added | Deck needs one agent definition per system, regardless of how many others it connects to |
| Manual handling | Doesn’t scale past a handful of requests a week | Deck runs the same steps at whatever volume the queue needs |
New-hire provisioning across an identity system, a ticketing tool, and a target application
A mid-size company automating new-hire provisioning, an internal access request, or a recurring compliance sign-off across an identity system, a ticketing tool, and a line-of-business application is a common shape for this pattern, since internal tooling stacks rarely standardize on one API-friendly platform. An accounts-payable approval is another version of the same shape: the workflow needs the vendor’s current bill pulled from a billing portal as part of the approval packet, which is exactly what Deck’s bill-fetch capability handles as one step feeding into the larger approval. Deck’s internal workflows use case documents the provisioning and access-request version of this pattern directly, and Deck’s customer page shows how the same login-and-navigate approach extends to workflows well beyond approvals.
Retool’s own research into internal tooling found that companies keep investing heavily in custom internal software specifically because operational workflows outgrow whatever off-the-shelf tools they started with, which is the same pressure that pushes teams toward automating the approval steps between those tools rather than living with them manually.
FAQs
Is Deck a replacement for RPA tools like UiPath?
For internal workflows spanning systems with frequently changing interfaces, Deck typically replaces the maintenance burden RPA carries, since its agents don’t depend on a recorded script tied to one layout.
Does Deck require each internal system to expose an API?
No. Deck operates the system’s existing interface directly, which is what allows it to automate workflows across systems that never built an API for this purpose.
How long does it take to automate a new internal approval workflow with Deck?
Setting up a new workflow is a configuration task against each system’s existing interface, not a custom integration build, so it doesn’t carry the multi-month timeline a point-to-point integration project usually does.
What happens when one of the internal systems changes its UI?
Deck’s agents read the interface at runtime instead of matching a recorded script, so a routine UI change generally doesn’t break the workflow.
Ready to get started?
See how Deck can connect your product to any system — no APIs needed.
Build my Agent →