Table of Contents
The software got the process. People got the workarounds.
For thirty years, "designing a business process" has quietly meant "implementing a system." A company bought the ERP, the CRM, the ticketing tool — and the process became whatever the system could do. The org chart adapted to the data model. Teams were retrained around screens. Anything the software couldn't represent got handled the old way, off to the side, in email.
The cost of that inversion never showed up on the invoice, because people absorbed it. Humans became the integration layer: re-keying data between systems that don't talk, chasing status the system can't see, assembling context by hand before every decision, apologizing to clients for portals nobody chose. Asana's Anatomy of Work research has measured the result for years: roughly 60% of the workday goes to "work about work" — coordinating, status-chasing, searching — rather than the job people were actually hired to do. That number is not a discipline problem. It's the fingerprint of processes designed around software, with people left to fill the gaps.
AI is on track to repeat the mistake
The AI era is running the same playbook at higher speed: deploy the technology, expect the process to improve. The early evidence on how that goes is unusually blunt. MIT's State of AI in Business research found that 95% of enterprise GenAI pilots produced no measurable P&L impact — and that the failures cluster around generic tools that demo well but were never embedded in real workflows. Gartner projects that more than 40% of agentic AI projects will be canceled by the end of 2027, citing escalating costs, unclear business value, and inadequate risk controls.
Read those numbers carefully, because the popular reading — "AI isn't ready" — is the wrong one. The models are the strongest part of the stack. What fails is deployments that start from the technology and hope the process rearranges itself around it. It's the pattern from the first factories electrified a century ago: they swapped the steam engine for an electric motor, kept the same floor layout, and saw almost nothing — the gains arrived only when the factory was redesigned around what the new power source made possible. Most organizations are running AI the way those factories ran electricity.
Start from the moments only people can own
Designing around people means inverting the order of operations. Don't start by asking what the technology can automate. Start by finding the moments in the process that are its actual point — the ones only a person can own. The approval. The exception call. The compliance sign-off. The commitment made to a client. These moments are not overhead to be engineered away; they're where judgment and accountability live, and accountability is a uniquely human function. No regulator, court, or client accepts "the AI decided" as an answer.
Everything surrounding those moments — collecting the documents, validating the submission, chasing the missing pieces, summarizing the history, routing the result — is work around the decision, and that is exactly what AI agents should absorb. This is the division of labor question that now sits at the center of workflow design, and getting it right changes what automation is for: not removing people from the process, but making sure that when the process reaches a person, everything is ready for them.
There's a structural reason this matters more every quarter. As agents absorb operational work, human involvement doesn't disperse — it concentrates. Fewer people touch each process, and the ones who do carry more of its weight. A process designed around software buries those people in assembly work before every decision. A process designed around people delivers each decision prepared: context gathered, data validated, a recommendation on the table with the evidence behind it. That preparation is also why oversight makes agents useful rather than slow — review takes minutes when the reviewer isn't doing the reconstruction themselves.
"People" includes the ones outside your walls
Here's where software-first design fails hardest. The processes that matter most to a business — onboarding a client, qualifying a vendor, closing out a claim — cross company lines. And enterprise software has always treated the people on the other side of the line as an afterthought: they get notification emails about a process they can't see, chasers for documents they already sent, and another portal password to forget.
Designing around people means all of the people. The client uploading documents, the vendor's compliance contact, the partner signing off — each is an actor in the process, not an audience for it. They should reach their part of the work through a link that just works, see exactly what's theirs and nothing else, and never need training or an account to act. This is more than efficiency. For the people who own client relationships, the process is the relationship experience — every friction point spends trust, and every prepared, effortless interaction builds it.
What people-first design looks like in practice
Humans are actors in the workflow, not notification targets. Every person in the process — internal or external — is assigned, prepared, and tracked inside it, the same as any system or agent.
Decisions come with context. By the time a step reaches a person, agents have collected, validated, and summarized. Nobody makes a consequential call from a bare notification.
Agents are scoped, and they learn. Each agent has a defined role and permissions, and outcomes feed back so agents improve with every run. Where a step warrants extra oversight, supervisor agents watch the others — and anything beyond an agent's parameters escalates to a person instead of getting guessed at.
The record proves who decided what. Every step — human or agent — lands in an audit trail: who, what, when, on what basis. Accountability you can't demonstrate isn't accountability.
The process is orchestrated, not stitched. Task automation connects systems; a process needs coordination across humans, agents, and systems together — the difference between automation and orchestration is precisely this.
For the first time, the software can bend
What makes this moment genuinely different from the ERP era is that the inversion is finally practical. Software used to be rigid, so organizations bent. Now the software can bend: describe a process in plain language — who's involved, what needs judgment, what needs collecting — and an AI builder turns it into a running workflow: human roles and their moments, agents on the work around them, branching and escalation for the exceptions, a record underneath all of it. The system finally fits the process, instead of the reverse.
The last era of software asked people to work the way the system demanded, and we spent three decades paying for it in coordination. This era offers the opposite deal: decide what your people should own, and build everything else around them. The companies that take it won't just automate faster — they'll be the ones where the 60% of the day lost to work about work finally comes back. See what your process looks like designed around its people.
