If you’ve been trying to keep up with Workday’s agent announcements over the past twelve months, I have some bad news and some good news.

Bad news: you’re going to need to learn a bunch of new product names. The “Illuminate” branding that Workday rolled out in 2024 is now mostly gone, replaced by “Sana from Workday” following the Sana acquisition that closed in November 2025. A bunch of agents that you might have read about under the Illuminate banner (”Illuminate Recruiting Agent,” for example) are now just “Recruiting Agent” inside the Sana umbrella.

Good news: the architecture underneath hasn’t really changed. The agents are still grounded in Workday data, still governed by the Agent System of Record, still inherit tenant security. The branding got a haircut. The plumbing is the same plumbing.

I’ve been saying this for a while now, and I’ll keep saying it: vendor AI branding has a shelf life of about nine months. The architecture is permanent. If you’re building your HR tech strategy around product names, you’re going to rebuild it three times a year. If you’re building it around data, governance, and workflow, you’re going to be fine.

With that framing, here’s the practitioner’s field guide to the current (April 2026) Workday agent lineup.

Before You Touch Anything: The UMSA

One thing Keith Bitikofer covered in his Philly RUG session that deserves to be front-loaded: if you want to use Workday Agents, you need to be on the UMSA. This replaces the old Innovation Services Agreement. It’s the gate. If your org is still on the MSA without the UMSA addendum, you’re not turning on agents yet. Check with your CSM before you plan anything else.

Start With the Platform, Not the Agents

Before we get into the roster, this is the part most agent write-ups skip. And it’s the part that actually matters.

Workday Agent System of Record (ASOR) is the control plane. Every Workday-built agent, and increasingly every third-party agent that wants to play nicely, registers here. ASOR is where you manage what the agent can see, what it can do, who can invoke it, and what data it’s allowed to touch. It’s the governance layer for your entire agent fleet.

ASOR is also the attestation layer. It’s the ledger that records where each agent came from, what version of the logic is running, which skills are enabled, and which humans are accountable for it. “We don’t know what agents are running in our tenant” is how you end up in a regulatory filing. ASOR exists so that sentence never gets spoken out loud in your company.

You access ASOR through the Agent Management Hub, which includes an Agent Registry, a view for Unregistered Workday Agents (yes, that’s a real section, and yes, you should check it), and links out to the Agent Marketplace. Third-party agents from Microsoft, Azure, AWS, Google Cloud, and partner ecosystems can register into ASOR using shared protocols including MCP and Agent-to-Agent (A2A). ASOR is becoming the universal control plane for agents, whether they were built in Workday or not. That’s a much bigger story than any individual agent on the roster.

If your HR tech team is going to care about exactly one Workday AI thing this year, care about this: an unmanaged agent in your tenant is a risk. A managed agent with a clear skill inventory, audit trail, identity, and permission model is a tool. ASOR is what moves you from the first thing to the second. Justin figured this out the hard way when I gave him unsupervised access to YouTube. Same concept, much higher stakes.

Workday Build is the platform for creating your own custom AI solutions inside Workday. This is Workday’s answer to “we want to build our own agents too,” which, if you read my last post, you know I have a few feelings about. Build is more structured and involves real developer workflows. The same rule applies: if no human on your team understands what the custom agent actually does, you don’t have an asset. You have a liability with a friendly UI.

Sana Agent Builder Pro (formerly called Flowise Agent Builder, if you’ve seen that name floating around) is the no-code/low-code tool for creating custom agents. It’s Build’s friendlier cousin, aimed at configurators rather than developers.

Flex Credits is the pricing model for all of this. We’ll come back to this one in detail, because it deserves more than a sentence. It deserves its own section.

The Front Door

These two are the agents your employees will actually touch. Everything else happens behind the scenes.

Sana for Workday

What it is: the new AI-native interface for Workday itself. Ask it questions, run transactions, get reports, navigate workflows, all in natural language. Replaces a lot of the classic Workday UI for users who prefer to chat rather than click.

My take: this is the most important shift in the Workday user experience since the 2016 redesign. For power users, it’s a convenience. For casual users (managers, frontline employees, anyone who uses Workday three times a year and forgets where everything is), it’s the difference between getting something done and filing a ticket. If you’re on a Workday tenant today, your employees are going to expect this within 18 months. Plan the change management now.

Watch out for: the security model still applies. Sana can only surface what the user’s permissions allow. This is a feature, not a bug, but it means “why can’t Sana show me my team’s salaries?” is going to be a recurring support ticket (depending on your security setup. I've seen some doozies, including several where manager didn't have access to pay info!). Get your comms ready.

One more thing Keith flagged in his RUG session that stopped me cold: Sana user access is managed separately from Workday. Your existing Workday security model does not automatically carry over. If you’re expecting seamless permission inheritance, you’re going to be surprised. Budget time for a separate access management workstream before you roll this out.

Sana Self-Service Agent

What it is: the workhorse. Ships with 300+ skills out of the box, covering the standard HR and finance self-service requests: address changes, PTO balances, benefit elections, expense inquiries, all the greatest hits.

My take: this is the agent that will replace the most tickets, and therefore the agent with the clearest ROI story. It’s also the one your Tier 1 HR support team is going to have feelings about. Have that conversation early.

Watch out for: “300+ skills” sounds impressive. In practice, the skills vary in maturity. Test the ones specific to your workflows before assuming they all work the way the demo works. And per Keith: you can’t use Proxy to test Agents or Sana Core. If Proxy is part of your standard testing workflow (and for most admins it is), you’re going to need to rethink how you validate before you go live. Plan for that extra testing time now.

The Talent Stack

These are the agents aimed at the recruiting, mobility, and frontline parts of the employee lifecycle.

Recruiting Agent

What it is: AI assistance across the recruiting workflow. Sourcing, screening, candidate communication, interview scheduling, the usual suspects.

My take: this is where Workday’s Hiredscore acquisition comes home to roost. The agent is meaningfully better than Workday’s pre-Hiredscore recruiting AI was (umm, crappy keyword matching ain't AI, Mr. Mobley). If your TA team still thinks of Workday Recruiting as a glorified ATS, this is the year that assumption may actually break.

Watch out for: the boundary between this agent and Paradox (which Workday also owns via partnership) is not always obvious. Ask your CSM which use cases go where. Also: the pricing on this agent has teeth. We’ll get to it.

Talent Mobility Agent

What it is: personalized internal matching. Surfaces roles, gigs, and projects for employees based on skills, goals, and history. Helps managers and recruiters find internal candidates.

My take: the use case is great. The execution depends almost entirely on your skills data. If your tenant’s skills model is thin or inconsistent (and let’s be honest, whose isn’t), this agent is going to surface noise. Invest in the skills data first, turn on the agent second. Also: the pricing on this one has teeth too.

Candidate Sourcing Agent

What it is: proactive identification of contingent talent for open needs. Aimed at procurement-adjacent hiring.

My take: niche but valuable for companies with large contingent workforces. If your contingent spend is significant, worth a look. If not, skip it for now.

Frontline Agent

What it is: self-service and workflow automation purpose-built for frontline workers. Shift questions, schedule swaps, benefits queries, the stuff hourly employees actually need.

My take: the most undervalued agent on the list. Frontline workers have been the stepchild of HR tech for two decades. An agent that actually works on a phone, in a break room, in 90 seconds, is a real unlock. If you’re in retail, hospitality, healthcare, logistics, or manufacturing, this one is worth a hard look.

The Operations Layer

These are the agents that live in the back office. Your employees will probably never see them. Your ops teams will.

Payroll Agent

What it is: automates payroll processing tasks, improves data quality, reduces manual reconciliation.

My take: payroll is the most conservative corner of HR tech for very good reasons (if you get payroll wrong, everyone notices). This agent is not going to replace your payroll analyst. It might eliminate 20% of the boring work that currently fills their day. That’s the right bar.

Watch out for: don’t let anyone pitch this as a headcount play. It isn’t. It’s a quality and cycle-time play.

Business Process Optimize Agent

What it is: analyzes your tenant’s business processes and recommends improvements. Think of it as a Workday-native process mining tool with opinions.

My take: potentially the sleeper hit. Every Workday tenant I’ve ever seen has business processes that have been amended, patched, and condition-ruled into Rube Goldberg machines. An agent that can spot the redundant approval step, the orphaned notification, the condition rule nobody remembers writing, is doing real work.

Watch out for: recommendations are only as good as your willingness to act on them. If your governance process requires six signatures to change a BP, the agent is going to produce insights that die in committee.

Deployment Agent

What it is: an AI assistant specifically for Workday administrators and implementers. Ask it anything about Workday configuration, troubleshooting, calculated field logic, business objects, you name it. Sourced from the Admin Guide, User Guide, Community Accepted Answers, release notes, and configuration documentation.

My take: this one should have been higher in the article. For the people reading this newsletter, it’s the most immediately useful agent on the list. 120,000 questions answered in February 2026 alone, with 49% request growth from January to February. Those aren’t vanity metrics. That’s a signal that admins are actually using it.

The Workday-cited stat is a 20-25% time reduction in research and troubleshooting. Based on how much time I’ve personally watched admins spend digging through Community threads for an answer that should have been findable in five minutes, I believe it.

One more thing, and this matters: as of the 2026R1 release, the Deployment Agent is available in your Customer Central tenant, does not require the UMSA, and does not consume Flex Credits. It’s free to run today. Which is a good segue.

The Finance-Adjacent

I’m not going to dwell here because this newsletter is for HR tech practitioners, but for completeness: Contract Intelligence Agent, Contract Negotiation Agent, Financial Audit Agent, Planning Agent, Revenue Contract Agent, and Supplier Contract Agent all exist, are either GA or in early adopter status, and live on the Finance side of the house. If your role straddles HR and Finance, worth a conversation with your Finance counterparts about what they’re piloting. Also, hold onto the Contract Negotiation Agent name. We’re coming back to it.

The Cross-App Extension

Sana Enterprise

What it is: the piece that extends Sana agents beyond Workday itself. Connects to Gmail, Microsoft Outlook, Salesforce, SharePoint, and other enterprise systems. Lets the agents find, orchestrate, and complete work across applications, not just inside Workday.

My take: this is the most ambitious piece of the March 2026 announcement, and the one most likely to get messy in the wild. The pitch is seductive: one agent, all your systems, completes the work. The reality is that every enterprise integration has its own quirks, its own permission model, and its own “hmm, that used to work” failure mode.

If you’re going to pilot Sana Enterprise, pilot narrowly. Pick one or two systems, not five. Prove the pattern before scaling it.

Watch out for: data residency. When a user in Frankfurt asks Sana Enterprise to “summarize the last five emails about this candidate,” where exactly does that summarization happen, and across which legal jurisdictions does the data travel? Global HR tech leaders have spent a decade carefully building tenant architectures that respect EU, APAC, and Latin American data boundaries. Cross-app agents have the potential to undo that work in a single well-meaning prompt. Get your Legal and Privacy teams in the room before you pilot this one, not after.

Also worth flagging: this is where the conversation with Microsoft (Copilot), ServiceNow (NowAssist), and Salesforce (Agentforce) gets interesting. All of them want to be the “front door” for work. Your IT architecture review board is about to have a lot of meetings.

Flex Credits:The Math Nobody's Modeling

Time to do the math.

Keith Bitikofer put a slide up at the Philly RUG session with a figure that got the room’s attention: “$50-75 per run of the Agent??” Double question marks and everything. When I first saw it, I figured the number was a rumor, or an early estimate that hadn’t been fully vetted.

It’s not a rumor. It’s on the rate card.

The Workday Flex Credits Rate Card v262, last updated February 12, 2026, lists per-skill consumption rates for every agent. The public marketing slide that shows Self-Service at 1-5 credits and BP Optimize at 1 credit is accurate. It’s also a curated view. The full rate card includes rows that are meaningfully higher.

Here’s what got highlighted:

• Contract Negotiation Agent, full document review and redlining: 500 credits per document. At roughly $0.10 per credit, that’s $50 per contract.

• Recruiting Agent, Talent Rediscovery (Fetch): 750 credits per unique requisition. That’s $75 per req.

• Talent Mobility Agent, Internal Talent Visibility and Matching: 750 credits per unique requisition. Also $75 per req.

Compare that to Candidate Grading (Spotlight), which runs 6 credits per resume screen. Same Recruiting Agent, wildly different meters depending on which skill you invoke. The agent isn’t one thing. It’s a bundle of skills with very different price tags.

Run the math for a recruiting team at a mid-size company.

$45,000 a year, for one skill, on one agent. Fine.

Now layer in the platform meters.

API Requests: 0.006 credits each, or 60 credits per 10,000 calls. Integration Events: 0.25 credits each, or 25 credits per 100 events. Document Storage: 120 credits per GB stored annually, with a 10-credits-per-GB-per-month overage rate if you exceed.

Here’s the thing Keith made explicit that I hadn’t appreciated until I saw the deck: platform entitlements are “fair use” levels, not hard limits. When you exceed them, the overage draws down your Flex Credit pool. So your heavy integration month doesn’t just generate a separate line item. It eats into your agent budget.

But not every integration counts the same way.

Keith’s slide broke it down.

Doesn’t count toward entitlement (included with subscription):

• Workday Core Connectors

• Workday Everywhere (Slack/Teams)

• Integrations to and from Workday acquisitions (Hiredscore, Paradox)

• EIBs (for Integration Events only, not for API Requests)

• Workday Applications built by Partners

Counts (and overage consumes Flex Credits):

• Custom Studio integrations

• Orchestrations

• Document Delivery unless attached to an EIB

• Customer-built Extend apps

• External applications and AI Agents calling your tenant

• Certified Partner integrations (including EIBs) for API Requests

Translation: if you’re a heavy Studio shop, you’re exposed. If you have a sprawl of custom Orchestrations, you’re exposed. If you built out Extend apps, you’re exposed. Go look at what your integration footprint actually looks like before you assume anything.

A few safety valves worth knowing. Sandbox testing is free. Non-production consumption is shown in the console for informational purposes only, never billed. Traditional Workday “AI” and machine learning features (the non-agentic stuff that’s been in your tenant for years) don’t consume Flex Credits at all. The meter runs on agents and platform consumption, not on the AI features you already have.

If you do go negative on your entitlement, you don’t get cut off. Annual true-up at reconciliation. No service interruption.

“No service interruption” is not the same as “this will be cheap.”

Ask me how I know. When Justin was in second grade, he figured out how to switch the payment method on his iPad from password to his fingerprint, and proceeded to rack up a thousand dollars in Roblox in-game purchases. I found out about it a day later. Apple didn’t cut him off. The system worked exactly as designed. The damage was done before anyone noticed.

Flex Credits work the same way. If nobody is watching the meter, the meter doesn’t care.

Keith told us the Platform Consumption Console (PCC) is where you watch all of this. Credit balance, active entitlement, rate card view, drill-down on Sana and Agent usage. If you’re evaluating any of this, know where the PCC is before you turn anything on. Watch it like a hawk.

My honest read: the public narrative around Flex Credits has been “pay for what you use, usage-based, very reasonable.” The full rate card tells a more complicated story. For admins and HR self-service, the economics are fine. For talent and contract agents, per-run costs are substantial, especially at scale. For shops with heavy Studio integration footprints, the platform side is going to bite before the agent side does.

Get your CSM to run an estimate against your actual tenant volume before you commit to anything. Make sure your Finance counterpart sees the full rate card, not the marketing slide. And if you’re a recruiting-heavy shop considering Fetch or Internal Talent Mobility at scale, model the annual cost before you green-light the pilot.

What I’d Actually Pilot First

Not a ranking. A sequence.

Get on the UMSA if you aren’t already. Nothing else on this list works without it.

Get ASOR configured and governed. Before you turn on any agent, make sure you understand how to manage them. This is not glamorous work. It is the work.

Start using the Deployment Agent today. It’s in Customer Central, it’s free, it doesn’t require the UMSA, and it will save your team real time. There’s no reason to wait.

Pilot the Self-Service Agent. Highest ROI, clearest user value, fastest to demonstrate impact, and the credit consumption at 1-5 credits per action is manageable.

Pilot the Frontline Agent, if you have a frontline workforce. Disproportionate value for underserved users.

Invest in your skills data before you turn on Talent Mobility. The agent is only as good as the foundation underneath it, and at 750 credits per requisition, you want signal, not noise.

Watch Business Process Optimize carefully. This one could be a sleeper. Worth the evaluation even if you don’t act on it immediately. At 1 credit per BP event, the economics are friendly.

Everything else: evaluate based on your specific business. Don’t let a vendor pitch drive your roadmap.

What’s Notably Missing

A rundown is only useful if it also tells you what isn’t on the map. A few agents I’d expect to see that haven’t shipped yet, or at least haven’t been named:

A Learning Agent. Curious, given that Sana Learning was a major piece of the acquisition. Workday Learning and Sana Learn are being positioned as complementary, but I’d expect a dedicated agent for personalized learning paths, content generation, and coaching within the next 6 to 12 months.

A Performance or Feedback Agent. This one is tricky, and I’m not sure “performance agent” is even the right framing. Performance management in Workday has always been where good intentions go to get buried under rating scales and due-date reminders. Slapping an AI on top of that stuff doesn’t fix the process. The shift I think is actually coming is bigger: performance stops being an annual event and starts being continuous feedback consumption and aggregation. 360 feedback, peer recognition, awards, signals pulled from meeting notes and email threads, all of it synthesized into something coherent. That’s a fundamentally different product than “help me write a review.” Workday hasn’t named that agent yet. When they do, it’ll matter a lot more than a draft-my-review button.

A Comp Agent. Compensation planning is another area ripe for agent help: market data, internal equity checks, recommendation drafting. Conspicuously absent.

Read the roadmap accordingly.

The Bottom Line

The Workday agent lineup is going to keep changing. Names will shift. Capabilities will expand. A vendor you haven’t heard of yet will get acquired, and whatever they built will get absorbed into this roster within a year of the deal closing.

What won’t change is the architecture. Agents grounded in trusted data. Governance through ASOR. Security that inherits from your tenant. The pieces that actually determine whether this stuff works.

What also won’t change is the economic model. Flex Credits are here to stay. Know your rates. Know your meters. Know what counts toward your entitlement and what doesn’t. The agent roadmap is exciting. The consumption math is what’ll show up on your Finance team’s invoice.

Learn the architecture. The product names will take care of themselves.

The Illuminate branding lasted about eighteen months. Sana will probably last longer, but not forever. What you build on top of the real plumbing underneath: that’s the part that compounds.

-- Mike

P.S. A HUGE shout-out to Keith Bitikofer for the Philly RUG session that sharpened most of the Flex Credits analysis in this post. Keith pulled back the curtain on the parts of the rate card that weren’t in the marketing deck, walked the room through what actually counts toward entitlement, and demoed the PCC live. That’s the kind of practitioner-to-practitioner knowledge transfer that RUGs exist for. If your local RUG has a Keith, show up. If it doesn’t, please consider being one.

P.P.S. Ultimately, Roblox gave me my money back, but also perma-banned Justin’s original account. To this date, I still have not been forgiven. He apparently purchased the Titanic in some game where a random player becomes a Jaws-like great white shark and eats boats (and other players). I will never understand Gen-alpha. Then again, we had Doom. We’re definitely more screwed up.

tl;dr:

Moving from "AI that suggests" to "AI that acts" isn't an upgrade. It's a fundamentally different risk profile, and most HR tech teams have zero infrastructure for it.

Back in December, I published a Safety Checklist. Five questions to ask your vendors before buying. This is the harder list: three questions you have to answer yourself before deploying, plus the foundational data problem underneath all of it.

Your current change management process was designed for humans. Agentic AI is going to look at it, politely nod, and then set it on fire.

The Promotion Nobody Voted On

In Part 2, I introduced you to my digital intern. Permanently caffeinated. Never asks for PTO. Occasionally confidently wrong about whether the Egyptians invented pizza.

You liked the intern. I liked the intern. The intern was great.

Here's the problem: someone in your leadership team just watched a vendor demo where the intern wasn't fetching coffee anymore. The intern was approving purchase orders. The intern was adjusting compensation ranges. The intern was making decisions about people's careers while a sales engineer narrated the whole thing like a nature documentary.

And now that leader is in your office asking: "Why aren't we doing this?"

The intern didn't get smarter. The intern got promoted. And nobody in your organization voted on it, built a job description for it, or thought about what happens when the newly promoted intern does something catastrophically wrong at 2am on a Saturday with no human in the loop.

That's what this post is about.

The Jump

The distance between "AI that recommends" and "AI that acts" is not a step. It's a canyon.

On one side, you have a tool that says, "Hey, based on the data, you might want to consider adjusting this comp range." A human reads it, thinks about it, and decides. That's a suggestion. That's a really smart sticky note.

On the other side, you have an agent that adjusts the comp range. Autonomously. Based on logic that someone approved at some point, theoretically, probably during an implementation meeting where half the room was checking email and the other half was trying to figure out the conference room AV system.

Most HR tech teams have spent decades building change management processes, approval chains, and governance structures for humans making decisions. Humans who hesitate. Humans who call their colleague and say, "Does this look right to you?" Humans who have a gut feeling that something is off, even if they can't articulate why.

Agents don't hesitate. Agents don't have gut feelings. Agents have logic, and they execute that logic with the enthusiasm of a golden retriever who just discovered the gate is open.

Nobody has built a governance model for that. And the vendors selling you agentic capabilities are not going to build it for you. That's not a knock on them; it's not their job. It's yours.

So let's build it.

The Checklist Was the Entrance Exam. This Is the Course.

Back in December, I published a five-point AI Safety Checklist. These were the questions you ask your vendor before you buy anything. Data retention. Bias audits. Explainability. Security inheritance. Kill switches.

That was the entrance exam. Those questions protect you from buying the wrong thing.

This is different. These are the questions you have to answer about yourself before you deploy the right thing. Because you can pass every vendor checkpoint with flying colors and still crash the car if you haven't built the road.

Three questions. They sound simple. They are not.

1. "Who Gave It Permission? Does That Permission Still Mean What They Think It Means?" (Authority)

Every agent acts on authority. Someone, somewhere, at some point, said "yes, you can do this."

The question is: who? And when? And did they understand what they were saying yes to?

Because here's what happens in practice. During implementation, someone approves a capability called "Talent Optimization." It sounds great. Everybody nods. It goes into the statement of work as an enabled feature. Eighteen months later, the vendor has expanded what "Talent Optimization" means. Now the agent is auto-adjusting job posting language based on candidate conversion data. It's rewriting your job descriptions. In real time. Based on what gets clicks.

And nobody remembers approving that. Because technically, they didn't. They approved a category. The vendor filled in the details later. And the details now include an AI rewriting your EVP messaging to optimize for engagement metrics that may or may not align with what your talent acquisition strategy actually says.

This happens all the time with regular software. Feature creep is not new. But feature creep with a deterministic system means someone eventually notices and opens a ticket. Feature creep with an autonomous agent means the agent has been making decisions for weeks before anyone realizes the scope drifted.

The fix: A living authority register. Not a one-time implementation sign-off. A document (a real one, not a slide deck someone presented once at a steering committee meeting and then buried in a SharePoint folder called "Archive - DO NOT DELETE - Final v3") that says exactly what each agent is authorized to do, who approved it, when it was last reviewed, and what the boundaries are. Reviewed quarterly at minimum.

I know. Quarterly reviews. I can feel you closing the browser tab. Stay with me.

2. "Who's Watching What It Did? Can They Explain Why It Did It?" (Oversight + Explainability)

In the Safety Checklist, I told you to demand explainability from your vendors. A "Glass Box," not a black one. Every output should come with a reasoning chain.

That was the vendor's job. This is yours: who on your team is actually reading those reasoning chains?

Agents act fast. Humans review slow. If your agent runs daily and your review cadence is monthly, you have 30 days of unaudited decisions compounding on top of each other. That's not a gap. That's a canyon with a gift shop at the bottom selling "I Survived Our AI Governance Program" t-shirts.

The scenario: An AI agent is recommending compensation adjustments across open requisitions based on market data, pipeline conversion rates, and internal equity benchmarks. It runs every day. It touches 200 reqs over three weeks.

Recruiters see the recommendations. They look reasonable. They have a little confidence score next to them, which (as we discussed in Part 3) makes humans go absolutely limp with compliance. "The system says 87%? Must be right." They adjust the comp ranges. Hiring managers approve. Offers go out.

Three weeks later, someone in Total Rewards finally reviews the output. They discover the market data feed was pulling from a dataset that included contract roles, which inflated the benchmarks by 12%. Every comp adjustment for the last three weeks was built on a bad foundation.

You are no longer auditing a recommendation. You are unwinding a decision chain. Offers have been extended. Some have been accepted. And here's the part that should make your legal team's ears perk up: if those inflated benchmarks skewed differently across demographics (and they almost certainly did, because market data for contract roles doesn't distribute evenly across job families), you may have just created an adverse impact pattern. Not because anyone intended to discriminate. Because nobody was watching closely enough to catch the drift.

That's not an AI bias problem in the way the Checklist discussed it. You already asked the vendor for the bias audit. They passed. This is a monitoring problem. The model was fine. The data feeding it shifted. And nobody caught it because nobody was assigned to catch it at the speed the agent was moving.

The fix: The review cadence has to match the action cadence. If the agent acts daily, someone (a human, with judgment, and the authority to say "stop") reviews daily. And that person needs to be able to read the reasoning chain — not just see the output, but understand why the agent made the call it made. If your reviewer can't explain the agent's logic to a skeptical VP in plain English, the review is theater.

3. "What's the Damage Protocol?" (Rollback)

The Safety Checklist gave you the kill switch — the vendor-side toggle that lets you shut it off. Good. You need that.

But turning it off is step one. What about the damage that's already done?

Your agent is going to make a mistake. It is a statistical certainty. And I need you to internalize something: the mistake will not announce itself. There will be no pop-up that says "ERROR: I JUST DID SOMETHING DUMB." The agent will execute the wrong action with the exact same confidence it executes the right one. That's the whole thing about machines. They don't sweat. They don't pause. They don't get a weird feeling in their stomach when something doesn't add up.

You know who does get a weird feeling in their stomach? Brenda in Payroll. And Brenda is going to catch this. At 4:47pm on a Friday. And Brenda is going to send you an email with the subject line "Question???" and three question marks is never good. Three question marks means Brenda found a body.

The scenario: An agent flags a batch of employees for a compliance-related action based on certification expiration dates. The field hasn't been audited in eight months. Some of the dates are stale. Some are flat-out wrong because someone fat-fingered an entry during a mass upload and nobody caught it because (and this is the part where I stare directly into the camera) nobody audits EIB data after the upload.

The agent doesn't know the data is stale. The agent sees an expired certification, matches it to a business rule, and fires the action. Forty employees get compliance notices. Twenty of them have valid, current certifications. They are, understandably, upset. Some of them call HR. Some of them call their manager. One of them calls a lawyer. (There's always one. If you've worked in HR Tech long enough, you know that one person who has a lawyer on speed dial like it's a pizza place.)

And here's where the regulatory landscape makes this worse: depending on the nature of the compliance action and your jurisdiction, you may have just triggered a notification obligation. NYC Local Law 144 requires notice and disclosure when automated tools are used in employment decisions. The EU AI Act classifies HR systems as "high-risk." You didn't just send a wrong notice; you potentially sent a wrong notice using a process that regulators are actively watching.

The fix: A rollback playbook for every agentic capability you enable. Not "open a ticket." A documented protocol that answers: what gets reversed, who authorizes the reversal, how do we communicate to affected employees, who owns the post-mortem, and what's our regulatory notification obligation? That protocol needs to exist before the agent goes live. Treat it like a disaster recovery plan. Because that's what it is.

The Floor Under the Agent (Data Foundation)

I've saved the most boring and most important part for last.

Your agent inherits every sin in your data.

Every stale supervisory org. Every orphaned position. Every job profile that hasn't been audited since the original implementation when someone said, "We'll clean that up in Phase 2," and Phase 2 never came because Phase 2 is a myth. Phase 2 is the HR Tech equivalent of "we should get together sometime." It's never happening.

The agent doesn't know your data is bad. The agent treats your data as ground truth. It walks across your data foundation like it's solid concrete. If there are holes, the agent falls through them at machine speed. And it doesn't even know it's falling. It just keeps executing, confidently, all the way down.

Bad data in a traditional system creates bad reports. Bad data under an autonomous agent creates bad actions. Reports you can correct. Actions you have to undo. And some actions (an offer extended, a notice sent, a compliance flag triggered) are really, really hard to undo.

The minimum before you go agentic:

• Supervisory org audit. When was the last time you verified that your org structure in the system matches reality? If the answer involves the phrase "during implementation," that's not an answer. That's a confession.

• Job profile hygiene. Are your job profiles current, consistently structured, and actually reflective of the roles people are doing? Or are they a museum exhibit of what someone thought the role was in 2019?

• Data field freshness. Every field the agent will read needs a last-verified date. If you can't tell me when a data point was last validated, the agent shouldn't be acting on it.

• Integration integrity. If the agent is pulling data from multiple systems, are those systems in sync? Or are you running on "Schrödinger's Data" (a concept I covered earlier in this series) where the same employee exists in three systems with three different job titles and nobody knows which one is authoritative?

You don't need perfect data. (Perfect data is another myth, right up there with Phase 2 and "we'll migrate the historical data later.") You need audited data. You need to know where the holes are before the agent starts walking.

Your Change Management Process Is Kindling

I promised in Part 3 that we'd talk about why your current change management process is going to look at agentic AI and burst into flames.

Here's why.

Your change management process was designed for a world where a human is the decision-maker at every step. A change gets proposed. A stakeholder reviews it. An approval chain fires. Someone communicates it to the affected population. Training happens. Feedback gets collected. The cycle repeats.

That entire model assumes one thing: time. Time for review. Time for feedback. Time for someone to say, "Wait, I don't think this is right." Time for Brenda to get that feeling in her stomach.

Agentic AI compresses time to near-zero. The agent proposes, evaluates, and acts in the space between your first sip of coffee and your second. There is no "review window." There is no "let's run this by the team." The agent ran it by itself, and it approved unanimously (because it was the only one in the room, and it doesn't understand the concept of a dissenting opinion).

You don't need a new version of your change management process. You need to acknowledge that the old one was designed for a species that moves at human speed, and then build something new for a world where decisions happen at machine speed.

What does that look like? It looks like pre-approved decision boundaries instead of case-by-case approvals. It looks like automated exception detection instead of manual review queues. It looks like real-time monitoring dashboards instead of monthly steering committee decks. It looks like treating your governance model as a living system, not a binder on a shelf.

It looks like work. A lot of it. I'm sorry. I wish I could tell you there's a shortcut. The shortcut is called "let the agent do whatever it wants and hope for the best," and the technical term for that strategy is "career-limiting."

The AI hasn't changed. The models are getting better, sure, but the fundamental dynamic is the same as it was in Part 2 when I was using it to draft user instructions and untangle calc fields. It's a tool. A very fast, very confident, occasionally wrong tool.

What changed is the authority. You moved the intern from the desk next to yours (where you could see the screen, check the work, and catch the errors) to a corner office with signing authority and a door that closes.

The governance model is how you make sure that promotion is earned. Incrementally. With guardrails. With review cadences that match the speed of the decisions being made. With rollback plans that exist before you need them. With data foundations that have been audited this calendar year.

Not all at once on a Tuesday afternoon because someone in the C-suite saw a demo and sent you an email with "THOUGHTS??" in the subject line.

Build the governance. Audit the data. Match the review speed to the action speed. Plan the rollback before you need it.

And for the love of everything, answer the questions before you flip the switch.

That's the series. Four (okay, it ended up being five) parts. The vocabulary, the plumbing, the literacy gap, and the governance. If you've made it through all of them, you're better prepared than most of the HR tech teams I talk to. And if you read the Safety Checklist back in December, you've now got both sides: the questions you ask them and the questions you answer yourself.

If this series helped you think differently about AI in your environment, share it. Forward it. Post it. Do the LinkedIn screenshot thing. Build the governance your organization needs before someone else builds urgency you can't control.

And if you're sitting there thinking, "This is great, Mike, but how do I actually sell this to my leadership?" Yeah. I hear you. I might have another post in me on that. No promises. (Okay, soft promise.)

— Mike

Director HR Tech | Intern Supervisor

The Department of First Things First. For the people who do the work.

P.S. Justin asked me what "governance" means. I told him it's like the rules in his video game that keep other players from cheating. He said, "So... it doesn't work?" Kid might have a future in consulting.

You just found The Department of First Things First. Maybe someone forwarded you a post. Maybe you caught me on Unsafe Harbor or Workday Gold. Maybe you Googled “why does Workday hate me” and ended up here.

Either way, welcome. Here’s the quick version of what this place is:

I’m Mike Domingo. I’ve been in HR technology for over twenty years. I’m currently a Sr. Manager of HR Technology at CVS Health. I co-organize the Philadelphia Workday RUG. I have a PMP, a DASM, and four Workday Pro certifications. I have opinions, and this is where I put them.

This newsletter is for the people who actually configure, architect, and maintain enterprise HR systems. Not the analysts. Not the buyers. Not the people who attend conferences and nod. The people who go back to their desks on Monday and have to make it work.

I publish weekly. No paywalls. No sponsors. No vendor cheerleading.

Here are five posts that will tell you whether this is your kind of place:

1.

My son Justin asked me for $10 to buy a cosmetic skin for his video game character. It didn’t make him faster or stronger. He just looked cool while falling off a cliff. Then Workday released their Sana-driven UI and I realized they’d done the exact same thing for a billion dollars. This post breaks down what the new UI actually means for practitioners, where the security nightmares hide, and why a search bar on top of a messy warehouse doesn’t clean the warehouse.

2.

Josh Bersin published a piece about AI “orchestration” that made it sound like the future was already here. I wrote the practitioner’s rebuttal. This one hit a nerve — 21,000 LinkedIn impressions, 233 reactions, 44 saves, and it doubled the newsletter’s subscriber count in a week. If you’ve ever sat in a meeting where an executive waved an analyst article at you and asked “why aren’t we doing this yet?” — this post is the answer you wished you had.

3.

Bersin argued that enterprise software is protected by a moat of decades-deep business rules. He’s right about the moat. But for the people actually using the system, that moat feels like a ten-lane tollbooth. This post introduced the framework I keep coming back to: the ERP isn’t going away. But the future is the ERP becoming headless infrastructure, buried so deep under experience layers and AI agents that the end-user forgets it exists.

4.

The hardest part of moving from Workday analyst to architect isn’t learning a new module. It’s the psychological shift from fixing tickets to navigating politics. I break down what that transition actually feels like: the muscle memory trap, the instant gratification desert, and why the Kitchen Table Test (can you explain your architecture to an 11-year-old?) is the only metric that matters.

5.

I Let My 11-Year-Old Audit Workday’s UI. He Lasted 3 Minutes.

I handed my son Justin a Workday tenant and asked him to request a day off. He’s a digital native who can navigate any app in seconds. He lasted three minutes before giving up. If a kid who grew up with an iPad needs a Quick Reference Guide to use your system, your design is broken. This post is the one that makes non-technical leaders finally understand the UX problem.

If any of those landed, you’re in the right place. Subscribe and I’ll show up in your inbox weekly with architecture takes, vendor accountability, and the occasional story about my son accidentally explaining enterprise strategy better than a $50,000 consultant.

— Mike

Director HR Tech | Keeper of the Layer Cake

P.S. If you want to hear me talk instead of read me type, I’ve been a guest on:

• Talent Experience Live with Devin Foster at Phenom — “Speed Meets Experience” (to be published)

• Unsafe Harbor with Christian Delcid — Episode 14

• Workday Gold with Keith Bitikofer — December 19th, 2025

All are worth your commute.

tl;dr: Josh Bersin released a podcast about AI literacy last week. It’s fourteen minutes of anxiety creation and product placement. His core argument — “AI learns from language, so be logical” — isn’t wrong, it’s just useless for practitioners. Real AI literacy for HR tech people isn’t about prompting or vocabulary. It’s about governance: who holds the leash on AI agents, what happens when they act on employee data, and how the requirements scale dramatically across Workday Illuminate’s tiers (Accelerate → Assist → Transform).

Josh Bersin dropped a podcast last week called “What Does AI Literacy Really Mean?”

Fourteen minutes long. And in those fourteen minutes, he managed to identify a problem, create anxiety about it, and sell you the cure. It’s a clean structure. The kind you’d respect if it weren’t aimed directly at your budget.

I’m not saying AI literacy isn’t important. It is. But when an analyst defines the disease and sells the medicine, you’re allowed to ask for a second opinion.

Here’s mine.

“AI Learns From Language” Is Not a Framework

Bersin’s big reveal is that AI learns from language, so you need to be able to put your needs into “logical statements” to get the most out of it.

That’s like telling someone learning to drive that cars run on gasoline. True. Not particularly useful when you’re trying to parallel park.

You know what AI literacy actually looks like for the people reading this newsletter? It looks like understanding why the same prompt gets wildly different results depending on how much context you give it. It looks like knowing what RAG is — not because you need to build one, but because your vendor is about to sit across from you and say their product “uses RAG” with the confidence of a sophomore who Wikipedia’d the topic ten minutes before the presentation. You need to know whether that’s meaningful or marketing.

It looks like understanding the difference between a model suggesting something and a model doing something. Which (and I really need everyone to internalize this) is the difference between “helpful tool” and “thing that just changed an employee’s compensation while you were in a meeting about change management.”

That’s not “be more articulate.” That’s architecture.

Bersin doesn’t go there. And to be fair, that’s not really his audience. His audience is buying. This newsletter’s audience is building. The advice that works at 30,000 feet can be actively misleading at ground level.

The Grocery List Is Not a Meal

In his podcast notes, Bersin name-drops bias, risk, auditability, data quality, and tuning. He even throws in a note about “vibe coding” being more complex than people think.

Cool. That’s a grocery list.

You don’t hand someone a list that says “chicken, rice, lemon, garlic” and call yourself a cooking instructor.

Who owns bias review when an AI suggests a compensation adjustment? What’s your escalation path when an agent takes an action on employee data that doesn’t match your business rules? What do you do on the Monday morning when someone in legal calls because an AI-driven recommendation created a disparate impact pattern that nobody caught because nobody was assigned to catch it?

These aren’t abstract questions. They’re Tuesday. They’re the actual work. And no podcast or newsletter (mine included) answers them for you. The difference is I’ll tell you that upfront instead of pointing you toward a subscription product.

So What Does AI Literacy Actually Look Like?

It looks like governance.

I know. I’m sorry. I just said the word “governance” and half of you felt your soul leave your body. Stay with me.

Not the “let’s draft an AI ethics statement and put it on the intranet where it can live next to the recycling policy and the 2019 holiday party photos” kind.

The kind where you decide (before you turn anything on) who holds the leash, how long it is, and what happens when the dog runs into traffic. Because the dog will run into traffic. The dog always sees a squirrel named “efficiency” and just goes.

I wrote about this in “The Agentic Leash” a few weeks ago, and the response told me something: practitioners are hungry for this conversation. Not the theoretical version. The operational one.

So let’s get operational.

The Tiers Are Not Created Equal

If you’re in the Workday ecosystem (and if you’re reading this, there’s a solid chance you are), you already know about Illuminate. What you might not have thought about is how dramatically the governance requirements change as you move through the tiers.

Accelerate is the easy one. Embedded AI. Summarization, natural language search, smart suggestions that surface information. Low risk. The AI is basically a really enthusiastic research assistant who never sleeps and never asks for PTO. You still make every decision. Governance here is mostly “did we turn it on?” and “does our security model still make sense?” This is the tier where everyone feels smart. Enjoy it.

Assist is where it gets interesting. The AI starts making recommendations that humans act on. Job matching. Compensation suggestions. Talent pipeline insights. The AI is no longer just surfacing information — it’s interpreting it. And the human on the other end might not know how to evaluate whether the interpretation is any good.

That’s where literacy matters. Not “can you prompt well?” but “do you understand what you’re looking at well enough to push back on the machine?” Because here’s the thing about humans: we are phenomenal at deferring to something that sounds confident. The AI gives you a recommendation with a little percentage next to it and suddenly everyone in the room is nodding like it came down from a mountain on a stone tablet.

Transform is the one that keeps me up at night. This is where agents take action. Not suggest action. Take action. And the governance model for that is fundamentally different from anything most HR technology teams have ever had to build.

Who approved the model’s logic? Who reviews the output before it hits a manager’s inbox? What if it’s wrong? What if it’s right but the business context changed and nobody told the model? What’s the rollback plan?

These questions don’t show up in a 14-minute podcast about AI literacy. But they’re going to show up in your implementation, whether you’re ready for them or not.

A Scenario, Because I Know How We Learn

Let’s say your Workday environment is running an AI agent (Transform tier) that analyzes talent pipeline data and suggests changes to open job requisitions. Adjusted job descriptions. Revised compensation ranges. Maybe even suggested changes to hiring criteria based on what’s working in similar roles.

Sounds amazing. Sounds like the future.

Now: who approved the logic the model used to decide what “working” means? Is it optimizing for time-to-fill? Quality of hire? Retention at 12 months? All three? Because those optimization targets can conflict with each other, and the model picked one. Or blended them. And someone in your organization needs to know which, and why, and whether that aligns with what your CHRO actually wants (or what they said they wanted six months ago before the reorg).

The output lands in a recruiter’s queue. It says “adjust the comp range for this req from $85K–$95K to $92K–$105K based on market data and pipeline conversion rates.” The recruiter sees an AI-generated recommendation and thinks, “Cool, the system says so.” They adjust it. The hiring manager approves it. Nobody interrogated it.

Nobody asked: what market data? What pipeline? Over what time period?

Six months later, you’ve got a comp equity issue that nobody can trace because it started with an AI recommendation that twenty people approved by not questioning it.

That’s not an AI failure. That’s a literacy failure. And it’s a governance failure. Because nobody defined who’s supposed to ask those questions before the recommendation goes live.

This is what AI literacy looks like in practice. It’s not prompting. It’s not “being logical.” It’s understanding the system well enough to know when to trust it, when to question it, and when to shut it off and figure out what went wrong.

The Encyclopedia vs. The Architecture

Bersin will keep writing the encyclopedias. There’s value in that. The categories, the frameworks, the market maps…they serve an audience. He’s earned that lane.

But if you’re the person who has to actually build the thing? Configure the tenant? Explain to your VP why the AI did what it did? Stand in front of a governance committee and say “here’s how we control this” while someone from legal stares at you like you just described a haunted house?

You don’t need an encyclopedia. You need architecture.

AI literacy for practitioners isn’t a course you take or a product you subscribe to. It’s a muscle you build. It’s knowing your platform, knowing your data, and knowing who’s accountable when the machine makes a move.

Next week: what happens when you actually let the agent off the leash. Part 4 goes deeper on the governance operating model: who owns what, how to build the review cadence, and why your current change management process is going to look at agentic AI and simply burst into flames.

If this is the kind of thing that makes you nod at your screen in a way that concerns your coworkers, please subscribe. And if you know someone who’s building, not just buying, share this with them. Forward the email. Post the link. Do that thing where you screenshot a paragraph and put it on LinkedIn with a “THIS 👆” caption. I won’t judge.

(I will judge a little.)

— Mike

The Department of First Things First. For the people who do the work.

P.S. Justin just wrapped up travel 14U volleyball season, where the gym acoustics are specifically engineered to ensure no parent retains their hearing by age fifty. And now we’re rolling straight into spring tennis tournament season, where I get to watch twelve-year-olds make line calls that would get a FIFA referee fired. USTA rules: on the line is out, inside the line is questionable, and clearly in is “I didn’t see it.” Governance starts at home, people.

"Built in" is doing a lot of work. Workday's security model isn't two words. It's domain policies, BP policies, constrained groups, intersections — and none of that translates cleanly when an agent pulls Slack data into a Workday comp profile.

"Thousands of agents" is a loaded gun, not a feature. Who approves them? Who audits them? What happens to API performance when 1,000 custom agents start polling Workday at once? Josh doesn't ask. You have to.

ASOR gets one mention. In parentheses. For a guy who coined "Intelligent Orchestration," the actual orchestration layer gets less screen time than the Galileo sales pitch.

The Copilot collision Josh skipped. Your CIO already paid for Microsoft Copilot. The question isn't "is Sana better than Copilot" — it's "is Sana better enough to justify funding two AI front-ends after we told the board we were consolidating."

Disclosure ≠ objectivity. Telling me you own the stock doesn't make the analysis objective. It just tells me why it isn't.

The Form Check. Six things your team should be interrogating right now — security inheritance, agent approval pipelines, data lineage, hallucination monitoring, migration paths, and real TCO (not sticker price).

It's 2:00 AM. You can't sleep. You're flipping channels.

And there he is. Perfectly lit. Radiating confidence. Leaning into the camera with the energy of a man who has personally tested this product and needs you to know about it.

The demo is flawless. The stains disappear. The before-and-after is stunning. Four amazing product features, each one bigger than the last. And right on cue — the call to action:

"Call us if you want to walk through the details."

I had a Billy Mays moment this week. You know the one. Where you're watching what looks like industry analysis, and then the camera pulls back and you realize…Oh! This is an infomercial. And the host is really good at it.

The Disclosure That Changes Everything (And Nothing)

To his credit, Josh tells you the deal right up front in paragraph one. He's a Sana customer. He's a Sana partner. His product, Galileo, runs on Sana. He's been using it for three years.

That's honest. I respect that.

But here's the thing about disclosure: it's necessary, but it's not sufficient. Telling me you own stock in the company doesn't make your stock analysis objective. It just means I know why it isn't. And once you know that Josh Bersin is reviewing his own landlord's renovation while selling condos in the building, every sentence reads differently.

Let's walk through his four big announcements the way an enterprise practitioner hears them. Which is: differently.

Announcement 1: All Workday customers get access to Sana for Workday.

Sounds incredible. What does "access" mean?

Is it bundled with existing SKUs? Is it a freemium play with an upsell? Is there a per-user cost? Per-transaction? Does my current contract cover it or is this a massive change order?

Josh doesn't say. A CHRO doesn't ask. But you — the person who manages the vendor relationship, reads the SOW, and explains the budget impact to the CFO — you're already reaching for your Workday rep's number.

(They're not going to pick up. The pricing is still "TBD." You know this.)

Announcement 2: Sana Enterprise connects to Salesforce, Teams, Slack, and more.

Multi-system integration through a single AI front-end is genuinely interesting. But here is what Josh calls Workday's security model: "built in."

Two words. For the most complex permission framework in enterprise HR technology. Domain security policies. Business process security policies. Constrained and unconstrained security groups. Intersection configurations.

"Built in." That's like saying OxiClean works on "all fabrics." Technically, the box says that. But you and I both know there's a reason the demo always uses a white t-shirt and never your grandmother's silk blouse.

But the real nightmare isn't just Workday's security; it's security translation. When Sana pulls a Slack message and pairs it with a Workday comp profile, whose security model wins? If an agent uses an Integration System User (ISU) to connect Workday and Salesforce, how does it respect field-level security across two entirely different data models?

The infomercial shows someone asking Sana for their PTO balance and getting a clean, happy answer. It does not show the data breach review after an agent surfaces comp data to someone in a view-only job requisition role because the integration couldn't translate the constrained security group.

Announcement 3: You can build your own agents in Sana.

Josh says: "Companies will build thousands of these agents."

Thousands.

My son, His Highness Justin (almost 12), can spin up a custom Roblox server with custom mods in ten minutes with zero oversight. Do I want an enthusiastic compensation analyst building a Workday agent with that same level of friction?

Who monitors for hallucination? Who audits data access patterns? What's the version control story? What happens when that comp analyst inadvertently exposes salary band data because the security inheritance isn't what they assumed? Or worse, what happens to your system performance when 1,000 custom agents start continuously pinging Workday's APIs to check for status updates?

Josh describes a loaded gun and spends the whole segment talking about how shiny it is.

The safety doesn't get mentioned. Not once.

Announcement 4: Sana's AI infrastructure becomes Workday's AI infrastructure.

Josh says the Illuminate brand is essentially being absorbed. New agents will be built within Sana's infrastructure going forward. Cool.

But what happens to the governance framework? Workday just spent a year training the ecosystem on how to govern Illuminate via the Agent System of Record (ASOR). Now they bought a completely new engine. Does the ASOR governance framework survive the transplant, or are we back to square one?

Want to know how seriously Josh takes ASOR? He mentions it once. In parentheses. Literally in punctuation designed for afterthoughts. He calls it "critical"…and then treats it like a footnote. For a guy who coined "Intelligent Orchestration," the actual orchestration layer gets less screen time than the Galileo sales pitch.

And when it comes to Paradox, HiredScore, and the rest of Workday's recent acquisitions? Josh's answer is: "will come out over time." If you're a customer who just finished a HiredScore integration, that sentence should make your eye twitch. Workday spent serious money acquiring these tools. You spent serious effort implementing them. "Will come out over time" is the analyst equivalent of thoughts and prayers.

The Boardroom Collision Josh Ignored

Josh's competitive landscape section is polite. Oracle gets two sentences. SAP/Joule gets a nod.

But there is a massive, existential boardroom collision coming, and Josh completely sidesteps it.

If you are an enterprise shop, you probably already have Microsoft Copilot. Not because you chose it, but because it came with the E5 agreement you signed two years ago. It's already in the budget. Already past procurement. Already blessed by InfoSec. Already in the SSO flow.

Now imagine walking into your CIO's office and saying: "I need budget for a second AI platform."

The CHRO wants Sana because it's "HR native." The CIO wants Copilot because it's already deployed and paid for. The question isn't "Is Sana better than Copilot?" Features comparisons are easy. You can build a slide for that.

The question is: "Is Sana better enough to justify paying for both?"

That is a "why are we funding two AI front-ends when we told the board we were consolidating vendor spend" conversation. And it's a conversation you can't objectively write when your own product runs on one of the platforms being evaluated. A practitioner actually has to live in that overlap. You have to answer the question your CIO will absolutely ask: "Can't we just build a Workday connector in Copilot Studio?"

Maybe the answer is yes, Sana is worth it. Maybe the Workday-native security layer and the learning platform integration genuinely differentiate it. But that argument has to be made with math, not with a Billy Mays demo. And the person who has to make that argument is you. Not Josh.

The Form Check: What You Should Actually Be Asking

Maybe Sana clears every one of these questions. Great. Let's see the test results. The point isn't that the answers are bad. The point is that nobody is asking the questions out loud, and somebody has to.

If Workday is serious about Sana as the agent infrastructure, here is what your team needs to be interrogating right now:

1. Security Inheritance Validation: Don't trust "built in" until you've tested it. Build test cases that intentionally cross security boundaries. Verify that Sana respects domain security, BP security, and field-level security independently across integrated systems.

2. Agent Inventory and Approval: If "thousands" of agents are coming, you need a pipeline. Not a free-for-all. Who approves them? Is there a review board? A sandbox environment? A staging process?

3. Data Lineage and Auditability: When an agent surfaces an answer, can you trace where that data came from? Which Workday report or data source did it pull? Was it real-time or cached? If an agent gives a wrong answer that leads to a business decision, can you reconstruct the logic?

4. Hallucination Monitoring: LLMs hallucinate. Period. What's the monitoring framework for agent-generated responses? Is there a confidence threshold below which the agent declines to answer? Who reviews flagged responses? Nobody has a great answer for this yet. That's exactly why you need to be asking.

5. Migration and Coexistence: If you've invested in Illuminate, what's the migration path? If you've built custom apps on Workday Extend, what's their future in a Sana-native architecture? Get it in writing. "Will come out over time" is not a migration plan.

6. Cost Modeling: What's the Total Cost of Ownership? Not just the sticker price, but the incremental FTE for agent governance, the change management burden, and the opportunity cost of not spending that budget elsewhere. Especially if you're already paying for Copilot.

The Laundry Room

Here's the thing about Billy Mays. He wasn't a con man. OxiClean actually works.

But Billy Mays didn't invent OxiClean. He was a paid endorser who did demos under perfect studio conditions. The lighting was right. The stain was pre-selected. And the camera cut away before you saw what happened when you tried it on the wrong material.

That's this article. Sana might be legitimately great. Josh clearly loves using it.

But this piece isn't strategic analysis. It's a guy in a blue shirt doing a demo with a white t-shirt and a perfect stain, under studio lighting, with a 1-800 number at the end.

The part the infomercial never covers is what happens when you get home, open the box, and try it on real fabric with real stains in your actual laundry room. That part has a name. It's called enterprise architecture.

And the stains are real.

-Mike

The infomercial ends. The laundry doesn't. Subscribe to The Department of First Things First.

This is a conversation space exclusively for subscribers—kind of like a group chat or live hangout. I’ll post questions and updates that come my way, and you can jump into the discussion.

Join chat

How to get started

1. Get the Substack app by clicking this link or the button below. New chat threads won’t be sent sent via email, so turn on push notifications so you don’t miss conversation as it happens. You can also access chat on the web.

Get app

2. Open the app and tap the Chat icon. It looks like two bubbles in the bottom bar, and you’ll see a row for my chat inside.

3. That’s it! Jump into my thread to say hi, and if you have any issues, check out Substack’s FAQ.

Last week, I gave you the vocabulary. RAG. MCP. Agents. The decoder ring for every vendor pitch and analyst article your CHRO will forward you at the moment.

But I also made you a promise: I'd show you what this actually looks like on the ground.

I spend a lot of time preaching about agentic governance and the risks of letting AI loose in your HRIS. But I also use these tools every single day. They're not optional anymore. They're how I survive.

So here it is. The truth about how I actually use AI at work. No vendor hype. No magic wands. Just the plumbing.

tl;dr:

I use AI every day, but I don't let it touch my Workday tenant. It's a digital intern — fast, tireless, occasionally confidently wrong. Three use cases that save me ~15 hours a week:

• The Translator: Drop dense Workday docs into an LLM with a specific prompt, get clean user instructions back in 15 seconds instead of 45 minutes.

• The Synthesizer: Feed scrubbed UAT feedback into AI, get the actual root causes instead of spending two days manually tagging a spreadsheet.

• The Wrench: Use AI as a pair-programmer for calc fields and XSLT — but make it explain its work so you can maintain it later.

• The rule: You are the Architect. The AI is the intern. Never forward the intern's first draft to the CHRO. Never paste its code into production without sandbox testing.

The Confession

Let's get this out of the way.

Right now, I do not let an autonomous AI push data into my Workday production tenant. The risk of corrupting foundational data is too high. Full stop. (That’s not to say this is a forever thing. But until I see things like ASOR mature, that’s my story and I’m sticking to it.)

So the AI doesn't run the system. It runs me.

I treat large language models (Claude, ChatGPT, whatever you prefer) as permanently caffeinated digital interns. They don't have the keys to the building. But they sit right next to my desk, and they help me translate, synthesize, and build the architecture that I eventually deploy.

Here are the three ways that intern earns its keep.

The Translator: Drafting User Instructions

If you work in HR Tech, you know that Workday release notes read like stereo instructions written by someone who has never plugged in a stereo.

A store manager doesn't have the patience for a 12-page PDF on absence management business process changes. They need to know what buttons to click so they can get back to their actual job.

The workflow: I take the dense Workday documentation (community, config docs, etc.) and drop it straight into my LLM with a specific prompt:

You are an expert technical writer. Read this Workday configuration document. Translate it into a simple, 3-step instructional flow for a non-technical manager. Use an encouraging, conversational tone. Strip out all system jargon — do not use words like 'Supervisory Org' or 'Condition Rule.' Output the result with bold headers and short bullet points.

What used to take me 45 minutes of staring at a blank screen now takes 15 seconds. The AI does the heavy lifting of translation. I tweak the final copy.

That's it. No magic. Just a really good first draft that I'd never have the energy to write from scratch at 4pm on a Thursday.

The Synthesizer: Making Sense of the Noise

After a major module rollout, the noise is deafening. Hundreds of UAT tickets. Angry emails. Help desk complaints that range from legitimate system bugs to "I clicked the wrong button and now I'm panicking."

When you're drowning in a sea of "This screen is broken!" and "I can't see my team!" tickets, stepping back to see the actual pattern is almost impossible.

The workflow: I scrub the feedback data of any PII, export the raw complaint logs to a CSV, and feed it to the AI (in this case, my work Copilot. Don’t use commercial tools for work stuff).

Analyze these 200 user feedback tickets from our recent performance rollout. Categorize them by core issue. Identify the top three root causes of user friction.

Within seconds, the AI cuts through the emotional noise. It tells me: "70% of these tickets aren't system errors — they're managers who don't understand the new security role mapping."

Instantly. A chaotic pile of complaints becomes an actionable punch-list.

That's not replacing my job. That's giving me X-ray vision into a dataset I'd have spent two days manually tagging in a spreadsheet.

The Wrench: Calc Fields and Code I Can't Write Alone

I have expert-level knowledge of Workday architecture. But I'm the first to admit my pure programming chops are light. Sometimes you hit a wall. You need to nest five calculated fields, or untangle a messy XSLT transformation on an inbound integration, and the syntax just isn't clicking.

This is where the AI becomes the ultimate pair-programmer.

The workflow: I don't just ask the AI to write the code. I ask it to teach me.

I am trying to build a nested calculated field in Workday to extract the length of service for employees in a specific supervisory org, but my logic is failing. Provide the correct structure, and explain exactly what you did so I understand the mechanics.

It's having a senior developer sitting over your shoulder who never gets annoyed when you ask "but wait, why?" for the fourth time.

It untangles the spaghetti. Writes the fix. And crucially — helps me understand what it did so I can maintain it later. Because nothing is worse than deploying a calc field you can't explain to the next person who inherits your tenant.

Worth knowing: The workflows above use general-purpose LLMs (Claude, ChatGPT, whatever you prefer.) But if your team needs something purpose-built for Workday, check out Mando. It's a Workday-specific RAG tool with curated content from vendors and ecosystem experts, every answer cites its source, and it gets smarter to your org over time. Great for config questions, troubleshooting, and getting new analysts up to speed fast. (They also published a solid AI 101 piece on the Customer Sharing Movement blog — go read it.) (NOTE: This is a personal advocacy only. I have no arrangement with Mando, I just appreciate their work)

You Are the Architect. The AI Is the Intern.

His Highness, Justin - who is nearly 12 now and requires the formal title - thinks my job consists entirely of "typing."

He isn't entirely wrong.

A massive part of HR tech leadership is translating complex technical realities into language that non-technical people can act on. My digital intern saves me roughly 15 hours a week on brainstorming, drafting, and untangling logic. It lets me punch way above my weight class.

But here's the rule, and it's unbreakable:

You never take the intern's first draft and forward it directly to the CHRO.

You never paste the intern's calculated field into the production tenant without testing it in sandbox first.

Use the AI to build the engine. Let it write the drafts, synthesize the feedback, map the logic. But you are the one who turns the wrench, pays the integration tax, and owns the final result.

The intern is fast. The intern is tireless. The intern is occasionally confidently wrong about whether the Egyptians invented pizza.

That's why you're still in the chair.

Next up: we're going to talk about where this gets scary…what happens when the intern gets the keys to the building. Agentic AI governance, the risks nobody's talking about, and why your foundational data strategy is the only thing standing between "helpful assistant" and "unsupervised chaos." Stay tuned.

And if you missed Part 1 (AI for HR People Who Don't Want to Sound Dumb in Meetings) - start there. Consider it the prerequisite.

If this was useful, share it with someone who's still writing user instructions from scratch at 4pm on a Thursday. They need this.

— Mike

Every Director of HR Technology knows the feeling.

Your inbox chimes. It's an email from your CHRO containing a link to the latest visionary article from a top-tier industry analyst, usually pitching some new "Expert HR AI."

The subject line is always the same: “Have you seen this? Why aren’t we doing this yet?”

I was explaining one of these massive AI platform announcements to my 11-year-old son, Justin, the other day (whilst getting my butt kicked at ping-pong). I told him they had loaded 25 years of HR research into an AI that could answer any policy question. He thought about it for five seconds and said:

"So it's basically the Wikipedia of work?"

Out of the mouths of babes. That is exactly what it is.

And it's why these articles make my blood boil. They sell the dream of frictionless AI but completely ignore the architectural plumbing required to make it actually execute tasks in Workday.

So let's fix that. Every major AI concept that matters for HR right now can be explained through the lens of an 11-year-old doing homework on a Sunday night (AKA - the Night of Tears and Regret). And if it can't survive that test, it's not worth your time.

Let’s get down to it.

The Large Language Model (The Kid)

Before we get into tools, let's start with the thing itself.

A large language model (LLM), like ChatGPT, Claude, or Gemini, is like Justin after 11 years of school, YouTube, and life. He's absorbed a ton of information. He can reason through problems. He can even surprise you with what he knows.

But he's working from memory. Sometimes that memory is sharp. Sometimes it's... creative. ("Dad, I'm pretty sure the Egyptians invented pizza.")

The model is the brain. Everything else we're about to talk about is how you make that brain useful in your world.

Prompt Engineering (The Homework Instructions)

Here's where most people start, and honestly, it's the highest-ROI concept on this list.

You know how if you tell Justin "do your project," you get a half-hearted paragraph and a shrug? But if you say "write two paragraphs about daily life in ancient Egypt, one about food and one about housing, with at least one specific detail in each" - Suddenly you get something you can put on the fridge?

That's prompt engineering. It's just being specific.

Tell an AI "write a job description," you get LinkedIn boilerplate. Tell it "Write a job description for a Workday Report Writer, emphasizing cross-functional collaboration and calculated fields, in a tone that's professional but not robotic" - Now we're cooking.

Most people blame the AI when they get bad output. Usually, it's the prompt.

RAG: Retrieval-Augmented Generation (The Study Guide)

Justin needs to write about Egypt, but his memory is fuzzy. So you go full research mode, highlight the good parts of a few articles, drop the stack on his desk, and say "here, work from this."

Now Justin can write something solid. But here's the catch: he can only work with what you gave him. If his teacher posted updated instructions to Google Classroom an hour ago, he doesn't know. He's working from a frozen-in-time stack of paper.

That's RAG. In the real world, RAG means you feed your company's actual documents (policies, SOPs, knowledge base articles) to the AI at query time. It doesn't hallucinate an answer. It pulls from your stuff.

This is what Justin called "the Wikipedia of work."

And when an analyst sells you a massive "Expert AI" for HR? (Ahem, Galileo) That's what they're selling you. A RAG model. It's study guide.

But it's read-only. It knows the answer. It can't press the buttons.

MCP: Model Context Protocol (The Badge and the Keys)

Same Sunday night. Same project. But instead of printing out articles, you take a different approach.

"Here's the login to Google Classroom. Here's the school library database. And here's your teacher's email if you need to ask a question."

Now Justin doesn't need you to pre-chew everything. He can see the latest assignment instructions himself. Check if the rubric changed. Search the library. Even email Mr. Hottenstein to clarify a question (shout out to Mr. Hottenstein, the GOAT). He's got live access to actual systems, and he can do things in them. Not just read stuff you handed him.

That's MCP.

MCP stands for Model Context Protocol. If you want another analogy, think of it as USB-C for AI. Remember when every phone had a different charger? MCP is the universal adapter; an open standard that gives AI a consistent way to plug into your tools. Your calendar. Your HRIS. Your ticketing system. Without someone building a custom integration for each one.

Where RAG gives AI a cheat sheet, MCP gives AI an employee badge.

RAG is read-only and point-in-time. MCP is live, and it goes both directions; the AI can read and write.

AI Agents (The Self-Directed Kid)

Now let's level Justin up.

Instead of you standing over his shoulder going "OK, now open the textbook... now write a topic sentence... now check the rubric..." Imagine Justin just handles it. He reads the assignment, makes a plan, looks up what he needs, writes a draft, checks it against the rubric, and revises. All on his own (AKA - Dad Nirvana). He might ask you a question along the way, but he's driving.

That's an AI agent. An LLM that can plan and execute multi-step tasks: not just answer a question, but figure out what steps are needed, use the tools available, and work through the problem.

In HR terms: asking "what's our PTO policy?" is RAG. Asking "look up my PTO balance in Workday" is MCP. But an agent handles the whole thing: "I need two weeks off in August. Check my Workday balance, find dates that don't conflict with my team's schedules, and draft the request for my manager's approval."

Plan. Research. Execute.

This is the direction everything is heading. And it's why MCP matters so much. Agents need secure, structured access to your systems to do anything useful. MCP is the infrastructure that makes that possible.

We're early. But not as early as you would think. This is live and in the wild, not yet everywhere, but we're seeing it. The groundwork you lay now (clean data, solid integrations, well-defined business processes) is what determines whether your org is ready when agents show up for real.

The Cheat Sheet

Because I know you skimmed. (It's fine. I did too.)

(Format: Concept | Justin Analogy → HR Example)

• LLM | The kid (smart but working from memory) → The AI itself: Claude, ChatGPT, etc.

• Prompting | Clear homework instructions → Writing better queries to get better output

• RAG | The highlighted study guide → AI that answers from your actual policy docs

• MCP | Login access to school systems → AI that connects to Workday/ServiceNow to take action

• Agents | Doing the project end-to-end → AI that handles multi-step workflows autonomously

How to Answer Your CHRO

You don't need a CS degree to make good decisions about AI in HR. But you do need this vocabulary, because the vendors are coming, the RFPs are coming, and you do not want to get swindled by someone selling a RAG model disguised as an agent.

The next time an executive forwards you an analyst's hype piece and asks "Why aren't we doing this?", you have your answer:

"The tool in this article is a RAG model, a great study guide, but it doesn't execute business processes in Workday. Our primary mandate right now is fixing our foundational data so we can eventually deploy true agentic AI that actually removes friction for our managers. Buying another study guide won't fix the workflow."

Let the analysts write the encyclopedias. We have architecture to build.

This is the first piece in a series on how the Department of First Things First actually uses AI in its workflow. Not theory! The real, messy, practical version. If you want to follow along, subscribe and I'll see you next week.

PS- If this was useful, share it with someone in your org who keeps nodding along in AI conversations but definitely Googles everything afterward. We've all been there.

PPS- I have just received a directive from Justin's agent (his mother) that in order for Justin to maintain his position as Chief UX Tester at the Department of First Things First, I am hereby required to refer to him as "the nearly 12-year-old." I have acquiesced to this demand without negotiation. Some agents don't need MCP to execute.

— Mike

tldr;

Josh Bersin published a piece arguing we need an "AI Orchestration Layer" to stitch together all our AI agents. This is literally just enterprise integration architecture wearing a blazer and a TED Talk lanyard.

His centerpiece case study is IBM. It took them a decade. He admits — in the actual article — that he needs to "reach out for an update" on how it's going. That's the flagship, folks.

He casually suggests AI agents could autonomously negotiate employee salaries with no human involved, and then just... keeps typing. Like he didn't just describe an EEOC complaint generator.

The piece plugs his product Galileo three times and his conference twice. He writes "You Are The Consultant Now" in bold, then immediately sells you consulting tools. Chef's kiss.

If your foundational data is broken, an Orchestration Layer doesn't fix it. It routes the broken request to the broken agent faster. You're not buying a conductor. You're buying a middle manager for your robots.

If you listen closely, you can hear it.

It's the unmistakable sound of a thousand CHROs reading the latest Josh Bersin article, titled "What Is AI Orchestration And Why Is It So Important?", and forwarding it to their Director of HR Technology with the subject line: "Thoughts on this? Do we have an orchestration strategy?"

If you just felt a cold chill run through your body, congratulations. You work in HR Tech.

Let's do this.

The Pitch

Bersin's premise is simple enough for any executive to love and too clean to be true: We're entering a world with dozens of AI Agents. A Recruiting Agent. A Compensation Agent. A Benefits Agent. He calls them "functional experts."

His argument? We need a magical "AI Orchestration Layer" sitting on top to stitch them all together. The user asks a question, the Orchestrator figures out what they need, and gracefully hands the baton to the correct agent.

The Orchestrator waves its baton. The Workday Agent plays the violin. The ServiceNow Agent plays the cello. The employee gets a flawless, frictionless experience.

Beautiful. Gorgeous. Absolutely stunning.

Now let me tell you what actually happens.

What Actually Happens

The Orchestrator waves its baton. The Workday Agent picks up its violin and immediately discovers the strings are missing because someone in 2019 built a workaround on a condition rule that nobody documented. The ServiceNow Agent starts playing the cello, but it's in a completely different key because the job profiles in ServiceNow don't match the job profiles in Workday because of course they don't. The Benefits Agent shows up late because the API timed out. The Payroll Agent refuses to play at all because its security group mapping was built by a contractor who left in 2021 and took the documentation with them.

The employee, who just wanted to know their PTO balance, closes the browser and calls Barb in HR.

That's what orchestration looks like when the instruments aren't tuned. And the instruments are almost never tuned.

The Obligatory "Yes"

I'm going to give Bersin his due because I'm a professional and my mother raised me right (mostly).

He's correct that agents will need to talk to each other. He's correct that someone needs to think about how a recruiting agent and a compensation agent coordinate. If you're an HR Tech leader and this hasn't crossed your mind yet, his piece is a useful nudge.

There. That's the "yes." It took three sentences. That's all it gets.

Integration Architecture in a Tuxedo

Here's what the analysts will never tell your CHRO, because it doesn't fit on a keynote slide:

"Orchestration" is a very expensive new word for something we've been doing (badly, painfully, thanklessly) for over a decade. API routing. Error handling. Payload management. Security mapping between systems that were designed by separate teams who have apparently never spoken to each other.

We've talked before about how AI Agents are essentially highly caffeinated Digital Interns. You give them an objective and pray.

Bersin is now selling your CHRO a Digital Middle Manager to supervise the Digital Interns.

Think about that. Think about every middle manager you've ever had. Now make them artificial. Now make them artificially intelligent. Now give them access to your Workday tenant.

Sleep well tonight.

The Double Integration Tax

Here's where I need you to put your architect hat on, because this is the part your executives will never understand from a Substack article written at cruising altitude.

Deploying a single AI agent already costs you an Integration Tax. You have to govern the API, secure the data, build the leash, and monitor the outputs. That's real work. That's months of your life you're not getting back.

Deploying an Orchestration Layer on top of those agents? That's a Double Integration Tax. Now you have to govern the AI that governs the AI. You need logic that tells the Orchestrator when to hand off a payload. What to do when the receiving agent is down. How to handle security mappings when an employee asks a cross-functional question that spans Workday compensation data and ServiceNow ticket history.

That's not a solved problem. That's two unsolved problems stacked on top of each other in a trench coat, and Bersin just pointed at them and said "look, a solution."

The IBM Example (Featuring a Ten-Year-Old Receipt)

Every good sales pitch needs a case study. Bersin's is IBM.

He describes a compensation agent that IBM built over many years. Eventually, the agent got smart enough to tell managers what an employee's raise should be. Bersin writes about it with genuine admiration, which is fair. That's legitimately impressive engineering.

Here's where it falls apart.

It took a decade. At IBM. A company with essentially unlimited engineering resources and an existential financial motivation to prove their own AI products work. IBM didn't build that agent because they read a thought leadership article. They built it because they are the thought leadership article.

And the kicker — Bersin himself writes that he's not fully up to speed on IBM's current system and plans to reach out for an update.

Time out. Pause, rewind.

His flagship case study for why you should reorganize your HR technology architecture is a project he has not verified is still running in its current form.

That's like writing a restaurant review based on a meal you had in 2016 and adding "(will call to confirm they're still open)" at the bottom. It's not a case study. It's a memory.

The Sentence That Should Have Its Own Legal Review

Okay. This is the part where I need everyone to stop multitasking and pay attention.

Deep in the article, Bersin describes a scenario where a recruitment agent and a compensation agent negotiate a candidate's salary. He writes — and I wish I were making this up — that "perhaps no human is involved."

He then proceeds to the next paragraph.

He doesn't stop. He doesn't caveat. He doesn't even take a breath. He describes autonomous AI agents deciding a human being's salary with zero human oversight, and treats it like a fun hypothetical on the way to his next point.

Let me describe what actually happens in this scenario.

Your legal team has a collective aneurysm. Your OFCCP audit becomes a five-alarm fire. Your pay equity analysis is now being generated by a system making lateral compensation decisions that no human reviewed, approved, or can explain. And when (not if) an adverse impact pattern surfaces — and it will, because the training data has the same biases your historical decisions had — you get to sit across from a federal investigator and explain that two chatbots negotiated someone's livelihood while everybody was at lunch.

That's not bold futurism. That's malpractice cosplaying as vision.

You do not get to drop that sentence into a thought leadership piece and just keep going. That idea deserves its own article, its own legal review, its own ethics board, and frankly, its own therapist.

The Infomercial

We need to talk about the business model, because it's the key to understanding why this article reads the way it does.

Bersin plugs Galileo three separate times. He mentions his Irresistible conference twice. He references his podcast. He even has a bold section header that reads "You Are The Consultant Now," which is a genuinely inspiring sentence until you reach the next paragraph, where he sells you his consulting product.

Let me repeat that. He tells you that you don't need consultants anymore. Then sells you a consulting tool. In back-to-back paragraphs. With a straight face.

The article literally creates the anxiety and then sells you the aspirin. "Your architecture is falling behind! The future is autonomous! You need orchestration now! ...And our platform can help. Contact us."

That's not thought leadership. That's a very well-written ShamWow pitch. But instead of cleaning up spills, it's cleaning up the executive panic it just created.

(Look, I get it. The man has a business. He's going to sell it. But we can at least acknowledge that this isn't a research paper. It's a funnel.)

How to Handle Monday Morning

When (not if) the Bersin article lands in your inbox with "Thoughts?" in the subject line, here's your play. Don't sigh. Don't get defensive. Don't trash it. Don't forward them this article (unless you're job hunting). Put on your calmest, most credible architect voice and reply with something like this:

"Thanks for flagging. Bersin's right that orchestration across AI agents will matter as the ecosystem matures. However, orchestration is fundamentally a routing and decision layer that sits on top of existing data and business rules. It's only as good as what's underneath it. Before we invest in a conductor, we need to make sure the instruments are tuned. Our current priority is solidifying our data foundation, cleaning up job architecture, and documenting our business rules so that when we do activate orchestration capabilities, they execute real workflows instead of automating error messages. Happy to walk you through where we are in a 30-minute sync."

Firm. Credible. No panic. No FOMO. And you just bought yourself six months.

The Bottom Line

Josh Bersin is describing a real destination. He usually does. The man is excellent at painting the skyline.

He's just never been the one pouring the concrete.

The gap between his vision and most practitioners' reality isn't a gap. It's the Schuylkill Expressway at 5 PM — everybody can see where they need to go, nobody's moving, and at least three people have made questionable lane changes that are about to ruin everyone's evening.

The bridge across that gap isn't orchestration frameworks. It's not Superagents or autonomous salary negotiations or whatever Galileo is selling this quarter. It's the boring, thankless, deeply unsexy foundational work that never makes it into a keynote.

Clean your data. Fix your job architecture. Document your business rules in human language. Audit your security groups. Untangle your integration spaghetti.

Then come talk to me about who's conducting the orchestra.

Until then, let the analysts sell the sheet music. We have actual instruments to tune.

— Mike

Director HR Tech | Chief Instrument Tuner | Tuba Duct-Taper

P.S. I tried to explain "AI Orchestration" to Justin. I told him it's like being the kid in the group project who has to make sure everyone else actually does their part. He said, "So it's the kid nobody likes who ends up doing everything anyway." I said yeah, buddy. That's literally my job. He thought about it for a second and said, "That's kind of sad, Dad." Then he asked if he could have $10 for another skin. I gave it to him. Because at least his purchase doesn't require an integration tax.

There are certain pieces of feedback that don't just bounce off. They leave a bruise.

Mine came during a one-on-one when a manager looked me in the eye and told me I “wasn't strategic enough.”

If you've ever heard that phrase directed at you, you know what it actually means. It means: you're a tool operator, not a thinker. You're the person we hand tasks to, not the person we ask for direction.

It is a complete dismissal of everything you think you bring to the table, delivered in three words that sound almost clinical.

It hurt. And it didn't just push me out the door of that organization — it lit a fire.

The Spite-Driven Enterprise

That's the secret origin story of The Department of First Things First.

When I launched this blog, I was not trying to be a benevolent mentor to the HR Technology community. Let me be honest about that. This was a purely spite-driven enterprise. Every post, every hot take, every architectural teardown was a broadcast into the universe saying, "Look at how incredibly strategic I am."

Spite is an unbelievable starter motor. It will get you off the couch. It will make you outline articles at midnight. It will force you to sharpen your arguments until they're bulletproof, because when you want to prove someone wrong, you leave no stone unturned.

Spite got me to publish when I had every reason not to. Spite built the habit.

But spite is a terrible long-term engine. It burns incredibly hot, and then it just…burns out. You can't sustain a career or a platform by being the person who loudly points out why everything is broken.

The Engine Swap

I can actually pinpoint the exact moment my fuel changed.

I wrote a post about Sana's UI layer: A hot take on whether the experience layer was real product innovation or just expensive frosting on someone else's cake. I published it, figured a few Workday people would nod along, and went to bed.

By morning, it had gone viral. Well…viral for a substack with 10 subscribers. Forty-one new subscribers in a week. My inbox was full, and the messages weren't what I expected. Nobody was writing to say, "Great rant." They were writing to say, "I just used your framework to push back on a vendor proposal," and "I forwarded this to my CIO because we're evaluating this exact architecture."

People were actually using my thinking to build things.

I sat with that for a while. And somewhere in that stretch of reading those messages, the ghost of that one-on-one finally left the room. Not because I'd proven her wrong - but because I'd stopped caring about proving her wrong. I genuinely just liked helping people architect. Turns out that's what being strategic actually looks like.

Nobody told me. I had to build my way to it.

The Real Fuel

If you're currently running on spite because someone told you that you weren't enough — use it. I mean that. Let it start the engine. Let it propel you out of a bad situation. Let it get you to publish the first post, send the first email, raise your hand for the first time

But the moment you have momentum, swap the fuel.

Stop trying to prove them wrong. Start trying to build something right. The difference between a critic and an architect isn't talent. It's what's driving the engine.

Mine runs on something different now. That's why I'm still here.

— Mike | The Department of First Things First

Josh Bersin dropped a piece this week called "Layoffs at Atlassian, Block, Amazon are Misleading. AI Alone Is Not The Story."

I read it twice. The first time I nodded along. The second time I started highlighting the parts that made my eye twitch.

And look; I want to be clear about something. I'm not here to dunk on Josh Bersin. The man has forgotten more about HR than most of us will ever learn. His "Talent Density" framing is genuinely useful. His point that companies overhire during growth and then blame AI for the correction? Dead on. That's not an AI story. That's a management story wearing an AI costume.

(It's like when your kid breaks a lamp and blames the dog. The dog was in the room, sure. But the dog didn't throw the football.)

Where it gets complicated is when Josh moves from macro-level workforce commentary into the specifics of how AI actually works inside a recruiting stack. Because that's where the altitude starts to show.

The Bias Blind Spot

Here's the line that stopped me cold:

Josh writes that AI recruiting tools "reduce bias (they don't care what someone looks like or their college degree, unless you tell them to)."

Hang out with that for a second.

This framing treats AI bias like a settings toggle. Like somewhere in the admin console there's a checkbox that says ☑️ Be Racist and as long as you don't click it, you're fine.

That's not how this works. That's not how any of this works.

Agentic AI doesn't need to be told to discriminate. It correlates patterns. If your historical hiring data shows that candidates from certain zip codes, with certain speech cadences, or with gaps in their resume tend to get screened out — the AI will learn that pattern and execute it at scale. Not because anyone told it to. Because that's what the data said to do.

A biased human recruiter might impact a dozen reqs. A biased autonomous agent will flawlessly execute that parameter across 10,000 applications before your analytics team has their morning coffee.

Josh is right that AI doesn't care what someone looks like. But it absolutely cares about every proxy variable that correlates with what someone looks like. And at enterprise scale, that distinction isn't academic. It's a lawsuit.

The Supervision Myth

Josh cites the Amazon VP story — where an AI executive eliminated 16,000 positions in a single quarter and then had to rehire people to supervise the AI when bug rates spiked and escalations piled up. Here's his Twitter/X post:

Josh presents this as evidence that humans remain essential. Which, yes. Obviously. But he breezes past the part that should terrify every HR technology leader reading his newsletter: they built the plane while flying it and had to rehire the mechanics mid-flight.

That's not a success story. That's a governance failure with a happy-ish ending.

And then Josh says the quiet part: in recruiting, the roles that get eliminated aren't the "high-value recruiters" but the interview schedulers, job posting admins, and advertising coordinators.

He frames this casually. Like those roles are just friction to be automated away. But those roles are also the humans who catch errors. The scheduler who notices the interview is booked for a location that closed last week. The admin who flags that a job posting has the wrong salary band. The coordinator who realizes the AI sent a confirmation to a candidate whose application was actually rejected.

When you remove the human middleware and replace it with an autonomous agent, you'd better have governance in place…because no one is catching the 2 AM mistakes anymore.

(I wrote about this yesterday in The Agentic Leash. I call it Schrödinger's Candidate. The AI tells the applicant they have an interview Tuesday at 9 AM. The API drops the payload. The store manager's dashboard is empty. The candidate exists and doesn't exist at the same time. It's fun as a thought experiment and deeply terrifying as a Tuesday morning in your Workday tenant.)

The Justin Postulate

Justin (11) has become the unofficial UX tester for this newsletter. I run things by him not because he understands enterprise architecture, but because he has the attention span and patience level of the exact demographic these AI tools are trying to hire.

So I explained the Bersin thesis to him at dinner. I said: "A really smart guy says AI won't replace recruiters, it'll just make them faster and better."

Justin thought about it for a second and said: "So it's like giving a kid a power washer. It cleans the walkway way faster. But if nobody's watching, he's definitely going to spray the dog."

I don't have a rebuttal for that. I think that's the whole article.

(Some context: Justin earned $20 power washing our front walkway last month before the cold snap. If anyone is interested in the Ring video evidence, DM me.)

The Ground-Level Truth

Here's what I agree with Josh on: AI transformation is primarily about quality and scale, not mass job elimination. The McDonald's and 7-Eleven time-to-hire numbers are real. The productivity gains are real. I just spent a week at IAMPHENOM watching demos that genuinely impressed me. This technology is necessary and it's coming whether we're ready or not.

But "the jobs don't go away, they just change" is an analyst's framing. On the ground, what's actually happening is that the risk profile of those jobs is changing dramatically. We're not replacing recruiters with robots. We're replacing guardrails with algorithms and hoping the algorithms don't spray the dog.

Josh says the ROI isn't about laying off recruiters. He's right. The ROI is about hiring faster, staffing better, and improving quality. But the ROI collapses the moment your autonomous agent hallucinates a sign-on bonus, introduces bias at scale, or creates a candidate that exists in the AI's memory but is invisible to your ERP.

The vendors are building the AI. Josh is narrating the transformation from the skybox.

Some of us are down here building the leash.

— Mike | The Department of First Things First

P.S. — I told Justin that Josh Bersin has been studying HR longer than I've been alive. Justin said, "So he's like the Wikipedia of work?" Not inaccurate, kiddo. But sometimes you need someone who's actually done the homework, not just read the encyclopedia.

If you want to understand the reality of high-volume hiring, you have to understand the "Justin Test” from last week.

My 11-year-old son recently downloaded a game on his iPad. He opened it up, was greeted by a screen demanding he create an account and verify an email address, stared at it for exactly four seconds, and deleted the app.

Your applicants are doing the exact same thing.

A 19-year-old sitting in their car on a 15-minute break does not have the patience to navigate a native ERP "Candidate Home" wall of death. If there is friction, they are simply walking across the street to work for your competitor.

To survive this reality, the HR tech industry is making a necessary pivot. We are officially leaving the era of chatbots behind and entering the Agentic Era. We aren't just buying software tools anymore; we are deploying autonomous Voice Agents and SMS Concierges that can screen candidates, evaluate answers, and schedule interviews while we sleep.

I just spent a week on the vendor floor looking at this technology. It is a brilliant, frictionless solution to the volume problem.

As an enterprise HR Technology architect, it also terrifies me.

The Difference Between a Tool and a Colleague

For the last few years, AI in HR has been a power drill. It's fast, it's efficient, but it sits quietly on the workbench until a human pulls the trigger (like generating a job description).

Agentic AI is an eager, highly caffeinated intern. You give it an objective: "Go hire three pharmacy techs" - and it executes the workflow on its own. It talks directly to external candidates, makes micro-decisions, and owns your calendar.

And that is where I see enterprise risk.

If a traditional chatbot fails, a candidate gets a frustrating error code. But if an autonomous Agentic AI fails, the blast radius could be…enormous.

The Architect's Nightmares

When you hand the keys to your Digital Intern, you are introducing three vulnerabilities into your enterprise plumbing:

1. Hallucinations with Authority

Generative AI is inherently built to please. What happens when a candidate asks your Voice Agent, "Does this role pay $20 an hour?" and the AI cheerfully says, "Yes, absolutely!" when the Workday requisition is only budgeted for $15? You didn't just give a bad answer; your autonomous agent just created an immediate legal liability and a broken promise before the candidate even talks to a human.

2. Schrödinger's Candidate

Your Conversational Agent is the frictionless frosting. Your core ERP is the dense compliance sponge. The moment that Voice Agent finishes its interview at 2:00 AM, it has to execute a flawless baton pass via API.

If your foundational data is messy, or the payload drops, you get Schrödinger's Candidate. The AI told the applicant they have an interview on Tuesday at 9:00 AM. But because the API failed, your store manager's dashboard is completely empty. The candidate exists in two states at once: interview ready in the AI's mind, and entirely invisible to the business.

3. Systemic Bias at Scale

If a human recruiter has an unconscious bias, it might impact a dozen reqs. If your autonomous agent starts correlating "good candidates" with a specific speech pattern, hesitation metric, or demographic marker, it won't just make one bad hire. It will flawlessly execute that biased parameter across 10,000 retail applications before your analytics team even realizes what happened.

Building the Leash

We have to adopt this technology. The hiring reality demands it. When your average time-to-apply needs to be measured in seconds, not minutes, there is no going back.

But our jobs as HR technology leaders have fundamentally changed. We are no longer just API mappers and implementation managers. Our new mandate on our neverending list is Agentic Governance.

The vendors are building the AI. It is on us to build the leash.

That means designing the exact, uncompromising thresholds where the Digital Intern is forced to stop, lock the process, and say, "I need to go ask my human manager." It means compensation guardrails that hard-block any promise outside the req range. It means integration circuit-breakers that halt the workflow when the baton pass fails instead of letting the AI keep running. And it means bias audit loops that don't wait for quarterly reviews—they flag in real time.

This is unglamorous work. Nobody puts "I built a kill switch" on a conference slide. But it is the work that will separate the organizations that thrive in the Agentic Era from the ones that end up in the headlines.

Buy the frosting. Love the innovation. But protect your sponge at all costs.

Because if your Digital Intern can't pass the same test as a $15/hour human recruiter: Explaining the role accurately, treating candidates fairly, and showing up in the system of record—then it isn't saving you time. It's manufacturing risk.

The Agentic Era is here. Build the leash before you need it.

— Mike | The Department of First Things First

P.S. — I showed Justin the Phenom Voice Agent demo. He said, "So it's like if Siri actually worked?" Honestly? Yeah, kid. That's kind of the point. And kind of the problem.

We have a mandate to hire retail workers in hours, not weeks. Workday’s native UI, built for corporate compliance, is fundamentally misaligned with this kind of retail velocity for both the candidate and hiring manager.

The solution is the "Layer Cake": Phenom is the frosting on both sides (frictionless UI for candidates, AI agents for managers) and Workday is the sponge (the dense, structured compliance data).

Yes, connecting them creates an "Integration Tax," but I will gladly pay it to stop candidates from abandoning our application and to stop our managers from tearing their hair out.

I am writing this right before I take to the floor of the Philadelphia Convention Center.

Next week is IAMPHENOM. For me, it is a homecoming. I was an early Phenom employee back in the days when "All Hands" meant ordering three pizzas. Heck, when I joined, we were called iMomentus. But I return this week wearing a very different hat: The Customer. As a Sr. Manager of HR Tech Engineering for a massive retail and pharmacy enterprise, I am caught in the ultimate architectural holy war: The Suite vs. Best-of-Breed. Workday wants you to use Workday Recruiting for everything. Phenom wants you to buy their Experience Layer to sit on top of it.

Who is right? To answer that, you have to look at the sheer, unyielding physics of High-Volume Hiring.

Recently, my team was handed a massive mandate: Get a retail candidate from "Apply" to "Offer Accepted" in hours, not weeks.

If a corporate Director takes four days to schedule an interview, that’s normal. If a Pharmacy Manager takes four days to schedule an interview with a tech, they are already working for the competition across the street.

The Candidate Problem: The "Justin" Usability Test

Last week, my 11-year-old son, Justin, wanted to play a new game on his iPad. He downloaded it, opened it, and was immediately hit with a screen asking him to create an account, verify his email, and set up a profile. He stared at it for exactly four seconds, deleted the app, and went back to playing Roblox.

Justin isn't lazy; he just has zero tolerance for unnecessary friction. He expects an Amazon-like experience.

Now, imagine Justin is a 19 year-old pharmacy tech applicant (it’s only 8 years from now - and now I’m having an existential crisis). He’s sitting in his car on a 15-minute break from his current job. If we hit him with the native "Candidate Home" compliance gate (forcing him to create an account, remember a password with a special character, and click through several pages of EEO questions) he doesn't submit a support ticket. He closes the tab. He walks across the street.

The Manager Problem: Doing Taxes While Running a Sprint

But the friction isn't just at the front door. We tried to bake this entire hire-in-hours process natively in Workday, and it broke down right at the beginning, on the manager side.

Workday is a system built by compliance lawyers for corporate recruiters. It wants a paper trail. It does not want you to hire a cashier in hours.

We were expecting a Store Manager, who is actively managing a pharmacy line and covering a register, to log into a heavy corporate ERP, navigate a supervisory org hierarchy, and execute a "Start Job Requisition" business process (which we massively simplified). Asking a retail manager to use native Workday to hire someone quickly is like asking them to fill out a supply chain procurement form just to order a pizza.

The Dual-Sided Layer Cake

To hit the goal of hiring in hours, we had to rethink the architecture. We built a "Layer Cake."

Workday is the sponge. It’s dense, it’s structurally sound, and it keeps the company from getting sued. But nobody wants to eat a dry sponge cake.

So, we put Phenom (the frosting) on both sides of the cake:

The Candidate Frosting: We replaced the mortgage application with an Amazon-like, frictionless front door. SMS applications, conversational AI, and zero forced account creation.

The Manager Frosting: We shielded the retail managers from the Workday UI entirely. We deployed Phenom's Job Requisition Agent and Hiring Manager portals. The manager just says, "I need a cashier," and the AI agent handles the heavy lifting, scheduling, and screening. We put a "Human in the Lead," but we gave that human a power-tool instead of a bureaucratic checklist.

And the most crucial architectural pivot? We kept the Offer Acceptance inside Phenom. If you give a candidate a beautiful 3-minute SMS application, but then force them to create a Workday Candidate Home account just to click "I Accept" on the offer, you’ve ruined the magic. It’s like ending a Michelin-star meal by making the customer wash their own dishes.

Keep them in the frosting until the deal is closed. Then the API fires, and they drop into the Workday cake for background checks and compliance.

The Pragmatic Architect's Verdict

As an architect, I love the "Power of One." I want everything in one system to keep my diagrams clean.

But layering Phenom over Workday creates an "Integration Tax." You have to monitor APIs and manage two vendor roadmaps.

Is it worth it? Yes. I will gladly pay that tax every single day to stop our candidates from abandoning our funnel and our managers from losing their minds. Our job isn't to force the business to use native functionality just because it's already paid for. Our job is to build a resilient bridge between the system of engagement and the system of record.

Now, if you'll excuse me, I need to go find Mahe and ask him about my API limits.

— Mike

Department Director, HR Tech | Keeper of the layer cake

Josh Bersin published a piece today arguing the market is irrationally punishing enterprise software (like Workday) over AI fears.

• He is right that an AI agent cannot replace a core HRIS because payroll and compliance must be deterministic.

• However, the "decades of business rules" he points to as a protective moat are exactly what make the native UI unbearable for high-volume hiring.

• The future isn't AI replacing the ERP. It is AI hiding the ERP from the user completely.

Josh Bersin dropped a great piece this morning pointing out a massive disconnect in the stock market: tech giants building AI infrastructure are soaring, while enterprise software stalwarts like Workday, SAP, and Salesforce are getting punished.

The prevailing market narrative is that AI agents are going to eat the ERP.

Bersin correctly calls this out as irrational. You cannot just point Claude at a Workday tenant and say, "rebuild this." He quotes Aneel Bhusri, who hit the nail on the head: AI is non-deterministic. Enterprise software must be deterministic. If you are running payroll for 300,000 employees, you cannot have an LLM creatively hallucinating someone's tax withholdings.

The math has to be absolute:

Bersin argues that these enterprise systems are protected by a massive, impenetrable moat built on "decades of industry business rules, financial workflows, and HR... processes."

He is absolutely right about the moat. But viewing this entirely from 50,000 feet misses the reality on the ground.

For the people actually using the system, that moat feels like a ten-lane tollbooth.

Those decades of deep, complex business rules are exactly why a 19-year-old applying for a pharmacy tech job abandons the native "Candidate Home" login screen after four seconds. It is exactly why a retail manager covering a cash register wants to throw their laptop out a window when forced to execute a 14-step "Create Job Requisition" business process (or even a 4-step “Start Job Requisition” process).

We have reached a tipping point where the structural integrity of the database is actively at war with the required velocity of the business:

This is why the market should be at least a little spooked.

The disruption coming for enterprise software isn't that AI will replace the database. It is that AI is going to completely bypass the UI.

Instead of forcing users into the ERP, Pragmatic Architects are moving toward decoupled architectures. We are actively buying Experience Layers (like Phenom and their AI agents) to sit directly on top of the core system. We willingly pay an "Integration Tax" to build a frictionless, consumer-grade front door so our retail candidates and busy managers never have to interact with the heavy, compliance-driven native system.

(I'll be diving deep into the exact mechanics of how we architect this separation in a few weeks after IAMPHENOM, but the philosophy is already steering our roadmap).

Enterprise software isn't going anywhere. We will always need the deterministic engine to keep us out of jail and make sure the paychecks clear.

But if the big vendors think their "decades of business rules" are enough to keep users happily logging into their native platforms, they are kidding themselves. The future of HR Tech is the ERP becoming headless infrastructure, buried so deep under AI agents and conversational interfaces that the end-user forgets it even exists.

— Mike

Director HR Tech | Pragmatic Futurist

Last week, a reader sent me a message that perfectly captures the mid-career HR Tech existential crisis:

"Mike, I've been a Workday Analyst for years. I know the config inside and out. I can build complex calc fields in my sleep. But how do I actually make the jump to Solutions Architect?"

If you’ve spent the last decade deep in the Workday trenches, you know the feeling. There is a very specific, god-tier thrill that comes from untangling a hopelessly knotted calculated field, executing a flawless EIB, or finally getting that complex condition rule to fire perfectly on the first try.

My answer to them was simple: The hardest part of the transition isn't memorizing the latest release notes or learning a new module. It’s the psychological shift. You are no longer the master builder; you are the city planner. And frankly, that adjustment is jarring.

Here is what that transition actually looks and feels like:

The Muscle Memory Trap

For the first six months, your own instincts will betray you. When a broken process lands on your desk, your muscle memory will scream at you to log in, roll up your sleeves, and fix it in ten minutes. As an architect, you have to fight that urge. Your job is no longer to turn the wrench. Your job is to guide, mentor, and trust your analysts to do it. It requires a tremendous amount of discipline to sit on your hands and keep them off the keyboard.

Trading the Keyboard for the Gavel

Welcome to the "herding cats" phase of your career. You are no longer just building a single house; you are heading up the zoning committee. You will find yourself in rooms with several different functional VPs—Talent, Payroll, and Finance—who all have fiercely competing priorities and want to build extensions on the exact same property. Your primary function is to get them to agree on the property lines. You are the referee, the mediator, and the ultimate guardian of the system's scalability.

Chief Translation Officer

The most critical skill in your new arsenal isn't knowing the exact syntax of a business process definition. It is the ability to translate complex, interwoven Workday architecture into plain English. When an executive asks for a "simple" new dashboard, you have to look them in the eye and calmly explain why their "simple" request will actually create a downstream data apocalypse for the Integrations team. You are the bridge between executive ambition and technical reality.

The Kitchen Table Reality Check

How do you know if you've actually made the leap from analyst to architect? Try the kitchen table test. Sit down at dinner and try explaining the business impact of your latest design to a normal human. I use my 11-year-old son, Justin. If I can make it make sense without using the words "reference ID," "calc field," or "EIB," I'm acting as an architect. If I'm just listing off configuration steps and tenant setups, I'm still stuck in the analyst mindset. Architecture is about translating system design into real-world business value.

The Instant Gratification Desert

Because you aren't closing out configuration tickets every day, the instant gratification is gone. The quick wins are spread much further apart. You have to learn how to redefine success. Your new "win" is looking at a beautifully designed, scalable, cross-module blueprint that you fought tooth and nail to get approved—knowing it will keep the system running smoothly for the next five years. It is delayed gratification in its purest form.

The Bottom Line

Stepping into an architecture role means accepting that your hardest days will no longer be about the technology itself. They will be about the people, the politics, and the processes that surround the technology.

If you can let go of the instant gratification of the tenant and master the art of the blueprint, the impact you make won't just solve a single ticket; it will resonate across the entire enterprise.

— Mike

Director HR Tech | Reformed Wrench-Turner

​

In HR Tech, there is a universal law: The stakeholders with the smallest requests usually scream the loudest.

​You know the type. They submit a ticket at 4:55 PM on a Friday marked “URGENT / CRITICAL.”

You panic. You open the ticket.

The Request: “Can we change the label on this report from ‘Employee ID’ to ‘Worker ID’? The VP needs it for a meeting on Monday.”

​This is not Urgent. This is Annoying.

​But if you don’t have a framework to push back, you end up treating it like a fire. You burn out your team fixing fonts while the actual fires (like Payroll integrations) go unnoticed.

​In the Department of First Things First, we Triage.

​The Tear Sheet: The Department Matrix

​I adapted the classic Eisenhower Matrix for Workday Leaders. Print this out. Tape it to your monitor. When a stakeholder walks in, point to it.

​The Two Axes:

1. ​Impact: Does this stop people from getting paid, hired, or compliant? (High/Low)

2. ​Urgency: Is the deadline driven by a law/regulation, or just because you “want it”? (High/Low)

​Quadrant 1: The Fire (High Impact / High Urgency)

• ​Example: The Payroll integration failed. The CEO can’t log in.

• ​Action: Drop Everything. This is a true P1. Fix it now.

​Quadrant 2: The Strategy (High Impact / Low Urgency)

• ​Example: Implementing the new Advanced Comp module. Cleaning up Job Profiles.

• ​Action: Schedule It. This is the deep work. Protect this time on your calendar, or Q1 will become Q1 (The Fire).

​Quadrant 3: The Noise (Low Impact / High Urgency)

• ​Example: “The VP needs this report for a meeting in 10 minutes.”

• ​Action: Delegate or Push Back. This is the “Trap.” It feels urgent, but it adds zero long-term value. Automate this report so they stop asking you.

​Quadrant 4: The Trash (Low Impact / Low Urgency)

• ​Example: Changing button colors. Adding a 5th approval step “just in case.”

• ​Action: Delete. Put it in the backlog to die. If they don’t ask about it again in 3 months, close the ticket.

​The Kitchen Table Reality

​My son Justin is the king of Quadrant 3 (The Noise).

​Justin (Running into the room): “DAD! IT’S AN EMERGENCY!”

Me: “Is the house on fire? Is the dog hurt?”

Justin: “No! The Minecraft server is updating and I can’t log in for 10 minutes!”

​The Audit:

• ​Impact: Zero. (In fact, positive impact, as he might go outside and practice his serve).

• ​Urgency: High (to him).

​Me: “Justin, that is a Quadrant 3 issue. It feels loud, but it doesn’t matter. Go read a book.”

​He didn’t like the triage. But he survived the outage.

​The Takeaway

​Your capacity is finite. Every minute you spend on The Noise (Q3) is a minute you steal from The Strategy (Q2).

​Stop letting other people’s lack of planning become your emergency. Use the matrix.

​— Mike

Director HR Tech | Chief Triage Officer

​P.S. If you mark a ticket as “Critical” and it turns out to be a font change, I am legally allowed to move all your future tickets to Quadrant 4 (The Trash).

We need to talk about Technical Malpractice.

It usually happens at 2:00 AM. A payroll integration fails. You open the error logs. You dig into the code that your expensive implementation partner wrote three years ago.

And there you find it. The smoking gun.

<xsl:if test="cc='100-2495'">

They hardcoded a specific Cost Center ID directly into the logic.

Why did they do it? Because three years ago, that was the only Cost Center that needed the special tax rule. It was fast. It was easy. It worked for the deadline.

But today, you reorganized. That Cost Center doesn't exist anymore. And because that logic is buried in the code (not in a configurable table) the system didn't just break; it exploded.

In the Department of First Things First, we have a rule: Data drives Logic.

If you are writing specific IDs, names, or dates into your code, you aren't building a system. You are building a trap.

The "Consultant's Shortcut"

Hardcoding is the "Sugar" of the Workday ecosystem. It gives you a quick rush of energy (the integration works instantly!), but it leads to a massive crash later.

Consultants often love hardcoding because:

Speed: It saves them the 15 minutes of creating a Launch Parameter or an Integration Attribute.

Job Security: When business requirements change next year, you can't fix it. You have to call them back (at $250/hour) to open the code and change '100-2495' to '100-2496'.

That isn't a partnership. That is a subscription to mediocrity.

The Fix: Abstract Everything

If you are a Product Owner or Architect, I want you to open your studio integrations or your advanced calculations and look for "Magic Numbers" (specific IDs).

If you see them, rip them out.

The First Things First Standard:

Never put a specific value in the code.

Always put it in a Launch Parameter, an Integration Attribute, or a Lookup Table.

If the rule changes, a functional analyst should be able to update the table in 30 seconds. They should not need to deploy a new .clar file.

The Kitchen Table Reality

I caught Justin committing "Physical Hardcoding" this weekend.

He was building a massive LEGO fort. It was impressive. But then I noticed he had a bottle of my expensive, BSI Super Glue.

Me: "Justin, what is the glue for?"

Justin: "The tower kept falling over when Toby (the yellow dog) walked by. So I glued the bricks together. Now it's sturdy."

Me: "That is true. It is very sturdy. But what happens when you want to turn the fort into a spaceship next week?"

Justin: "I can't. It's a fort forever now."

Me: "Exactly. You have hardcoded the bricks, and you’ve glued your fingers. You have committed the ultimate sin of LEGO. Now luckily your dad has some super glue un-cure around here. Let’s get your fingers unstuck, but the solvent will melt your LEGOs."

He stared at the glued bricks, followed by his fingers. He realized the permanence of his decision.

Justin: "Can we buy new bricks?"

Me: "No. You must live in the fortress you glued."

The Takeaway

Hardcoding feels like stability in the short term. "It just works!"

But your business is not a glued-together fort. It is a living thing. It changes. It reorganizes. It acquires (and divests) companies.

If your code is glued together with hardcoded logic, you cannot pivot. You can only break.

Audit your code. Remove the glue. I know there’s some un-cure around here somewhere.

— Mike

Director HR Tech | Chief LEGO Architect

P.S. If you are a consultant and you hardcode a worker's name (e.g., Advisor = 'Steve') into a business process condition rule... I will find you. And I will make you fix it for free.

​Aneel Bhusri is back as CEO.

​For the last few years, Workday was run by Carl Eschenbach. Carl is a world-class operator. His job was to scale revenue, sell more SKUs, and make the stock price go up. He did that.

​But for those of us in the trenches—the people actually configuring the Business Processes—the product has felt… drifted. We got more acquisitions (HiredScore, Evisort) and more “AI” marketing fluff, but the core object model felt like it was taking a backseat to the deal cycle.

​Aneel is not a sales guy. He is a Product Founder. He is the original architect.

​He didn’t come back to referee a QBR. He came back because he believes AI is a bigger shift than the Cloud, and he knows you can’t survive a platform shift with “Shelfware.” You survive it with Engineering.

​Here is what the Department of First Things First predicts for the “Aneel Era” (and why we are bullish):

​1. The “Vaporware” Pipeline Will Slow Down

​Under a Sales-Led regime, the roadmap is driven by “What do we need to demo to close the deal in Q4?” This leads to features that look great on a slide but break in Production.

• ​The Shift: Aneel is an engineer. Expect the roadmap to get boring.

• ​The Win: “Boring” is good. “Boring” means fixing the performance issues in the calc engine instead of launching another half-baked “Talent Marketplace” widget. We might get fewer new toys, but the toys we have might actually work.

​2. AI Goes from “Marketing” to “Native”

​Workday has been shouting “AI” for two years. But mostly, it’s been bolt-on copilots and acquired tech stacks (like Sana Labs).

Aneel’s mandate is clear: Native AI.

• ​The Shift: He is going to force a refactoring of the underlying data model to support AI natively.

• ​The Risk: This is going to be painful. He might break things to fix them. Expect forced migrations to new data structures in late 2026. But it’s necessary surgery.

​3. The “Partner” Crackdown (We Can Dream)

​Founders are protective of their code. Hired CEOs love Implementation Partners because they drive revenue. Founders hate them because they bastardize the product.

• ​The Prediction: We might finally see a crackdown on the “Consultant Industrial Complex.” Aneel knows that if a partner hardcodes a solution and it breaks in 6 months, the customer blames Workday, not Deloitte.

• ​The Hope: If Aneel starts decertifying partners for bad architecture, I will personally fly to Pleasanton and buy him a beer.

​4. The “Founder Mode” Reality Check

​A professional CEO tries to keep the stock price smooth. A Founder CEO doesn’t care about next quarter; he cares about next decade.

• ​The Impact: Expect Workday to be more honest about Technical Debt. They might kill off legacy features faster than we want, because Aneel isn’t afraid to force modernization to save the platform.

​The Verdict

​The party (Sales) is over. The renovation (Engineering) has begun.

​For the Department of First Things First, this is the best possible news. It means our obsession with Architecture, Data Governance, and Fundamentals is now perfectly aligned with the vendor’s new direction.

​We aren’t just shouting at the clouds anymore. The CEO is finally listening to the architects again.

​— Mike

Director HR Tech | Croc-wearing enthusiast

​P.S. To the Sales Rep who just promised my CHRO that “AI Agent” will solve our dirty data problem: Aneel is watching you. And so am I.

When employees don't use the system, we blame them. We say they are "resistant to change." We schedule more training sessions. We write longer PDFs with arrows pointing to buttons.

But last weekend, I ran an experiment that proved the problem isn't the user. The problem is us.

The Experiment

My son, Justin (11), wanted to skip his Saturday chore (emptying the dishwasher) to go hang out with a friend.

Me: "I am open to this request. But you need to follow proper procedure. Log into the 'Household ERP' (a GMS tenant) and submit a Time Off Request."

I sat him down in front of my laptop. I gave him no instructions. I just said: "Request one day of vacation."

Justin is a digital native. He can navigate a complex 3D printing slicer, design in CAD, mod Minecraft, and edit video on an iPad without reading a manual. He speaks "Interface" fluently.

The Breakdown

Minute 1: The Search Bar

Justin went straight to the search bar. He typed "Day off."

The System: Returned 42 results.

Create Absence Plan

Absence Calculation Interface

Maintain Time Off type (USA)

Justin: "Dad, what is an 'Absence Calculation Interface'? I just want to not do dishes."

Me: "That’s the backend configuration. Keep looking."

Minute 2: The "Actions" Button

He finally found his profile. He looked for a button that said "Request Time Off." It didn't exist.

He hovered over his photo. Nothing.

He right-clicked. Nothing.

Justin: "Is it broken?"

Me: "No. You have to click the button marked “Actions” (we used to call it a “Twinkie”), then go to 'Time and Time off', then 'Request Time Off'." (We have used some Maintain Custom Labels).

Justin: "Why? That's hiding the thing I want to do inside a menu of things I don't care about."

Minute 3: The Rage Quit

He finally got to the calendar. He clicked Saturday. A modal appeared. Workday now wants a "Reason Code."

He clicked it. The options were: FMLA, Jury Duty, Bereavement, Unpaid Leave.

Justin: "I'm not on a Jury. I'm going to Skyler's house and the park."

Me: "Just pick 'Unpaid Leave'."

Justin: "This app is trash. I'm just going to text Mom."

The Takeaway

Justin identified three failures of Enterprise Design in 180 seconds:

Search Noise: We expose technical configuration to end-users who just want to do a transaction (Workday has improved this, and Justin was in my account with Admin access, but the point still remains).

Buried Actions: We hide the most common tasks (Request Time Off) behind generic "Related Action" menus ("The Twinkie") because we prioritize a clean screen over a functional one.

Mandatory Friction: We force users to categorize things (Reason Codes) that don't need categorization, just because the field exists.

The Audit: How to Fix Justin’s Tenant

Here’s the good news: Workday has released features to solve all three of these problems. If your tenant still behaves like the one Justin audited, that isn’t software failure: that is configuration debt.

Here is how we fix it:

1. Fix the Search (Search Synonyms)

If a user types “Day Off,” they should get “Request Time Off.” Workday allows you to configure Search Synonyms. Map the language your employees actually use (Vacation, Day Off, Hooky) to the business process they need. Stop making them speak HR-to-English. Synonyms can be found in Edit Tenant Setup - Search.

2. Kill the “Twinkie” (Promoted Items)

Justin shouldn’t have to hunt for the Actions button. You can now configure Promoted Items on the Worker Profile. This pulls the most frequent actions (Time Off, Change Address, Payslips) out of the menu and puts them as big, clickable buttons right on the profile header. Sana’s another solution. Workday is clearly moving to Search-as-the-platform and frankly, I’m here for it.

3. Remove the Friction (BP Configuration)

Why did Justin see a “Reason Code”? Well, we have a lot of them.

Ask yourself: Do we actually report on this data?

If Yes: Make it required, and use help text, QuickTips, and Guidance Workspace to help the user make a choice (at a minimum, please!)

If No: Remove the field from the step in Configure Optional Fields, whenever possible.

Stop asking users for data you are just going to ignore.

The "Department" Rule:

If you need to create a "Quick Reference Guide" (QRG) for a self-service transaction, you have failed as an architect.

Don't train the user. Fix the screen.

— Mike

Director HR Tech | Chief UI Critic

P.S. Justin emptied the dishwasher. He said manual labor was easier than navigating the Request Time Off Business Process.

I should be relaxing. Instead, I am stress-eating pretzels and staring at a progress bar that currently reads 87%.

For the last 3.5 days, this machine has been depositing molten plastic to build a complex pair of "Whaleberry" shoes: a rigid white skeleton fused with a flexible "Frozen" blue skin.

If the print fails now—if a nozzle clogs, or the power flickers (happened last week), or a layer shifts by a single millimeter—I don't just lose $60 of filament or the 24 kWh of electricity I’ve pulled from the grid. I lose my son’s vision.

Because here is the raw truth I’m grappling with as I pace the floor: This isn't my project.

The Architect vs. The Sponsor

In my day job as a Director of HR Technology, I am usually the one designing the flow. I know the configurations. I know where the bodies are buried.

But in this basement? I am just the Executive Sponsor.

Justin (11) is the Architect.

He picked the model. He chose the "Frozen" TPU because it looked cool. He decided he needed custom 3D-printed footwear to wear to 6th grade. He has the Vision.

I just have the credit card and the anxiety.

As I watch the nozzle dart around the print bed, I realized this is exactly what it feels like for our business stakeholders during an enterprise implementation.

1. The "Visionary" Doesn't Care About Physics

Justin does not care about "layer adhesion" or "retraction settings." He doesn't care that TPU and PLA are chemically incompatible and require a mechanical dovetail joint to bond. He just wants the shoes to exist.

The Lesson:

This is your VP of HR. They don't care about the API limits or the data transformation map. They have a vision of the "Future of Work." As the Sponsor (me), my job isn't to burden the Architect (Justin) with the physics of why it might fail; my job is to sweat the details silently so his vision doesn't collapse under its own weight.

2. The Illusion of Control (The "Pacing Phase")

We are at hour 84 of 96.

If I touch the printer now, I ruin it. If I try to "optimize" the speed, I’ll cause a clog.

I have to trust the machine.

The Lesson:

This is the "Hyper-Care" freeze. As leaders, we want to do something during deployment. We want to send emails, check dashboards, and micromanage the queue. But the reality is, once you hit "Execute" on the cutover plan, you are no longer the driver. You are the passenger. You have to trust that the infrastructure you funded is robust enough to handle the load.

3. The "Mud" Reality (Go-Live)

This is the part that terrifies me most.

Let’s say this print finishes perfectly. I will peel off the supports, clean up the edges, and present these pristine, engineering marvels to the Architect.

Justin is going to put them on. And then?

He is going to run outside.

He is going to sprint through the snow in the backyard.

He is going to kick a soccer ball into the neighbor's fence.

I am treating these shoes like a museum piece. He is going to treat them like... shoes.

The Lesson:

We build our software in a "Clean Room." We test with perfect data. We assume users will read the Job Aid.

But the User (Justin) lives in the Mud.

The Clean Room: A user follows the script to request time off.

The Mud: A manager tries to approve a compensation change from their phone, with 10% battery, while waiting in line for coffee.

If the shoe falls apart because Justin ran through the mud, the shoe failed, not the boy.

If our system breaks because a manager didn't "follow the process," the system failed, not the user.

The Final Layer

The printer just chirped. We are at 88%.

The Architect is upstairs playing video games, blissfully unaware that his project is hovering on the brink of disaster.

The Executive Sponsor is down here, counting the kilowatt-hours and praying for adhesion.

But that’s the job. We absorb the anxiety so they can have the vision.

Now, if you’ll excuse me, I need to go check the nozzle temperature one more time.