---
title: "Does AI Sit on Every Workday Integration Run? — Kiweely"
description: "Why design-time agents and runtime code are different jobs, and why an agent does not carry each Workday row."
url: https://kiweely.com/blog/design-time-agents-vs-runtime-integration-code
---

# Does AI Sit on Every Workday Integration Run?

Agents design, build, test, and fix the integration. The run itself is tested code. Workday rows pass through and are not kept. Roots, coming next, states that split in its FAQ.

-   By Kiweely
-   November 16
-   10 min read

Does AI sit on every Workday integration run?

No. On the [Kiweely Roots](https://kiweely.com/roots) page, each integration runs as tested code. Agents design, build, test, and fix that code. They do not sit in the path of the data. Roots is coming next, so this is a specification you can review, not a runtime you can call today. It is also the right question to ask of every other product that says “AI” next to “Workday integration,” because the two architectures have different failure modes.

A design-time agent helps a person produce an integration. A runtime model is invoked while the rows are moving. A third pattern, easy to confuse with both, is an assistant that asks about a run after the fact and never sees the file. Roots publishes all three roles and assigns the model to the first and the third, not the second.

## The three places a model can sit

| Place | What the model sees | What happens if the model is wrong | What Roots specifies |
| --- | --- | --- | --- |
| Design time | The description you wrote, the tenant’s processes and fields, the other system’s rules. | A bad integration is proposed. It is tested on Sandbox before Production. You switch Production on. | The agent builds with you and tests before anything goes live. |
| Run time | Each row, or the file, on the way from Workday to the other system. | A different transformation on Tuesday than on Monday, a model outage that stops payroll, and a prompt that can see pay. | “No. Each integration runs as tested code.” |
| After the run, on request | Times, counts, and outcomes. The pictured answer is a clock time, a worker count, and a rejection count. | A wrong sentence about a run that already happened. The file is not in the answer. | Claude, ChatGPT, and Gemini reach Roots over MCP to check a run, start one, or ask for a change. |

The FAQ on the page is one sentence and it is the sentence that matters: agents do not move the data on every run. If a demo shows a chatbot “doing” the integration by calling a model once per worker, that demo is a different product from the page.

## What design-time actually includes

“Design” is four steps on the Roots page, not a single prompt.

1.  You describe what goes where, and when, the way you would tell a colleague. The page’s example is a nightly 834 of benefits changes, with rejected rows reported.
2.  The agent reads both sides. The tenant’s business processes and fields, and the other system’s own rules.
3.  It builds and tests on Sandbox. Real data, real runs, before Production.
4.  You switch it on. Nothing reaches Production until you say so.

A later step, “it keeps it working,” is also an agent, and it is still not the nightly path. When the other side changes, the agent finds it, fixes it, and tests it. For payroll, benefits, and tax, the tested fix waits. For a directory or reporting feed, the tested fix goes back on and the owner is told. In both cases the thing that runs afterward is the fixed code, not the agent that wrote the fix.

That is why a fix can have a before-and-after. Code either maps a coverage tier from benefit elections or it does not. You can show the 14 rows the page’s illustration uses: rejected before, accepted on Sandbox after. A model that “usually” fills the tier does not give you that pair of outcomes. The [before-and-after article](https://kiweely.com/blog/before-and-after-diffs-and-one-step-rollback) is that record. One-step rollback is possible because there is a previous version of the code to return to.

## What runtime code is allowed to do

The run, as specified, does ordinary integration work:

-   It starts on a schedule or an event. The illustration is every night at 01:00.
-   It reads through that integration’s own API client, scoped to what it reads. The illustration is read-only to Benefits.
-   It sends an 834 of the changes since the last run, or whatever the integration was built to send.
-   It observes the other system’s response. In the illustration, 14 rows are rejected at 01:04.
-   It deletes the Workday data at the end of the run.
-   It keeps times, counts, and outcomes.

There is no step that says “ask a model how to transform this worker.” Adding one would break the FAQ, the retention rule, and the Sandbox proof. A transformation that was not in the tested code is a transformation Sandbox did not see.

The agent’s next action, if the rejection is new, is a change to that code, tested on the rows that failed. The run that just happened has already finished. The agent is repairing the program, not riding along inside it.

## Why people think the model is on the path

Three product patterns in the market use the word “agent” for a run, and they are not this FAQ.

**A generated flow that calls a model step.** MuleSoft Vibes, Boomi DesignGen, and Workato Recipe Copilot generate the flow at design time, which is the first row of the table. A separate choice, which those products also allow because they are general platforms, is a connector step that calls a model during the flow. That step is runtime AI even if a copilot wrote the flow. Roots’ FAQ forbids that for the data path. When you review a Mule flow, a Boomi process, or a Workato recipe, look for a model connector in the executing path. The copilot that wrote the XML is not the same finding as a model inside the XML.

**A healer that runs when the process errors.** Boomi’s Agent Heal recipe watches process failures and starts healing steps. Workato’s Autonomous Operations Framework retries transient errors from a recipe’s error handler. MuleSoft’s Diagnostics Agent analyzes a diagnostics file and recommends actions. Those are operational agents. They run because something failed. They are still not “a model transforms each worker on a successful night.” They are also not, on the pages fetched on 16 November 2026, a new mapping proven on a Workday Sandbox. The Roots repair loop is closer to a developer with a test than to a retry.

**An assistant with a tool.** Claude, ChatGPT, or Gemini calls a tool, gets an answer, and talks. If the tool is “run the integration,” the assistant started a run. The run is still the code. If the tool is “read last night’s outcome,” the assistant is on the third row of the table. Roots publishes both tools and keeps the payload out of them. The pictured payroll exchange is: the file went at 02:01, 27 workers, none rejected, and the Ireland change is tested and waiting because it touches payroll. The assistant did not receive the 27 workers.

Workday’s Developer Agent is a fourth pattern and it is not a runtime for your file either. Workday’s page says it builds apps, agents, APIs, DevOps, and orchestrations from plain language, inside developer tools, for customers on Extend Professional from 2026R2+. Building an orchestration with an agent is design time on Workday’s platform. It does not mean the orchestration calls a model for every worker unless the orchestration you built does that.

## What “tested code” has to mean or the sentence is empty

“Runs as tested code” is only a control if the test is defined. The Roots page defines it as Sandbox, with real data, for every build and every fix. For a repair, the page is more specific: payroll, benefits, and tax are proven on Sandbox with the rows that failed.

A test that only checks “the process completed” is the failure mode this FAQ is trying not to repeat. Workday can report Completed, or Completed with warnings, or Completed with errors, based on message severity inside the integration, and still have delivered a file the carrier will not accept. That is documented in Workday’s benefits testing chapter and in the Studio severity table, and it is written up in [why the vendor rejected the rows](https://kiweely.com/guides/workday-file-delivered-carrier-rejected-rows). A Roots run that is “tested” only against Workday’s event status would be repeating that gap. The page’s illustration tests the outcome that matters: the rows the carrier rejected, rerun on Sandbox, showing accepted after the map change.

Real data on Sandbox is also a constraint. Workday’s Sandbox is a copy of Production and, on Workday’s tenant description, refreshes weekly. A test against a sandbox that was just refreshed is a test against production-like data. A test against a hand-built sample of three workers is a different test, and the page says real data. When you evaluate early access, ask which Sandbox and which population the fix ran against. The right answer is the failed rows, on Sandbox, not a synthetic file on a laptop.

## What the assistant is allowed to start

“Start one” is on the page, and it is easy to over-read as “the model runs payroll.” Starting a run means invoking the tested code. It does not mean improvising a new mapping inside the conversation. Asking for a change is the design-time loop again: the Ireland entity is added, tested on Sandbox, and held because the integration is payroll. The assistant can request the change. The approval rule is the platform’s, not the chat’s.

That split is also why MCP is the right shape and a bad mental model if you stop at the acronym. MCP is how Claude, ChatGPT, and Gemini call Roots. The tools on the other side are check, start, and ask for a change. They are not a pipe that streams the 834 into the model so the model can “take a look.” The retention rule makes the second design impossible to implement honestly: the rows are gone when the run ends, so a later question cannot be answered from a stored file. It can be answered from the outcome record. If a future design stored the file so the model could reread it, the retention sentence would be false.

## Questions to ask any vendor, including Kiweely, when early access opens

Use these as yes or no questions. A paragraph that contains “agent” and “responsibly” is not an answer.

| Question | Answer that matches the Roots page |
| --- | --- |
| On a successful run, is a model called for any row? | No. |
| Who transforms the file? | The tested code. |
| Where is a fix tested? | Sandbox, with real data. For payroll, benefits, and tax, on the rows that failed. |
| Can that fix reach Production without a person? | Not if the integration is payroll, benefits, or tax. Yes if it is a directory or reporting feed and you left it on that rule. |
| What can an assistant read the next day? | Times, counts, outcomes. Not the records. |
| Where was the data at the end of the run? | Sent to the system you named, and deleted from Roots. |

If the answer to the first question becomes “only for rows the code does not understand,” the FAQ has changed. Unknown rows are exactly the rows a payroll file cannot hand to a model. They are the rows that should fail the run, get counted, and become a design-time fix.

## Frequently asked questions

### Does “the agent maintains it” contradict “the agent is not on the path”?

No. Maintenance is a change to the code between runs, tested before it applies. The path of a single run is the code as it stood when the run started. The page’s nightly clock and the page’s approval card are two different moments.

### Can we still call a model from a Workday integration we write ourselves?

Yes. Studio, Orchestrate, and every iPaaS will let you call an HTTP endpoint, including a model. That is your design, and it is the design this FAQ says Roots is not. If you do it, treat the model as a processor of confidential data, log it accordingly, and do not describe the integration as deterministic.

### What if we want the model to classify a free-text comment?

That is a runtime model call on worker data. Roots’ FAQ does not include it. If you need it, it is a separate, explicit step with its own review, not a silent part of the file builder. The page does not say that step exists.

[Kiweely Roots](https://kiweely.com/roots) is coming next. The page is worth reading for this FAQ alone, because most “AI integration” pages never separate the builder, the run, and the assistant. [Asking an assistant about a failed run](https://kiweely.com/blog/ask-an-assistant-about-a-failed-workday-integration) is the third row, written out. [The run book](https://kiweely.com/guides/workday-integration-run-book-for-assistants) is what that assistant is allowed to query.

## Read next

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

-   [November 16 ### Build Workday Integrations In-House or Buy an Agent-Maintained Platform](https://kiweely.com/blog/build-workday-integrations-in-house-or-buy)
-   [November 16 ### Sana, Flex Credits, and ASOR vs. Bridge’s Flat Company Price](https://kiweely.com/blog/sana-flex-credits-asor-vs-bridge-flat-pricing)
-   [November 16 ### Google Agentspace and Amazon Bedrock Agents Calling Workday: Prerequisites That Are Actually Published](https://kiweely.com/blog/agentspace-bedrock-workday-prerequisites-compared)

### More guides on Custom agents and Workday AI

[All 91 guides](https://kiweely.com/guides#custom-agents)

-   [Connecting a Workday custom agent to an outside agent platform with A2A](https://kiweely.com/guides/workday-custom-agents-a2a-external-agents)
-   [Why Workday custom agents use up Flex Credits so quickly](https://kiweely.com/guides/workday-custom-agent-usage-limits)
-   [A Workday custom agent’s lifecycle, from first deploy to Production](https://kiweely.com/guides/workday-custom-agent-lifecycle-promotion)
-   [Workday Illuminate, Agent System of Record, and Custom Agents: What Each Covers](https://kiweely.com/guides/workday-illuminate-asor-custom-agents-comparison)
-   [Can Workday Extend build custom agents? What you can and cannot build](https://kiweely.com/guides/workday-extend-custom-agents)
-   [How to connect your own agent to Workday’s Agent System of Record, step by step](https://kiweely.com/guides/connect-custom-agent-workday-system-of-record)
-   [Workday Agent System of Record (ASOR): An Admin’s Security and Setup Checklist](https://kiweely.com/guides/workday-agent-system-of-record-security)
-   [How to Budget Workday Flex Credits Before You Sign](https://kiweely.com/guides/workday-flex-credits-budget-planning)

## 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.
