Designing Friction-Lite Workflows Without Burning the Business Down

This is not “switch everything off and start again”. It’s a deliberate programme to lower internal friction and become legible to the external agents that will decide where demand flows.

Simple is harder than complex. That is why most people don’t try.

We designed our current operating models for people. Why? Because humans are incredible at handling ambiguity.

When a process breaks, or a rule is vague, a human uses intuition to “make it work.” We rely on that human glue to hold the enterprise together.

In the human era, this was adaptability. In the agentic era, it is structural rot.

Agents don’t improvise. They don’t do “glue.” If your process relies on a human to “just figure it out,” an agent will simply halt.

The Fix: You don’t need more complex software. You need Radical Subtraction.

You need to strip away the ambiguity, the “gravy”, to reveal the clean logic underneath.

This makes you faster today and agent-ready tomorrow.

In Part 4 (The Conclusion), I break down:

• Why “Human Glue” is the enemy of scale.

• The 3-step pattern to simplify workflows before you automate them.

• How to stop buying “Performance Theatre” and start building leverage.

A challenge for this week: Go back to the workflow you mapped in Part 1. Apply the “No Human” constraint.

If you couldn’t rely on a person to interpret the data or smooth the handoff, what would break?

If the answer is “Everything,” don’t buy more software. You have a structural problem, not a tooling problem.

This is exactly where the Red Pen helps.

I’m opening a few spots for reviews to help you identify the “gravy” you need to cut so you can be ready.

Hit reply (or DM me) to grab a slot.

---

Designing Friction-Lite Workflows Without Burning the Business Down

This is not “switch everything off and start again”. It’s a deliberate programme to lower internal friction and become legible to the external agents that will decide where demand flows.

When people hear “agentic economy” or “post-firm enterprise”, they often jump to one of two extremes:

1. Utopia: we’ll replace everything with agents and self-optimising workflows.

2. Freeze: it sounds risky, so we’ll wait until the tech is “proven”.

Both are ways of avoiding the real work.

The real work sits in the middle:

• running the business you have today,

• while deliberately redesigning it so that internal friction drops,

• and both internal agents and external agents can genuinely do useful work.

Because the next generation of “work operating systems” won’t just sit inside your four walls. They will sit:

• on your customer’s device,

• in your partner’s stack,

• in neutral platforms that broker demand between buyers and suppliers.

If your workflows are opaque, brittle, or bespoke, those agents simply won’t choose you.

Start with friction, not with tools

Most transformation programmes still start with tools:

• “We’re implementing a new case management platform.”

• “We’re rolling out a new CRM with AI built in.”

• “We’re adding agents on top of our existing systems.”

The assumption is “If we deploy the right tools, friction will fall.”

In practice, you usually get:

• the same process,

• with slightly nicer screens,

• and a new layer of configuration to maintain.

Instead, start by asking:

“Where does friction actually live in this workflow, for us and for the outside world?”

Look for:

• steps where work bounces between teams,

• approvals where nobody remembers why they exist,

• data re-entry, copy-paste, and reconciliation,

• “manual checks” that rarely find anything,

• exceptions that account for 80% of the effort,

• external touchpoints where customers or partners have to phone, email, or chase.

These are the places where the cost of transactions explodes, and where external agents will judge you as “high friction”.

Design principles for friction-lite workflows

You don’t need a new operating model theory. You need a small set of principles you apply consistently.

Here are five:

1. Single accountable owner per outcome
   One person or team is clearly accountable for the end-to-end outcome, not just their step.

2. Minimum viable approvals
   Approvals exist for clear, articulated risks – and are designed to be fast by default.

3. Event-first visibility
   Key state changes emit events that humans, internal agents, and external agents can subscribe to – rather than being buried in logs or spreadsheets.

4. Composable capabilities
   Actions (create order, update status, schedule appointment, issue refund) are exposed as capabilities that can be called by different channels and agents.

5. Externally legible contracts
   Where it makes sense, the rules (SLAs, constraints, pricing, eligibility) are machine-readable, so an external agent can understand what you offer without scraping PDFs.

If a workflow doesn’t respect these principles, agents will struggle – and humans will keep firefighting.

A practical pattern you can apply tomorrow

Take one high-value workflow and run this pattern.

Step 1: Define the “minimum viable journey”

Write down, in plain language:

• the trigger that starts the journey (often external),

• the outcome that counts as “done”,

• the non-negotiable checks or controls.

Strip everything else out for now.

If you can’t write this on half a page, the workflow is already too bloated.

Then add a second line:

“If a customer’s agent wanted to complete this journey end-to-end, what would it need to see and do?”

This forces you to think beyond internal steps.

Step 2: Map current reality – including external touchpoints

Now map the real-world steps and systems:

• where the work actually starts,

• every handoff,

• every approval,

• every system touched,

• every point where a human outside your firm has to intervene (call, email, portal, form).

Mark each step with one of three labels:

• Core – essential to reaching the outcome safely.

• Guardrail – risk/control that genuinely matters.

• Gravy – habit, legacy, or local optimisation.

Be honest. A lot more will fall into “gravy” than people expect.

Step 3: Design the friction-lite version

Redesign the flow with three constraints:

1. Keep all Core and necessary Guardrail steps.

2. Remove as much Gravy as you can.

3. Express the flow as states and capabilities, not just tasks.

For example:

• States:

  New, Eligibility Checked, Approved, Scheduled, In Progress, Completed, Closed

• Capabilities:

  check_eligibility, approve_case, schedule_slot, update_status, notify_customer, issue_refund

Now ask:

• Which of these capabilities should internal agents be allowed to call?

• Which should external agents be allowed to call, under what contracts (rate limits, auth, SLAs)?

You’ve just drawn the outline of an operating model that is legible to both.

Step 4: Implement in slices, not shocks

Don’t announce a big-bang change.

Instead:

• pick one segment of the journey (e.g. from New to Approved),

• implement the friction-lite version there,

• ensure events and capabilities are surfaced clearly,

• pilot with a narrow set of customers, channels, or partners,

• then expand to the next segment.

The business keeps running. Risk is contained. Learning is fast.

Internal agents can start by operating within that slice. External agents (for example, a partner’s automation or a customer’s “ops copilot”) can start by calling a small, well-defined subset of capabilities.

Where agents fit into this

Once you’ve done this for even a small number of workflows, you can introduce agents in a way that makes sense:

• An internal agent can monitor events and propose or take decisions in clearly defined states.

• Another internal agent can orchestrate calls to capabilities you’ve already exposed.

• External agents can:

  • request quotes,

  • place orders,

  • check status,

  • reschedule or cancel,
    within guardrails you set.

You’re not asking agents to:

• infer messy, undocumented rules from noisy data,

• improvise ownership,

• or guess how to handle exceptions you’ve never defined.

You’re asking them to operate inside a workflow that has:

• clear states,

• clear capabilities,

• clear accountability,

• and clear contracts at the edge.

That’s where they create leverage instead of chaos – and where external agents can confidently keep sending work your way.

This is evolution, not revolution

The point here is simple:

• You don’t have to switch everything off.

• You don’t have to wait for some perfect platform.

• You don’t have to pretend your world is simpler than it is.

You do need to:

• pick concrete workflows,

• deliberately lower internal friction,

• expose cleaner structure for humans and agents,

• and decide where and how you want to be consumable by external agents.

If you’re planning big moves in 2026, make this the bar:

“Does this initiative make our workflows more friction-lite and agent-ready, inside and outside, without betting the business on a single giant leap?”

If the answer is yes, you’re moving in the right direction.

If the answer is no, you’re probably adding another layer of complexity you’ll pay for later – in human frustration today, and in lost demand when the next generation of agentic platforms quietly chooses someone else.

Designing friction-lite workflows, one slice at a time, is how you avoid that choice.