Human + Machine

1. 1Map your target process into its component tasks, then sort each into three buckets: machine-only (repetitive, high-volume data analysis, routine cases), human-only (judgment, ethics, complex exceptions), and missing-middle collaboration. The collaboration bucket is where you deploy the six roles.
2. 2On the human-supporting-machine side, staff the three developer/deployer roles: trainers who teach algorithms behaviors and correct outputs, explainers who interpret and articulate algorithmic reasoning to stakeholders, and sustainers who keep systems accountable and within ethical and performance bounds inside the process.
3. 3On the machine-supporting-human side, design for the three amplify/interact/embody roles: give people AI that amplifies their analytical and creative capacity, that interacts with them naturally (conversational agents), and that embodies capability physically (collaborative robot arms, embedded systems).
4. 4Create the new job titles the roles demand—for example, a machine relations manager who runs performance reviews on AI systems, promoting and replicating high performers and demoting or decommissioning poor ones—rather than bolting AI onto existing job descriptions.
5. 5Reimagine the process from scratch as adaptive rather than automating the existing linear one; treat rigid assembly-line steps as candidates for flexible human-robot teams that adapt on the fly to new data.
6. 6Fund the enablers before scaling: build a free-flowing data supply chain (including exhaust data) unencumbered by silos, commit leadership to responsible-AI guardrails, and train/retrain people for the missing-middle roles.
7. 7Instrument the collaboration so you can tell whether each role is producing the intended lift; run trial-and-error to reallocate tasks between human, machine, and joint work as results come in.

At BMW's Dingolfing plant, a transmission is built by a human-machine team rather than a full-automation line. The worker prepares the gear casing while a lightweight, surroundings-aware robot arm picks up a twelve-pound gear, places it precisely inside the casing, and turns to fetch the next one; the worker has already moved to her next task. This is the embody role operating in the missing middle: the machine handles the heavy, precise, repetitive placement while the human handles preparation and sequencing. Elsewhere on the same floor a different robot arm evenly applies black adhesive to car window edges. The process was not merely automated—it was reimagined as a flexible team, so rigid assembly lines give way to teams that adapt to new conditions. The result is jobs that change in nature and increase in number, letting people work more like humans and less like robots.

• If a task is repetitive, high-volume, or routine data work, then assign it to the machine and free the human for complex exceptions—as in claims processing where AI does grunt data collection and preliminary analysis.
• If stakeholders cannot understand why the AI decided something, then you have a missing explainer role—staff one before deployment, not after a complaint.
• If you are only digitizing or speeding up an existing static process (the early-GPS pattern), then stop; reimagine it as an adaptive Waze-style process before adding AI.
• If an AI system's performance is drifting or unaccountable, then a sustainer/machine relations manager should review, and demote or decommission it rather than let it run.
• If you are deploying AI that affects people's decisions or wellbeing, then leadership must set ethical guardrails and preserve employees' sense of agency and empowerment from the start.

• Treating AI as pure replacement (man-versus-machine framing). The tell: your business case is measured only in headcount reduction, and no new missing-middle roles appear on the org chart.
• Automating the old process instead of reimagining it. The tell: performance gains level off quickly because you're wringing the last efficiencies out of a mechanistic, sequential workflow.
• Deploying algorithms with no explainer or sustainer. The tell: no one can articulate why the system produced a result, and there's no performance-review cadence for the AI itself.
• Skipping the data supply chain and leaving data in departmental silos. The tell: teams spend most of their effort accumulating and preparing data, and models can't be sustained or improved.
• Ignoring agency and ethics until an incident. The tell: employees feel deskilled or surveilled, or you run experiments on people without review—the Facebook mood-manipulation gray area.

• ▸Process/task being reimagined: name the specific workflow, not the whole function
• ▸Machine-only tasks: list repetitive/data-heavy tasks the AI will own
• ▸Human-only tasks: list judgment/ethics/complex-exception tasks people keep
• ▸Amplify / Interact / Embody: for the joint tasks, note how the machine boosts the human
• ▸Trainer / Explainer / Sustainer: name who fills each human-supporting-machine role
• ▸New role or title created: e.g., machine relations manager, with its review duties
• ▸Data source & flow: what data (incl. exhaust data) fuels this and which silos to break
• ▸Guardrail & agency check: ethics/accountability rule + how the worker keeps decision agency
• ▸Success signal: the specific performance lift that proves the collaboration works

1. 1Audit your AI systems for confidence gaps before deployment: measure whether you have high confidence in fairness, auditability, and safety — the Accenture survey found fewer than one-third of companies trust their systems' fairness/auditability and fewer than half trust safety. Treat any gap as a trust liability to close, not a footnote.
2. 2Assign explicit trust roles, not just an engineer. Staff an ethics compliance manager to act as watchdog/ombudsman for human values, an algorithm forensics analyst to trace why a system produced a biased output, and AI safety engineers to anticipate unintended consequences and respond to harmful events with urgency.
3. 3Choose model transparency deliberately: in necessary cases, use non-blackbox models so intermediate reasoning is inspectable. Reserve opacity only where the stakes and auditability requirements permit it.
4. 4Build a human fallback into every customer-facing agent. Design the bot so that when it can't confidently resolve a request, it hands off to a human expert and learns from that interaction — as SEB's Aida does.
5. 5Pressure-test bots against high-stakes personal prompts before launch: run them through crisis scenarios (suicidal statements, assault disclosure, symptoms suggesting appendicitis or cancer) and require consistent crisis recognition, respectful language, and referral to an appropriate helpline or resource.
6. 6Localize for worldview: employ worldview and localization trainers so systems account for regional differences in attitudes toward automation (e.g., Japanese cultural affinity for robots vs. US/Western European anxiety), preventing confusion, embarrassment, and brand distrust.
7. 7Investigate and remediate discovered bias with the forensics/compliance pair: when a credit system discriminates by geography or a 'loving grandmother' query returns only white women, trace the cause and implement the fix rather than patching the symptom.

At SEB, the virtual agent Aida answers FAQ-type questions, guides users through processes, performs actions in internal systems, and asks follow-up questions to solve a customer's problem. The design decision that builds trust is the boundary condition: when Aida encounters a question it cannot confidently resolve, it connects the customer to human experts. That handoff prevents the moral crumple zone where an overconfident bot gives wrong or harmful answers and the customer bears the cost. Aida then learns from the human expert's interaction with the customer, so competence and trust compound over time. Contrast this with the 2016 study of Siri, Cortana, Google Now, and S Voice, which were inconsistent and incomplete at recognizing crises — Siri offered nearby medical facilities but didn't distinguish a headache from a heart attack. The lesson: agency and guardrails (confident-vs-uncertain routing) matter more to trust than raw conversational fluency.

• If the AI system cannot confidently resolve a request, then route it to a human expert and capture that interaction as training data.
• If a use case is high-stakes or legally sensitive (credit, health, safety), then use a non-blackbox model so intermediate steps are auditable.
• If an output shows a bias pattern (geographic discrimination, skewed image results), then pair an algorithm forensics analyst with the ethics compliance manager to find the root cause before shipping any fix.
• If you deploy a conversational bot across regions, then engage worldview/localization trainers because attitudes toward automation vary by culture.
• If confidence in a system's fairness, auditability, or safety is below a high bar, then treat it as not deployment-ready regardless of technical performance.

• Optimizing for conversational fluency while ignoring crisis handling — the tell: the bot sounds like a trusted friend but responds to 'I feel suicidal' or symptom searches inconsistently, as all four assistants did in the 2016 study.
• Creating a moral crumple zone by giving an overconfident bot no handoff — the tell: users get confidently wrong answers and no human ever intervenes.
• Shipping black-box models where auditability is required — the tell: when a discriminatory outcome surfaces, no one can explain why the system decided as it did.
• Assuming one worldview generalizes globally — the tell: users in one region react with confusion, embarrassment, or distrust that didn't appear in your home market.
• Treating trust as a technical rather than human problem — the tell: you have no ethics compliance manager or safety engineer, and you're surprised that a third of people fear AI and nearly a quarter believe it will harm society.

• ▸System name & use case: name the system and the decision it makes.
• ▸Stakes level (low/medium/high): rate potential harm to users if it errs.
• ▸Model transparency: state whether it's black-box or inspectable, and justify the choice.
• ▸Confidence-fallback rule: define the threshold below which it hands off to a human expert.
• ▸Crisis/edge prompts tested: list the high-stakes scenarios you ran and the pass/fail result.
• ▸Bias audit owner: name the algorithm forensics analyst and ethics compliance manager accountable.
• ▸Localization scope: list regions covered and the worldview differences accounted for.
• ▸Fairness/auditability/safety confidence: rate each and flag any below a high bar as not-ready.
• ▸Learning loop: describe how human corrections feed back into the system.

1. 1Sequence the foundation before the augmentation: first apply automation to routine, linear, repeatable work to develop employees' full potential; only then move to human-machine collaboration in the missing middle.
2. 2Classify each task in a process into three buckets — best for humans, best for machines, best for both together — using the AI definition (systems that sense, comprehend, act, and learn) as your test for what to hand off.
3. 3Pick the augmentation mode that fits the task: amplify insight (recommendation systems, personalization), interact on the reader's behalf (text/speech/image/video recognition), or physically extend ability (extended reality for training and maintenance).
4. 4Feed the augmented process real-time data streams — human inputs, crowd inputs, live signals — instead of a fixed a priori sequence of steps, so directions and outputs update mid-course.
5. 5Run experiments to find the specific spots in a process where AI adds capability; test, measure the outcome against the human-only baseline, then scale the reimagined process rather than replicating a competitor's best practice.
6. 6Reorganize rigid, stepwise workflows into fluid organic teams of humans plus smart machines that adapt on the fly to new data and different human contributions.
7. 7Set ethics guardrails before augmenting research on people — establish an IRB-style review committee where no standard protocol exists, since outside pharma there is no default for what counts as human research.

A designer at Autodesk wants to build a drone. Instead of modifying preexisting concepts and manually adjusting for constraints like weight and propulsion, she inputs those parameters into the company's AI-enabled generative software. The software's genetic algorithm produces a vast array of designs no human has ever seen — some bizarre, but all satisfying the initial constraints. She then selects one that distinguishes her drone and further tweaks it to fit her own aesthetic and engineering goals. The machine explores a design space at a scale and speed a person cannot; the human sets constraints, judges, and refines. Neither works alone — the augmented output belongs to the missing middle where the designer's intuition and the algorithm's search combine.

• If a process is linear, stepwise, standardized, and already optimized by time-and-motion analysis, then automate it first — do not rush to add collaboration on top of unstable routine work.
• If productivity gains from mechanistic automation are leveling off, then the remaining value is in augmentation, not more efficiency-wringing.
• If a subject-matter expert must become an expert in the tool itself (e.g., Bayesian optimization) to use it, then the augmentation has failed — the software should tell the chemist 'this is the next experiment to try,' not demand internal knowledge of the system.
• If the task depends on behaviors, preferences, and context that shift moment to moment, then drive it with real-time data rather than a fixed sequence of steps.
• If your research uses human subjects and no external protocol exists, then stand up your own review committee before you test, not after.

• Treating augmentation as automation — using machines only to replace steps in a workflow; the tell is short-run gains that stall out with no breakthrough.
• Digitizing the old static process instead of reimagining it — like turning a paper map into a digital map without adding real-time rerouting the way Waze does; the tell is a faster version of the same rigid route.
• Skipping the foundation and rushing to fill the missing middle before employees' routine work is automated; the tell is human-machine teams collapsing back onto unstable manual processes.
• Copying a leading firm's best-in-class process instead of experimenting for your own context; the tell is imported practices that don't fit your unique operating conditions.
• Building tools that require expert internal knowledge to operate, so subject-matter experts spend time tweaking systems instead of experimenting more; the tell is adoption limited to specialists.
• Testing on human subjects with no review board or ethics rules; the tell is gray-area studies proceeding with no one deciding whether a product test is human research.

• ▸Process name: the workflow you are reimagining
• ▸Task breakdown: list each discrete step in this process
• ▸Human-only / Machine-only / Both: tag each step
• ▸Augmentation mode: amplify insight, interact on behalf, or physically extend
• ▸Real-time data inputs: which live human/crowd/sensor signals feed it
• ▸Human baseline metric: current performance without AI
• ▸Experiment + expected lift: the spot you'll test and the outcome you'll measure
• ▸Foundation check: is routine work automated first? (yes/no)
• ▸Ethics guardrail: review board or rules needed if humans are subjects

1. 1Inventory the tasks your team actually does, then separate them into two columns: repetitive/structured work machines do best (reading, sorting, routing, data collection, preliminary analysis) versus judgment work humans do best (resolving ambiguity, difficult cases, dealing with dissatisfied customers). Employee satisfaction improves only when you offload from the first column.
2. 2Identify which tedious tasks specifically fatigue people more than their other work. At Virgin Trains, reps found manually reading, sorting, and routing complaints more fatiguing than directly talking to customers — target that gap, not just any automatable task.
3. 3Deploy AI to do the drudgery (grunt work, tedium, drudgery) and route the output to humans as a case-ready file they can quickly review, so people spend their time on the higher-satisfaction work (talking to customers, conceiving experiments, asking unexpected questions).
4. 4Build in an exception path: when the system isn't fully confident, it flags the item for a human, and that human's response updates the model. This keeps humans in meaningful decision roles and improves the system over time.
5. 5Redeploy freed-up time deliberately — shift workers to where people skills matter more, or where danger is removed. Rio Tinto moved operators out of dangerous mining conditions to a central control facility; Coca-Cola freed employees from count-and-restock paperwork.
6. 6Invest in the skills part (MELDS) so employees adjust how they work — the shift places a premium on collaborative capabilities, judgment, and customer interaction rather than manual throughput.
7. 7Frame the change as rehumanizing work: measure not only efficiency but whether the work now feels more human and less robotic, safer, and more satisfying.

At Virgin Trains, customer service reps manually read, sorted, and routed incoming complaints. These repetitive activities diverted their time and attention and fatigued them more than other work like directly talking to customers. The read-sort-route process was clearly defined but the incoming complaints were unstructured text, which stumps less advanced systems. The company installed inSTREAM, a machine-learning platform with natural-language processing that recognizes patterns in unstructured data by analyzing a corpus of similar complaints and tracking how reps handle incoming text. Now complaints are automatically read, sorted, and packaged into a case-ready file an employee can quickly review; the most common complaints get appropriate automated responses. When the software isn't fully confident, it flags an exception for a human, whose response updates the model. The result: employees spend less time on the fatiguing drudgery and more on the human work, and the company later expanded intake channels to include social media.

• If a task is repetitive, structured, and clearly defined, then route it to the machine; if it requires resolving ambiguity or handling dissatisfied customers, then keep it human.
• If a task fatigues employees more than their other work, then prioritize it for offloading even if it isn't the biggest efficiency win.
• If the system is not fully confident in an assessment, then flag it as an exception for human review and use that response to retrain the model.
• If you're only using AI to replace humans, then expect to eventually stall; if you design machines to augment humans, then you position for leadership.
• If a task exposes workers to danger, then automate the exposure and move people to a safer control or analysis role.

• Automating for pure replacement rather than augmentation — the tell: efficiency gains level off and you've eliminated the human judgment that handles complex or ambiguous cases.
• Picking tasks by ease of automation instead of by which ones drain people — the tell: throughput rises but employees report no change in satisfaction or fatigue.
• Skipping the exception/feedback loop — the tell: the model never improves and humans lose their meaningful role in ambiguous cases, becoming passive reviewers.
• Offloading time without redeploying it to higher-value human work — the tell: freed hours get absorbed by more of the same instead of customer contact, discovery, or judgment work.
• Neglecting the skills investment (MELDS) so employees can't work alongside the new system — the tell: people resist the tool and collaborative capabilities never develop.

• ▸Task name — the specific process step under review.
• ▸Structured or unstructured — is the input clean/defined or text-based and messy?
• ▸Fatigue rank — how draining is this versus the team's other work (high/med/low)?
• ▸Machine-best or human-best — repetitive/analytical vs. ambiguous/judgment/customer-facing.
• ▸AI action — what the system will do (read, sort, route, count, pre-analyze).
• ▸Exception trigger — the confidence threshold that flags an item for a human.
• ▸Feedback loop — how the human response updates the model.
• ▸Redeployed time — the higher-satisfaction work freed hours go toward.
• ▸Skills gap — the collaborative or judgment skill employees need to build.

1. 1Adopt the reimagination mindset first: refuse to accept the existing process as given. Treat the current workflow as a 'rupture' candidate — ask what work might be, not how to automate what is. Automating an accepted process yields only incremental gains.
2. 2Discover and describe the real pain point through observation, not assumption. Capture current business context, distill insights from watching actual users, and identify the potential value impact before designing any system. Expect this to be iterative — your first framing is usually wrong.
3. 3Classify the process work across the missing middle: the three human-improves-machine activities (training, explaining, sustaining) and three machine-improves-human activities (amplification, interaction, embodiment). Assign work to whichever side does it best.
4. 4Divide the data by type: route structured data (surveys, measurements, brand preferences, sensor readings) to machines, and unstructured, judgment-laden data (images, freeform notes, tricky material handling) to humans.
5. 5Co-create the workflow so machine and human hand off in a choreographed sequence rather than a fixed chain — e.g., algorithms narrow options to a manageable set, humans finalize with expertise and personalization.
6. 6Build self-adapting systems: bake demand fluctuations and customization into the system so teams can be assembled on the fly without manually overhauling steps. Change should be self-adaptive from real-time human and machine input, not episodic and human-led.
7. 7Scale and sustain: test on a bounded set (a pilot), feed the outcome data back to improve the algorithms, then expand. Ensure both human and machine keep learning and updating continuously.
8. 8Address the neglected 'MELD' factors — data landscape (your own AI-enabling data plus broader available data), corporate culture, ethics, and consumer and employee trust — as part of the process, not afterthoughts.

Stitch Fix was built as a human-machine team from the start, making it a prime case of process reimagination. Its personal-shopping service reimagines the old process of spending hours trying on dozens of outfits at a store. The company splits its recommendation engine by data type: machines manage structured data such as style surveys, measurements, and brand preferences, while human stylists handle unstructured data like Pinterest board images and customer notes about why they want new clothes. When it is time to assemble a shipment, machine-learning algorithms reduce thousands of options down to a manageable set of choices for a stylist; the machine augments the worker. The stylist then applies expertise to finalize the package and add a personalized note, and both human and machine keep learning and updating from the result. The outcome is an entirely new business model, not just an efficiency bump.

• If you are only automating an existing process as-is, then expect incremental improvement that eventually stalls — go back and envision a rupture instead.
• If the data is structured (surveys, measurements, sensor readings), then assign it to machines; if it is unstructured or requires judgment (images, notes, material handling), then assign it to humans.
• If your initial problem framing came from assumption rather than watching users, then run further observation — the real pain point is often different (crop-yield prediction turned out to be real-time adaptive recommendations).
• If demand fluctuates or orders are customized, then design self-adapting workflows that reconfigure automatically rather than requiring manual process overhaul.
• If a pilot's outcomes are promising, then feed its data back into the algorithms before scaling, so improvement compounds.

• Accepting the current process and layering AI on top. Tell: you get modest short-run productivity gains that plateau, with no new business model or step-level change.
• Treating reimagination as pure task replacement rather than process change. Tell: robots or algorithms sit sectioned off doing one dedicated task inside an otherwise rigid, fixed chain of work.
• Solving the pain point you assumed instead of the one users actually have. Tell: the agricultural company nearly built crop-yield prediction when farmers really wanted real-time, actionable recommendations (which crops, where, how much nitrogen).
• Rushing identification of the opportunity. Tell: skipping the iterative capture of context and insight, then discovering the value impact was mis-estimated after build.
• Neglecting culture, ethics, and employee/consumer trust while focusing on technology and data. Tell: capable systems that stall on adoption because people don't trust or aren't skilled to use the new freedom (e.g., a designer without training to exploit thousands of generated designs).

• ▸Pain point (validated): the internal or external friction, confirmed by observation not assumption
• ▸The rupture: describe how this work might be done, not how it is done now
• ▸Structured data → machine: list data machines will manage
• ▸Unstructured/judgment data → human: list data and calls humans will own
• ▸Missing-middle roles: which of training/explaining/sustaining and amplification/interaction/embodiment apply
• ▸Handoff sequence: how machine and human pass work back and forth
• ▸Self-adaptation triggers: which demand or customization changes the system absorbs automatically
• ▸Pilot scope + feedback loop: bounded test set and how its data improves the algorithms
• ▸MELD guardrails: data sources, culture, ethics, and trust risks to manage

1. 1Audit your current AI use: classify each deployment as either automating a static process (early-GPS thinking) or reimagining it around real-time data and human-machine teams (Waze thinking). The second category is where orders-of-magnitude gains live.
2. 2Stop optimizing linear, stepwise, standardized workflows for the last bits of efficiency—those gains level off. Instead identify processes rigid enough to be candidates for conversion into adaptive human-machine teams.
3. 3Build the 'missing middle': design roles where humans develop, train, and manage AI applications, and where AI amplifies human skills rather than replacing them. Assign what each party does best.
4. 4Replace fixed sequences with real-time data feeds so processes self-adapt to worker behavior, preferences, demand fluctuations, and market conditions on the fly.
5. 5Deploy AI defined by the four capabilities—sensing, comprehending, acting, learning—so work processes become self-adapting and can reconfigure teams without manual process overhauls.
6. 6Enable individualized outputs: use the adaptive process to deliver customized products/services profitably rather than mass-produced goods, and measure whether non-standardized processes still repeatedly deliver better outcomes.
7. 7Move ahead of competitors on timing—digital Darwinism means technologies evolve faster than firms adapt, so capture the exponential improvements 'in record time' before rivals fill the same gap.

Consider a designer at Autodesk building a drone. In the old mechanistic approach she would modify preexisting concepts and manually adjust for constraints like weight and propulsion—a linear, standardized process. Instead she inputs those parameters into Autodesk's AI-enabled software, whose genetic algorithm generates a vast array of designs no one has ever seen, all satisfying the initial constraints. She then selects one that distinguishes her drone and tweaks it to fit her aesthetic and engineering goals. This is the missing middle in action: the machine explores a design space impossible for a human to enumerate, while the human sets constraints and exercises judgment—together attaining a breakthrough neither could reach alone. The same pattern shows on factory floors at BMW and Mercedes-Benz, where rigid assembly lines give way to flexible teams of employees working alongside collaborative robots that sense, comprehend, act, and learn.

• If a process is linear, stepwise, and already time-and-motion optimized, then expect automation gains to stall—redesign it as an adaptive human-machine team instead.
• If your AI merely digitizes an existing static process (early GPS), then you are leaving orders-of-magnitude gains on the table; rebuild it around real-time data (Waze).
• If a task benefits from generating options at scale or sensing changing conditions, assign it to the machine; if it requires judgment, aesthetics, training, or managing the AI, assign it to the human.
• If demand fluctuates or orders require customization, then bake adaptation into the system so teams reconfigure automatically rather than through manual process overhauls.
• If you are treating machines as replacements for humans, then stop—the gains come from amplification and collaboration in the missing middle, not substitution.

• Automating existing static processes and calling it AI transformation—the tell is short-run productivity gains that plateau and stall out.
• Adopting the man-versus-machine frame (machines replace humans)—the tell is roles designed to eliminate people rather than pairings that amplify them, leaving the missing middle empty.
• Keeping rigid assembly-line thinking while bolting on AI—the tell is that processes still can't adapt on the fly to new data or market conditions.
• Standardizing everything for repeatability—the tell is you cannot deliver individualized products profitably because the process can't respond to real-time preferences and needs.
• Moving too slowly in digital Darwinism—the tell is competitors capturing the same exponential improvements first while you're still wringing efficiency from old automation.

• ▸Process name: the workflow you are evaluating.
• ▸Current type: mark as static-automation (early GPS) or adaptive (Waze).
• ▸Real-time data source: what live data could drive this process instead of a fixed sequence.
• ▸Machine role: which of sense/comprehend/act/learn the AI performs here.
• ▸Human role: the develop/train/manage or judgment task the human owns.
• ▸Customization target: the individualized outcome this pairing should deliver profitably.
• ▸Adaptation trigger: the demand or market change the team must reconfigure to on the fly.
• ▸Gain type: modest-plateauing vs. orders-of-magnitude breakthrough expected.
• ▸Time-to-capture: how fast you must convert before a competitor fills this gap.

1. 1Sequence before you reimagine: first apply automation to routine work to develop the full potential of your employees, then move to human-machine collaboration. Do not rush to fill the missing middle before laying this foundation.
2. 2Honestly assess what humans and machines each do well — let machines do the heavy lifting, monitoring, and monotonous tasks; assign adaptation, creative problem-solving, and novel solutions to people. A new set of process possibilities emerges only from this honest inventory.
3. 3Rather than digitizing the old static process, redesign it as living and adaptive — like Waze reimagining maps using human, crowd, and real-time inputs — so teams continuously adapt on the fly to new data and different human contributions.
4. 4Replace rigid, standard processes with flexible teams of augmented humans and smart machines. Assume the age of copying best-in-class practices is over; derive processes that fit your unique conditions through trial and error.
5. 5Pair the mindset shift with the other MELDS elements: experimentation (test spots in processes to learn and scale), leadership (commit to responsible AI from the start), data (build a data supply chain), and skills (retrain people for missing-middle roles).
6. 6Use AI's third-eye data and analysis to make previously invisible inefficiencies knowable, then reimagine the process — and stay open to spinning up entirely novel businesses (e.g., vertical farms) that the reimagined possibilities reveal.
7. 7Extend the reimagining across every zone — factory floor, back office, R&D, and front office — because the missing middle applies to all of them, not just production.

Consider the BMW assembly plant in Dingolfing, Germany. Rather than fully automating transmission assembly, the plant reimagined the process around collaboration: a worker prepares a gear casing while a lightweight, surroundings-aware robot arm picks up a twelve-pound gear and places it precisely inside. Elsewhere a robot arm evenly applies black adhesive to small car windows, while a worker steps in between applications to wipe the glue nozzle, pop in new glass, and carry away finished windows. The result reads as a choreographed dance rather than a replaced human — the machine takes the heavy, monotonous, precision-repetitive work and the human handles setup, judgment, and adaptation. This is the reimagining mindset in practice: not automating a step out of existence, but redesigning the work around what human and machine each do best. The rigid assembly line gives way to a flexible human-machine team.

• If a task is heavy lifting, monitoring, or monotonous repetition, then assign it to the machine; if it requires adaptation, creativity, or novel solutions, then keep it with the human.
• If you have not yet applied automation to routine work, then do that first — do not rush to fill the missing middle before the foundation is laid.
• If your instinct is to digitize the existing static process, then stop and instead redesign it as a living, adaptive process fueled by human, crowd, and real-time data.
• If you are tempted to replicate a best-in-class practice from a leading firm, then run your own experiments instead — standard processes no longer confer advantage.
• If AI reveals a previously off-limits possibility (too costly or slow before), then experiment toward it, since that is where game-changing, industry-transforming innovations appear.

• Treating AI as pure automation — replacing humans instead of collaborating. The tell: the project brief measures success only by headcount reduction, never by new human-machine process capability.
• Digitizing the old process rather than reimagining it. The tell: the 'new' workflow mirrors the static one-to-one map of the old, just faster — Waze-style adaptivity is absent.
• Rushing to fill the missing middle before automating routine work and developing employees. The tell: workers still bogged in routine tasks while leadership chases advanced collaboration.
• Adopting only the mindset while ignoring the rest of MELDS. The tell: bold reimagining talk with no experimentation cadence, no data supply chain, no retraining budget, and no responsible-AI guardrails.
• Letting employees lose their sense of agency in the redesigned process. The tell: people working alongside AI feel deskilled or sidelined rather than empowered in decision making.

• ▸Process under review: name the workflow you intend to rethink rather than merely automate.
• ▸Current state: is routine work already automated? (yes/no — if no, do that first).
• ▸Human-does-best tasks: list the adaptive, creative, judgment tasks to keep with people.
• ▸Machine-does-best tasks: list the heavy, monitoring, monotonous tasks to offload to AI.
• ▸Collaboration handoffs: describe where human and machine trade off in the reimagined flow.
• ▸Static-vs-adaptive check: how will this process ingest real-time/human/crowd data to adapt?
• ▸Experiment to run: the specific spot you will test AI to learn and scale.
• ▸Data supply chain: what data (including exhaust data) fuels this process, and where from?
• ▸Skills/agency plan: what retraining keeps workers empowered, not deskilled, in new roles.

1. 1Start by laying the automation foundation before you experiment on collaboration: apply automation to routine work first, then look for the missing-middle spots where humans and machines should collaborate. You cannot test reimagined processes on top of un-automated chaos.
2. 2Actively observe your processes for specific spots to test AI. Don't run generic pilots — target a discrete task and ask the missing-middle question: what should humans do, what should machines do, and where do they collaborate?
3. 3Frame each test around a clear picture of the successful outcome (as deep reinforcement learning does — give the system the target result), then run trial-and-error cycles to let the process find its own path to that outcome.
4. 4Instrument the test with a data supply chain: collect granular real-time data so the process becomes knowable and you can measure results, not guess. Without measurement you cannot tell success from failure.
5. 5Build a feedback loop that routes measured results back into the process — either to a human operator or automatically into the work-management system — so each cycle updates the next (build-measure-learn).
6. 6Judge each AI system on performance: promote and replicate variants that perform well to other parts of the organization; demote, improve, or decommission systems that perform poorly.
7. 7Stop replicating best-in-class practices from other firms. Standard business processes are ending — derive the process that fits your unique conditions through your own tests.
8. 8Scale only after a reimagined process proves out in the test spot, then deploy the working variant more broadly.

Fanuc, with software-maker Preferred Networks, tests robotic arms that learn to pick up and place parts without explicit programming. The method is deep reinforcement learning: the robot is given a picture of the successful outcome, then uses trial and error to figure out its own solution. Per Shohei Hido, chief research officer at Preferred Networks, the arms take about eight hours to reach at least 90 percent accuracy — virtually the same time and accuracy as an expert programmer. The payoff of the experimentation model is that the learning is transferable: once one arm figures out a task, that solution can be shared with others rather than each being reprogrammed. This is the experimentation principle of MELDS in practice — actively finding a spot in the process to test AI, letting trial and error derive the method, and then scaling the reimagined process.

• If a process is still routine and un-automated, then automate it first before you experiment on human-machine collaboration.
• If you can articulate a picture of the successful outcome, then set that as the target and let trial and error find the path rather than pre-specifying every step.
• If an AI system performs well in a test, then replicate the variant and deploy it to other parts of the organization; if it performs poorly and can't be improved, then decommission it.
• If you're tempted to copy a leading firm's best-in-class process, then stop — run your own tests to derive what works for your unique conditions.
• If a test lacks real-time data instrumentation, then don't run it yet — you won't be able to measure success from failure or feed the learn cycle.

• Rushing to fill the missing middle before laying the automation foundation. Tell: teams are experimenting on collaborative workflows while routine tasks are still manual and chaotic.
• Treating AI as a tool to automate existing static processes rather than reimagine them — the early-GPS trap versus Waze. Tell: the 'reimagined' process is just the old process digitized, with no adaptation to real-time data or human input.
• Copying another firm's best practice and calling it experimentation. Tell: the process was imported wholesale and never tested against your own conditions.
• No measurement layer, so trial-and-error becomes just error. Tell: you can't say whether a given AI system is performing well or poorly, so nothing gets promoted or decommissioned.
• Punishing failure instead of learning from it, killing the trial-and-error appetite. Tell: employees stop proposing tests because a failed pilot is treated as a black mark rather than a learn cycle.

• ▸Target process/task: name the discrete spot you're testing
• ▸Picture of success: describe the successful outcome the system aims for
• ▸Human vs. machine hypothesis: what humans do, what machines do, where they collaborate
• ▸Automation prerequisite: confirm routine work here is already automated
• ▸Data instrumentation: what real-time/granular data you'll collect to measure
• ▸Cycle plan: how each build-measure-learn iteration feeds the next
• ▸Promote/demote criterion: the performance threshold that decides scale or decommission
• ▸Scale path: where a proven variant gets replicated next

1. 1Commit to responsible AI use from the start—before you deploy, name the ethical, moral, and legal implications of each system in writing, so leadership review precedes rather than trails production.
2. 2Set three non-negotiable technical requirements for every deployed system: it must generate explainable results, promote algorithmic accountability, and eliminate biases. Reject systems that cannot meet all three.
3. 3Stand up a machine relations manager function that runs regular performance reviews of AI systems: promote and replicate variants that perform well, demote and decommission those that perform poorly.
4. 4Protect employee agency: audit AI-augmented processes for whether the people working alongside the systems retain decision-making authority, and redesign any process that reduces workers to passive executors.
5. 5Fund training and retraining as a core line item of AI strategy—invest in people so they can assume the new missing-middle roles (training, explaining, sustaining algorithms), not as an afterthought.
6. 6Sequence the rollout: lay the foundation first by developing employees' full potential and applying automation to routine work, then move to human-machine collaboration rather than rushing to fill the missing middle.
7. 7Install societal guardrails through 'responsible normalizing'—actively shape the purpose and perception of human-machine collaborations as they affect individuals, businesses, and society, so benefits accrue broadly.

At the BMW plant in Dingolfing, Germany, a worker and a lightweight, surroundings-aware robot arm collaborate to build a transmission: the worker preps the gear casing while the robot picks up and precisely seats a twelve-pound gear, then turns to the next. Responsible leadership here is visible in the design choice itself—the robot is engineered to be sensitive to and aware of its surroundings, keeping the human safe and in the loop rather than fenced off from an automated line. The worker retains meaningful tasks and agency (wiping the nozzle, loading glass, carrying finished windows in the adjacent window-adhesive cell), which is exactly the agency-preservation the leadership principle demands. Leadership's job is to look beyond jobs displacement and reimagine roles in the missing middle so people still do what people do well—adapt and find creative solutions—while machines handle the heavy lifting and monotony. This is the 'L' in MELDS made concrete: a deployment that is safe, keeps humans empowered, and is paired with the retraining commitment that lets those maintenance and assembly workers fuse their skills with the new systems.

• If a system cannot produce explainable results, then do not deploy it—explainability is a gate, not a feature to add later.
• If an AI-augmented process leaves employees feeling they've lost agency, then redesign the process so decision-making empowerment increases, because sustaining human agency is a leadership requirement.
• If an AI system's performance reviews show poor results, then demote it and consider decommissioning; if strong, replicate the variant and deploy it elsewhere.
• If you are tempted to rush to fill the missing middle, then stop and first develop employees' potential and automate routine work—foundation precedes collaboration.
• If a deployment would concentrate benefits narrowly, then establish guardrails so the benefits of evolving AI accrue to all of humanity.

• Treating responsible AI as a post-launch compliance patch—the tell: ethical, moral, and legal review happens only after systems are already in production.
• Deploying black-box systems and calling audits 'in progress'—the tell: no one on the team can explain a given output or trace accountability for a decision.
• Framing AI purely as jobs displacement—the tell: leadership discussion centers on headcount reduction with no plan for missing-middle roles or retraining.
• Cutting training budgets as a cost—the tell: AI strategy documents contain automation ROI but no line item for employee retraining, leaving people unprepared for new roles.
• Letting augmentation erode agency—the tell: workers report following AI recommendations they can't question or override, and empowerment in decision making has dropped rather than risen.

• ▸System name & process: which process this AI enters and who works alongside it.
• ▸Ethical/moral/legal review: implications named and signed off before deployment (yes/no + owner).
• ▸Explainability: how results are made explainable to affected users and reviewers.
• ▸Algorithmic accountability: who owns outcomes and how decisions are traced.
• ▸Bias check: what biases were tested for and eliminated before go-live.
• ▸Agency safeguard: how workers retain/gain decision-making empowerment in this process.
• ▸Training plan: retraining committed for people assuming new missing-middle roles.
• ▸Machine relations review cadence: schedule for performance reviews, promote/demote/decommission criteria.
• ▸Societal guardrail: how purpose and perception are shaped so benefits accrue broadly.

1. 1Inventory every source of data your intelligent systems could consume, including exhaust data — the byproduct data thrown off by other processes, such as cookies from customer web browsing. Do not assume the useful data is only the data you deliberately collect.
2. 2Assess both volume and variety, since AI requires extensive amounts of both. Map where rich, varied streams already exist (sensor feeds, transaction logs, crowd-sourced signals) and where you have only static snapshots.
3. 3Break departmental silos so data flows freely, unencumbered across functions. Identify each place where a silo blocks a stream and assign an owner to open it.
4. 4Build the capture-clean-integrate-curate-store pipeline as a real-time flow, not a periodic batch. Model it on Waze rather than early GPS: combine AI algorithms with live data so the system updates continuously instead of digitizing a static route.
5. 5Instrument physical and digital processes to generate the field data intelligent systems need — attach sensors where the signal lives, even transiently, as GE does by placing sensors on turbine parts that burn off at operating temperature after the cold-to-hot transition data is captured.
6. 6Feed the curated flow back into the missing middle so it supports, sustains, and improves both AI and human performance, and build digital twins where holistic optimization across many assets is possible.
7. 7Treat data supply chain building as one of management's five crucial activities (the 'D' in MELDS), funded and governed as a standing capability, not a one-off project. Pair it with responsible-use governance so results stay explainable and free of bias.

GE runs a working data supply chain across its industrial products. It attaches sensors to the hottest parts of turbines to capture physical changes during the cold-to-hot transition; the sensors literally burn off at operating temperature, but the data is already collected. That captured field data lets engineers understand the thermodynamics of turbine materials and improve operating conditions, and it feeds digital twins of deployed jet engines that engineers use to test virtual flights through cold, heat, dust, rain, and bird strikes. GE extends the same flow to 10,000 monitored wind turbines whose digital twins adapt in real time, revealing that running the leading turbine slower lets the ones behind absorb energy closer to optimal, raising total farm output. GE estimates digital twins could increase wind-farm output by 20 percent and deliver $100 million of value over the life of a 100-megawatt farm. The point: capture rich varied data, integrate and curate it into a real-time flow, and let it optimize whole systems rather than single assets.

• If a process only digitizes a static artifact (like an early GPS map), then it is not yet a data supply chain — rebuild it to ingest real-time data like Waze before layering AI on top.
• If data is trapped behind a departmental silo, then treat that silo as a supply-chain break and open the flow before scaling any AI use case.
• If a process throws off exhaust data as a byproduct, then capture and prepare it — it is often the cheapest source of AI fuel you already own.
• If you can only optimize a single asset, then check whether pooled data (e.g., a whole wind farm or a fleet of robots sharing learning) enables holistic optimization worth far more.
• If the AI cannot produce explainable, bias-free results from the data, then fix governance of the supply chain before deployment, since responsible use is a leadership commitment from the start.

• Treating data supply chain as a storage project rather than a dynamic real-time flow — the tell is batch refreshes and dashboards that lag actual conditions, like GPS that can't reroute midcourse.
• Underinvesting in accumulation and preparation, which the passages name as one of the biggest challenges — the tell is data scientists spending most of their time cleaning rather than modeling, and stalled AI pilots.
• Ignoring exhaust data because it wasn't collected on purpose — the tell is teams saying 'we don't have data' while byproduct streams sit unused.
• Optimizing only volume and neglecting variety, or vice versa — the tell is a model starved of the rich, varied signals it needs even though you have terabytes of one narrow type.
• Leaving silos intact so data can't flow freely — the tell is duplicated, inconsistent datasets per department and use cases that can't be combined across functions.

• ▸Source name: name each data stream, including at least one exhaust/byproduct source
• ▸Type — volume & variety: rate the richness and quantity of this stream
• ▸Capture method: how it is instrumented (sensor, log, crowd-sourced, transaction)
• ▸Silo/flow status: is this stream free-flowing or blocked, and by whom
• ▸Clean/curate step: what preparation is required before AI can use it
• ▸Real-time vs. static: does it update live or only in batch — target state
• ▸Consuming system + missing-middle use: which AI/human collaboration it fuels
• ▸Governance check: is the output explainable and bias-checked (yes/no + owner)
• ▸Owner & next action: single accountable person and the next step to close a gap

1. 1Map each of the eight fusion skills to a specific role in your process: rehumanizing time (free up hours for distinctly human work), responsible normalizing (set purpose/perception norms), judgment integration (decide amid machine uncertainty), intelligent interrogation (question the AI across abstraction levels), bot-based empowerment (offload tedious tasks to punch above your weight), holistic melding (build mental models of the AI), reciprocal apprenticing (teach the AI while it trains you), relentless reimagining (redesign the process itself).
2. 2Start with rehumanizing time: audit the process, identify tedious/repetitive/dangerous tasks to hand to machines, and reclaim that time for judgment, learning, and reimagining — the way Rio Tinto pulled operators out of dangerous mining conditions and into analysis roles.
3. 3Practice intelligent interrogation by learning to ask the AI agent questions at multiple levels of abstraction so the output actually gives you the insight you need, not just data — as the Canadian insurance analyst trains the system to extract insights tailored to individual preferences.
4. 4Build holistic melding by forming an accurate mental model of what the AI does well (real-time processing of copious data) and where it is uncertain — so you know when to apply judgment integration and override or accept its output.
5. 5Set up reciprocal apprenticing loops: assign humans to teach the AI new skills (as with tailoring the news-analysis system to an analyst) while they simultaneously undergo on-the-job training to work inside the AI-enhanced process.
6. 6Apply responsible normalizing early: shape how the collaboration is perceived by individuals, the business, and society so people see the machine as a symbiotic partner amplifying skills, not an adversary replacing them.
7. 7Use relentless reimagining as the recurring loop: don't automate a linear stepwise process as-is; overhaul the whole process for exponential improvement, thinking as Waze does about traditional processes being completely reimagined.

At the BMW plant in Dingolfing, a worker and a lightweight, environment-aware robot arm build a transmission together. The worker prepares the gear casing (a judgment and dexterity task) while the robot picks up and precisely places a twelve-pound gear (a repetitive, physically demanding task) — this is rehumanizing time in action, offloading the tedious lifting so the human focuses on the next distinct task. On another line, a robot evenly applies black adhesive to car windows while a worker wipes the glue nozzle, pops in new glass, and carries away finished windows, a choreographed melding where each party does what it does best. Because the assembly is self-adapting, human-machine teams can be assembled on the fly to fulfill customized orders — reciprocal apprenticing and relentless reimagining baked into the system so no manual overhaul is needed. The result is not replacement but symbiotic partners pushing each other to higher performance in the missing middle.

• If the machine outputs a result under uncertainty, then apply judgment integration — you choose the course of action, not the algorithm.
• If a task is tedious, repetitive, dangerous, or high-volume data processing, then hand it to the machine (bot-based empowerment / rehumanizing time) and reallocate that human time to learning and reimagining.
• If the AI's answer isn't giving usable insight, then re-interrogate at a different level of abstraction rather than accepting the first output.
• If people perceive the AI as a job threat, then invest in responsible normalizing before scaling — reframe it as augmentation, or adoption stalls.
• If you are only automating an existing linear process, then stop and apply relentless reimagining — modest gains will eventually stall out; breakthrough gains come from redesigning the process.

• Treating AI as a replacement for humans rather than a collaborator — the tell: you measure success by headcount cut, and productivity gains plateau instead of achieving orders-of-magnitude improvement.
• Automating the old process instead of reimagining it — the tell: your process is still linear, stepwise, and standardized, and results stall out after modest early gains.
• Skipping reciprocal apprenticing — the tell: the AI never improves for your specific context and workers never learn to work inside the AI-enhanced process, so the two never mesh.
• Poor intelligent interrogation — the tell: you accept the AI's first output and complain it isn't useful, rather than re-asking across levels of abstraction.
• Neglecting responsible normalizing — the tell: adoption resistance and a man-versus-machine culture, because no one shaped the purpose and perception for individuals, business, and society.

• ▸Process/task under review: name the specific workflow you are reimagining.
• ▸Rehumanizing time — tedious tasks to offload: list tasks to hand to machines and the human time reclaimed.
• ▸Bot-based empowerment — where AI helps you punch above your weight: name the superhuman capability (e.g., real-time data analysis).
• ▸Intelligent interrogation — key questions and abstraction levels: what you will ask the AI to get real insight.
• ▸Holistic melding — AI mental model: what the agent does well and where it is uncertain.
• ▸Judgment integration — decision points under uncertainty: where a human must choose the course of action.
• ▸Reciprocal apprenticing — teaching/training loop: what humans teach the AI and what humans must learn.
• ▸Responsible normalizing — purpose and perception plan: how you frame this for individuals, business, society.
• ▸Relentless reimagining — process redesign target: the novel overhaul for exponential (not modest) improvement.