The Steps Were for the Humans

On July 9, 2026, OpenAI shipped ChatGPT Work. Bloomberg covered it the same day. The pitch is that GPT-5.6 will take a goal, break it into steps, walk across your connected apps for hours, and hand you back finished sheets, decks, docs, and small web apps. Two days earlier, Peraton had already announced Peraton[x], an agentic platform pitched at government missions. A week later, the Model Context Protocol team promoted its Enterprise-Managed Authorization extension to stable, so an agent can now clear a single-sign-on gate and touch every internal server the identity provider approves.

Three product moves in one stretch, from three very different rooms, all pointed at the same thing. Agents that do knowledge work end to end. Not chatbots that draft one email at a time.

And yet Gartner's headline number for the year is that 89% of enterprise AI agent pilots never reach production, and their forecast is that more than 40% of agentic projects will be canceled outright by 2027. MIT's Project NANDA looked at the underlying pilots and put the "no measurable ROI" figure at 95%.

So we have the best agent stack in history landing in July, and a market that cannot get its pilots past the demo. That is not a technology gap. It is a design gap. Every hour I spend on real agentic workflow implementation in business ends up in the same place. The company is asking the agent to execute a picture that was drawn for people.

The steps in your workflow diagram were never the work. They were the coordination overhead between the humans who did the work. Now that the agent can do the work in one operation, the diagram is furniture.

Where the workflow came from

Take any process map on any wall of any large company. Follow one branch. The boxes are not units of value. They are handoffs. Sales qualifies a lead and passes it to solutions. Solutions writes a scope and passes it to legal. Legal redlines and passes it to finance. Finance rate-checks and passes it back to sales. Each box exists because the previous box's owner needed to stop working on that task and hand it to the next owner.

The boxes were the seams. The lines between the boxes were where the work actually stalled.

We inherited this shape from Frederick Taylor's stopwatch and from the assembly line, where the reason to split labor was that a single person could not learn every station without losing the specialization dividend. We codified it in ISO 9000 and Six Sigma and the swim-lane BPMN diagram, then we bought Salesforce and Workday and ServiceNow to enforce it in software. By 2019 the average enterprise process was a stack of thirty forms in three systems, and the reason it was thirty and not four was that thirty humans needed to see it.

Now watch what happens when you drop an agent into that map. The agent does not need a swim lane. The agent does not need a handoff. The agent does not need a form, because the form was invented so a human could complete state without holding it in their head. The agent already has state.

If you tell an agent to execute the diagram, you are asking it to reproduce the coordination overhead of the human org that drew the diagram. You are paying for tokens to simulate ceremony. That is why the pilot dies. Not because the model is weak. Because the process is a costume the agent has to wear.

Two production wins and what they actually did

Klarna is the case study everyone quotes and almost nobody reads carefully. Their AI assistant handles roughly two thirds of customer service chats, cuts average response time from about eleven minutes to under two, and saved the company around sixty million dollars in a single year. The number the industry loves is "853 human agents replaced." The number that matters is what Klarna deleted to get there.

Klarna did not build an agent that walks a support ticket through the pre-existing tiered escalation ladder. They built an agent that resolves the ticket. The tier one queue was a batching mechanism for humans. Tier two was a specialization boundary between humans. Tier three was a scarcity mechanism for the humans who knew the corner cases. All three were forms of load balancing across a workforce with limited attention. The agent's attention is bounded by inference cost, not by shift length, so the ladder was meaningless to it. Klarna kept the outcome, deleted the ladder.

AMD is the second one. They put a Kore.ai agent in front of HR queries and cut time to resolve an inquiry by eighty percent inside ninety days, while satisfaction sat around seventy. What they collapsed was the ticket-triage-route-answer chain that Workday and ServiceNow had built up over a decade. The old chain assumed a human at each hop. The new one has one agent with policy access and no shift.

Grubhub reports an 836 percent return on their agentic marketing spend and a 20 percent lift in orders. The interesting thing there is not the number, which is a vendor number. It is that the promotion, personalization, and settlement steps used to be three separate teams with three separate calendars. They are now one loop with one clock.

You can put every winning production agent from the last twelve months on a chart, and the common feature is not the model, the SDK, or the vendor. It is that the buyer had the nerve to erase intermediate steps rather than automate them.

The July 2026 tell

Watch what the top of the market shipped this month. It tells you which shape the frontier vendors think will win.

ChatGPT Work is aimed at goals, not steps. Read the launch language carefully. Gather context across your apps, break a goal into steps, return finished work. The user does not choose the steps. The agent proposes them and executes. The user approves outcomes and mid-course corrections. If your organization's ROI depends on the specific sequence in the current BPMN diagram, that product cannot help you. If your organization's ROI depends on a specific outcome, it can.

Anthropic's Claude Agent SDK moved to version 0.2.120 on July 15 with better subagent streaming, hook handling, and background agent behavior. The whole thing is built on the same primitive. Name a goal, give it tools, let it plan. The SDK does not have a "workflow" object at the top of its object model. It has an agent, a set of tools, a session, and permissions. Steps are emergent.

Microsoft's Copilot Studio and Salesforce Agentforce are the interesting counter-examples. Both are trying to sell you an agent that fits inside your current process. Copilot Studio's most-shipped patterns, per its own recent playbook, are IT help desk, HR self-service, and sales enablement, and its deployment guide talks in terms of four to six weeks for a simple agent and up to thirty-two weeks for a portfolio. Agentforce sells the "Atlas Reasoning Engine" as CRM-native. Both platforms are betting that the enterprise will refuse to redesign, and that the winning move is to wrap the old process in a chat interface.

The market will run both experiments in parallel through 2027. The frontier vendors are betting on goal-native agents. The suite vendors are betting on process-preserving agents. The 89% failure rate tells you which one the pilots are currently running, and which one they should be.

The Model Context Protocol number is the last piece. Per July 2026 reporting, 78 percent of enterprise AI teams have MCP-backed agents in production, and 28 percent of the Fortune 500 run MCP servers. Monthly SDK downloads are near 97 million. That is not a pilot metric. That is standardized plumbing landing in the middle of the enterprise while the C-suite is still writing memos about pilots.

The plumbing is not the constraint anymore. The design is.

Why the pilot is the wrong verb

The pilot is a nineteenth-century industrial idea. You take a small physical instance of a new machine, run it under supervision in a corner of the plant, measure defects, then scale the machine to the rest of the plant. The pilot works because the machine's behavior is roughly the same at scale as it is in the corner.

An agent does not behave that way. An agent's behavior is a function of the context, the tools, and the permissions available to it. Move it from a sandboxed corner to a full production tool set and you have not scaled the pilot. You have deployed a new agent, because the tool graph is different. The pilot proved that a small agent with three tools could summarize five tickets. It did not prove that the same model, given twenty-seven tools and cross-department access, would refrain from fabricating a refund or leaking a customer number.

This is why Gartner's own May 2026 note argues that applying uniform governance across all agents will itself cause failure. Governance has to match the blast radius of the individual agent, which changes every time you add a tool. The pilot cannot tell you what happens in production because the two agents are literally different objects.

The right verb is not pilot. It is contract. Define the outcome. Define the boundary. Define the rollback. Give the agent the tools it needs and none it does not. Turn it on for a slice of real traffic, measure, and either widen the boundary or reclaim the outcome. Do not budget for a pilot phase followed by a rollout phase. Budget for a contract that widens.

What agentic workflow implementation in business actually looks like

If you are the person on the hook for real agentic workflow implementation in business inside a large organization, the frame that keeps you out of the 89% is this.

Start from the outcome, not the diagram

Do not open the current process map. Open the P&L. Find the line item that pays for the outcome the workflow is supposed to produce. In Klarna's case that was resolution of a customer service contact. Never "route to tier one" or "escalate to tier two." Resolution. The diagram between contact and resolution was invented by an org chart that no longer needs to exist for that outcome.

Write the outcome as a contract. What has to be true when the agent is done. Who is worse off if the agent lies. What state has to move where. That contract is the specification. The current diagram is not.

Kill the seams before you hire the agent

Walk the current process backward from the outcome. Every step whose only purpose is to hand state from one human to another is a candidate for deletion. Every form whose only purpose is to make a human remember what they were doing when they picked the task back up next Tuesday is a candidate for deletion. Every meeting whose only purpose is to reconcile two departments' views of the same fact is a candidate for deletion.

You will find that a workflow with fourteen steps has three real steps and eleven seams. The three real steps are the ones an agent needs to perform. The eleven seams were the coordination overhead you were paying to run the org.

The industry likes to talk about "human in the loop" as the safety story. It is also the failure story if you leave the human at every seam. Keep the human at the outcome boundary, where judgment and accountability live. Do not put a human at every hop, because then you have rebuilt the org chart in software and paid for tokens on top of it.

Give the agent tools, not a script

An agent is not a macro. If you build a nine-step deterministic script and call it an agent, you have written a Zapier flow with a language model in the middle. That is nowhere near what wins.

Give the agent a set of tools that map to the real capabilities in your business. Read the CRM. Write the CRM. Query the data warehouse. Send email from this alias. File a refund up to this dollar amount. Escalate to a human at this boundary. Let the agent decide the sequence for the current request. Two requests that look similar to a human may not need the same sequence. The agent will plan differently for each and be right more often than the script.

MCP is the vocabulary for this now. That is why the enterprise adoption number matters. If your platform team stands up an internal MCP catalog with clean permissions, every subsequent agent your business builds is a two-week job instead of a four-month job. The July 2026 EMA extension collapses the auth story from per-server consent prompts to one identity-provider handshake. If your CIO is still six months from picking an MCP strategy, that is the highest-leverage decision they can make this quarter.

Instrument the trace, not the output

The pilot dashboard everyone builds shows how many tickets the agent closed and what the customer said afterward. That is the output. The output is a lagging indicator of a design that either works or does not.

The leading indicator is the trace. What tools did the agent call, in what order, with what arguments, and what did each one return. When the agent gets a case wrong, the trace is the postmortem. When the agent gets a case right in a surprising way, the trace is the design insight for the next tool. If your platform does not preserve full traces, you cannot iterate the agent. You have shipped a black box that will slowly drift and take your production credibility with it.

The Anthropic and OpenAI teams have both moved this direction in July. Their SDKs are shipping better subagent visibility and stronger hook handling. The tool is telling you what to build around it.

Contract the boundary, not the freedom

The safest agents are not the most restricted ones. The safest agents are the ones with the tightest boundary and the widest freedom inside it. Give the agent a small blast radius, then let it plan freely inside that radius. When the boundary holds, widen it. When it breaks, do not widen it and do not necessarily narrow it. Look at the trace, fix the tool that got misused, and widen again.

Governance has to match the blast radius, per that Gartner note. Uniform governance across a fleet of agents with different tool sets is either too loose for the dangerous ones or too tight for the useful ones. In either case you lose.

The seven percent

The other number in this year's data is worth staring at. Gartner's 11% of pilots that make production deliver a 171% return. First Page Sage's read of the enterprise data puts serious agent adoption in the mid-teens overall. The BCG "AI at Work" tracking puts the fraction of companies with genuinely production-ready agentic infrastructure at about seven percent.

Seven percent of the market has already crossed. They are compounding. Every month they run agents in production, their MCP catalog gets wider, their trace archive gets richer, their guardrail library gets sharper, and their people learn the muscle for designing agentic contracts instead of workflows. The other 93 percent are running quarterly pilots that produce PowerPoints.

The gap between the two groups is nothing to do with talent. It is nothing to do with budget. It is the willingness to look at the process diagram, admit the boxes were coordination overhead for the people who used to do this, and delete them.

Do not automate the diagram. Delete it.

Your consultants will tell you to map the current state, then map the future state, then automate the delta. That was the right advice for an enterprise resource planning rollout in 2004. It is the wrong advice for agentic workflow implementation in business in 2026, because the current-state map is a picture of your coordination overhead, and the future-state map should not contain that overhead at all.

The right sequence is different. Name the outcome. Name the tools that produce it. Name the boundary you refuse to let the agent cross. Give it those tools inside that boundary. Preserve the trace. Widen when it holds. That is a workflow you architect. It is not a workflow you buy from a suite vendor.

You cannot outsource this to the platform your CIO signed a five-year deal for, because that platform's business model depends on the workflow diagram still existing. You cannot outsource it to a labeling shop, because the design is upstream of the labels. You cannot outsource it to the model vendor, because the model does not know your outcomes, your P&L, or your risk appetite.

You have to do the architecture yourself, or you have to bring in a partner whose job is architecture. Buying a tool and hoping it comes with an architecture is exactly the move that puts you in the 89 percent.

Agor AI Advisory does this work for a small number of companies at a time. We start from the outcome. We take the seams out before we hire the agent. We build the MCP catalog and the trace store because those are the compounding assets, not the individual agent. We treat governance as a per-agent contract, not a companywide policy. We ship into production traffic on a boundary you can defend to your board, and we widen only when the trace says the boundary is holding.

If the pilot you are about to greenlight is really a "map the current state and automate the delta" project with a language model bolted on, you already know the outcome. You will be part of the 89 percent, and the meeting where that becomes visible will be the one where the board asks what happened to last year's AI budget.

The frontier vendors shipped the tools this month. The plumbing landed. Seven percent of the market is compounding. The only decision left is whether you architect your way into that seven percent or spend another year automating the diagram.