---
title: "Why Shared Workday ISUs Are Risky for Employee AI — Kiweely"
description: "Connecting an employee AI assistant through one Workday Integration System User bypasses tenant security. User-delegated OAuth enforces real worker domains."
url: https://kiweely.com/blog/why-integration-system-users-are-dangerous-for-workday-ai
---

# Why Shared Integration System Users (ISUs) Are a Security Risk for Employee AI Chatbots

Connecting an employee AI chatbot to Workday through a shared Integration System User (ISU) forces your application code and prompts to recreate Workday’s security model from scratch. User-delegated OAuth with PKCE runs every query under the signed-in employee’s own security groups and domains.

-   By Kiweely
-   November 15
-   7 min read

Connecting an employee-facing AI assistant to Workday with a single Integration System User (`ISU`) strips away Workday’s row- and field-level access controls at the exact moment data leaves the tenant. Use a user-delegated Workday API client (`Register API Client` with Authorization Code Grant and PKCE) instead so Workday evaluates every REST, WQL, SOAP, and RaaS request against the signed-in employee’s own security groups and domains.

Integration System Users exist for unattended batch pipelines—payroll interfaces, nightly benefits feeds, and Enterprise Interface Builder (`EIB`) loads—where no human is sitting at a keyboard. Reusing that pattern for interactive chat turns your AI middleware into a shadow authorization engine that has to guess who is allowed to see what.

## How Shared ISU Bots Break the Workday Security Model

In Workday’s configurable security framework, an `Integration System Security Group (Unconstrained)` grants `Get` or `Put` access across every target worker instance in the tenant for each permitted domain. Even an `Integration System Security Group (Constrained)` only narrows access to a static list of organizations configured on the group itself—never to the dynamic supervisory, matrix, location, or self-service context of the employee typing in Slack, Teams, or Claude.

When an internal engineering team or legacy chatbot vendor wires an AI assistant through `Register API Client for Integrations`, one service credential must hold the **superset** of permissions needed by every persona who might talk to the bot:

-   `Employee As Self` permissions so individual contributors can check `Self-Service: Time Off Balances` or `Self-Service: Payroll (My Payslips)`.
-   `Manager` constrained permissions so team leads can read `Worker Data: Time Off (Time Off Balances Manager View)` and direct-report job profiles.
-   `HR Partner` permissions so HR business partners can query `Worker Data: Current Staffing Information` or `Worker Data: Compensation by Organization`.

Because Workday sees only `ISU_AI_Assistant` on the wire, Workday returns every row and column permitted to that `ISU`. The burden of preventing a regular employee in `Warehouse 4` from reading a VP’s compensation or a peer’s leave history shifts entirely onto custom application code or LLM instructions.

## Why Rebuilding Workday Security in Middleware Always Drifts

Engineering teams usually try to patch an `ISU`\-backed chatbot by resolving the caller’s email address to a Workday `employeeID` and appending a `WHERE` filter before calling Workday:

Fails

```
SELECT worker, businessTitle, totalBasePay_Amount, timeOffPlans
FROM allWorkers
WHERE workersManager = 'fc8492018d1a100018a9c00291b40012'
```

That query looks safe in a prototype and fails against real Workday tenant rules within weeks:

1.  **Subordinate organization inheritance (`COO` vs. `COUS` vs. `COAS`):** Workday’s `Role-Based Security Group (Constrained)` settings distinguish between *Current Organization Only*, *Current Organization and Unassigned Subordinates*, and *Current Organization and All Subordinates*. A flat `workersManager` filter either hides unassigned child supervisory organizations a director legitimately leads or exposes indirect reports a frontline supervisor was restricted from seeing.
2.  **Intersection and exclusion rules:** Many enterprises use `Intersection Security Groups` to restrict an `HR Partner` to a specific `Supervisory Organization` *and* `Location Hierarchy`, or to exclude executive and HR populations via custom organization exclusions. Middleware SQL filters do not evaluate Workday intersection logic unless someone duplicates and syncs the entire security graph outside Workday.
3.  **Multiple jobs and contingent workers:** Workday role definitions carry explicit rules for workers with secondary positions (*Role has access to the positions they support* vs. *Role for primary job has access to all positions*). A custom email-to-worker lookup regularly merges or exposes data from the wrong position.
4.  **Prompt-layer filtering is trivially bypassed:** Worse still, some homegrown agents pass a multi-row RaaS JSON payload into the LLM context window with a system instruction saying *“Only answer about the current user.”* Any indirect prompt injection—or a simple phrasing shift asking for department averages, rankings, or differences—causes the model to derive and reveal unauthorized figures already sitting in its context.
5.  **Broken Workday audit trails:** In Workday’s `View User Activity` report, every transaction run over a shared credential logs `ISU_AI_Assistant` under `System Account`. If a compromised chat account exfiltrates staffing data or submits a time-off request, Workday security administrators have zero native tenant record tying the API call to a specific worker session.

## Comparing Shared ISU Credentials vs. User-Delegated OAuth

| Security Dimension | Shared ISU (`Register API Client for Integrations`) | User-Delegated OAuth (`Register API Client` + PKCE) |
| --- | --- | --- |
|  **Grant type** | Non-expiring or rotating Refresh Token bound to one `ISU` | OAuth 2.0 Authorization Code Grant with PKCE per human user |
|  **Sign-in & MFA** | Bypassed at query time; bot authenticates with stored secret | Employee signs in directly on Workday with corporate SSO and MFA |
|  **Row & field filtering** | Rebuilt by hand in bot middleware or prompt instructions | Enforced natively by Workday domain and security group policies |
|  **Privilege escalation risk** | Bug or injection in app code exposes every record the `ISU` can read | Structurally impossible to read records Workday denies that worker |
|  **Workday `View User Activity`** | Logs every worker’s reads and writes under one `ISU` account | Logs each employee’s own `System Account`, IP, and task access |
|  **Revocation granularity** | Rotating the `ISU` secret takes the bot offline for the entire company | Terminating or revoking one worker in Workday cuts off only their token |

## How User-Delegated OAuth Eliminates Privilege Escalation

When you register an OAuth client via the standard **Register API Client** task (rather than [setting up an ISU integration client](https://kiweely.com/guides/workday-integration-system-user-api-client)), you select **Authorization Code Grant**, check **Support Proof Key for Code Exchange (PKCE)**, and choose the **Functional Areas** (scopes) the client may request—such as `Staffing`, `Time Off and Leave`, or `Organizations and Roles`.

Functional Areas on an API client act as a **ceiling, never a grant**. Giving the API client scope over `Core Compensation` does not give a regular employee compensation access. At runtime, Workday computes the mathematical intersection of:

1.  The API client’s permitted `Functional Areas`, and
2.  The authenticated worker’s own active security groups (`Employee As Self`, `Manager`, `Intersection`, or `User-Based`).

When an individual contributor asks an AI assistant to run a WQL query against `allWorkers` requesting `totalBasePay_Amount` for a coworker, Workday’s own query engine evaluates `Worker Data: Compensation` against that employee’s token and returns empty/omitted fields or a permission error—before a single byte leaves Workday’s data center:

Works

```
SELECT worker, businessTitle, supervisoryOrganization
FROM allWorkers
WHERE supervisoryOrganization = 'eb39104c92a1100014f02918c721000a'
```

Run under an employee’s user-delegated Bearer token, Workday returns public directory fields secured by `Worker Data: Public Worker Reports`. If the same employee asks for `nationalIdentifiers` or a peer’s `totalBasePay_Amount`, Workday blocks access inside the tenant kernel. No prompt jailbreak in Claude, ChatGPT, or Gemini can coax a token into returning rows Workday refuses to serve.

## Auditing Existing AI Pilots in Your Tenant

If your organization has tested internal bots, portal builders, or automation scripts, run this 10-minute check in Workday to verify none of them rely on an over-privileged `ISU`:

1.  Open **View API Clients** in Workday and inspect the **Registrations for Integrations** tab versus the **API Clients** tab.
2.  For any client tied to an interactive chat bot, intranet portal, or developer app builder, check the assigned **Integration System User** and run **View Security Groups for User** on that `ISU`.
3.  Run **Action Summary for Security Group** on the `ISU`‘s security group. If an interactive employee tool holds unconstrained `Get` permissions on `Worker Data: Compensation`, `Person Data: ID Information`, or `Worker Data: Payroll (Payslips)`, pause the client secret and migrate the integration to [Authorization Code Grant with PKCE](https://kiweely.com/guides/workday-api-client-pkce-sso-without-workday-password).
4.  Review [constrained vs. unconstrained security groups](https://kiweely.com/guides/workday-constrained-vs-unconstrained-security-groups) for your human roles [before opening AI agent access](https://kiweely.com/guides/workday-security-audit-before-enabling-ai-agents) so managers and HR partners hold only the org visibility they need.

## Where Kiweely Bridge and Kiweely Leaf Fit

Both [Kiweely Bridge](https://kiweely.com/bridge) and [Kiweely Leaf](https://kiweely.com/leaf) (both coming next) enforce this exact architecture by design: neither product ever connects to your tenant with an Integration System User.

-   **[Kiweely Bridge](https://kiweely.com/bridge)** (coming next) connects Workday to Claude, ChatGPT, and Gemini across desktop, web, and mobile using `Register API Client` with Authorization Code Grant and PKCE. Every REST, WQL, SOAP, and RaaS call executes under the signed-in employee’s own Workday token, paired with [zero stored payloads and sealed client-held grants](https://kiweely.com/bridge/security). Pricing is flat per company by licensed Workday employee count ($499/mo up to 1,000 employees, $1,499/mo for 1,001–5,000, $3,999/mo for 5,001–20,000, and Enterprise by quote above 20,000 or for dedicated/self-hosted deployments), and free for one person on their own Workday developer tenant.
-   **[Kiweely Leaf](https://kiweely.com/leaf)** (coming next) lets HRIS admins build custom external employee portals, mobile frontline screens, and chat approvals in plain English without a Workday Extend license—running every screen as a stateless pass-through under each employee’s own Workday OAuth session.

## Frequently asked questions

### What is the architectural difference between Register API Client and Register API Client for Integrations in Workday?

Register API Client for Integrations binds a Refresh Token directly to one unattended Integration System User (ISU). Register API Client creates an interactive OAuth 2.0 client (such as Authorization Code Grant with PKCE) where each human worker signs in through Workday and receives a short-lived token scoped to their own security groups.

### Why can't an AI system prompt safely filter data fetched by an unconstrained ISU?

System prompts sit inside the same context window as untrusted data and user questions. Even if you filter rows in middleware before the LLM runs, your middleware does not know Workday's dynamic role inheritance, intersection exclusions, or subordinate org rules—any mismatch leaks records.

### What happens in Workday audit trails when an employee chatbot uses a shared ISU?

Workday's View User Activity report and business process audit trails attribute every read and write to the single ISU account (for example, ISU\_HR\_Chatbot) rather than the human employee who asked the question, breaking non-repudiation for SOX and privacy reviews.

### Does user-delegated OAuth require a Workday AI SKU or Agent System of Record?

No. User-delegated OAuth 2.0 via Register API Client with Authorization Code Grant and PKCE is a standard core tenant feature available without a Workday AI agreement, Flex Credits, or Workday Extend license.

## Read next

[All posts](https://kiweely.com/blog)

-   [November 15 ### Mapping Microsoft Teams, Slack, DingTalk, and Lark Identities to Workday Worker OAuth](https://kiweely.com/blog/mapping-teams-slack-lark-sso-identities-to-workday-workers)
-   [November 15 ### How Workday’s Twice-Yearly Releases Break In-House MCP Servers and REST Integrations](https://kiweely.com/blog/how-workday-twice-yearly-releases-break-custom-mcp-servers)
-   [November 15 ### Turning Your Existing Workday RaaS Reports into Governed AI Tools](https://kiweely.com/blog/exposing-existing-workday-raas-reports-to-claude-and-chatgpt)

### More guides on Integrations and APIs

[All 89 guides](https://kiweely.com/guides#integrations)

-   [Designing for Workday Tenant API Concurrency and Rate Limits During Peak Employee Traffic](https://kiweely.com/guides/workday-api-rate-limits-concurrency-workforce-self-service)
-   [Calling Workday RaaS Reports with User-Delegated OAuth Instead of an ISU](https://kiweely.com/guides/workday-raas-user-delegated-oauth-vs-isu-basic-auth)
-   [Updating Preferred Name, Pronouns, and Contact Information via the Workday Person API](https://kiweely.com/guides/workday-person-api-legal-preferred-name-contact-updates)
-   [Restricting Workday OAuth Token Use by IP with Maintain IP Ranges](https://kiweely.com/guides/workday-maintain-ip-ranges-manage-authentication-policies-api)
-   [Why Browser Single-Page Apps Hit CORS and Token Limits Against Workday APIs—and How to Fix It](https://kiweely.com/guides/workday-cors-browser-api-calls-why-backend-pass-through-needed)
-   [Parsing Workday Business Process Custom Validation Errors Returned by REST and SOAP APIs](https://kiweely.com/guides/workday-business-process-validation-errors-rest-soap-responses)
-   [How Workday Audits Business Processes Initiated via REST or SOAP Web Services](https://kiweely.com/guides/workday-business-process-audit-trail-initiated-via-web-service)
-   [Approving, Denying, and Sending Back Workday Business Process Steps via REST and SOAP APIs](https://kiweely.com/guides/workday-business-process-approve-deny-rest-soap-api)

## Your Workday work, done by AI.

Kiweely Vine is the AI agent that builds, deploys and tests Extend apps as real people, makes changes in any Workday task screen, answers from your real tenant and builds reports.

[Start for free](https://kiweely.com/download) [See how it works](https://kiweely.com/vine/how-it-works)

## Get the next one in your inbox.

One email a month for Workday teams: what’s changing in Workday and what to retest, one tip tried in a real tenant, and what’s new at Kiweely.
