The ESSII Framework: Five Ways to Transform a Process, Not Just Automate It

The default answer to "how should we transform this process" in 2026 is "add AI to it". That answer is correct maybe 20% of the time. The other 80% of the time the right answer is to remove the task entirely, to simplify the form the task produces, to standardize the variants that have proliferated, or to integrate with a system that already does the work. An AI on top of an over-complicated, poorly standardized process just gives you an expensive over-complicated, poorly standardized process. Framework first, AI decision second.

ESSII is five axes of process improvement in the order you should consider them: Eliminate, Simplify, Standardize, Integrate, Intelligize. LucidFlow runs every task through all five and returns the recommended approach as the dimension that scores highest for that specific task. The order matters: a task you can eliminate does not need to be intelligized; a task you can integrate with an existing system does not need a bespoke AI agent. The framework pushes you to cheap answers before expensive ones.

A task can be eliminated when it produces no value to the process outcome, it is checking something that has already been checked, creating a report nobody reads, approving something that has no policy basis for disapproval. Eliminate is the first axis because the saving is the full cost of the task forever: zero infrastructure to maintain, zero tool subscription to pay, zero training to onboard. The bar for eliminate is correspondingly high: you have to be sure the task really contributes nothing.

• Redundant approvals: three people approve the same thing with no authority distinction. Remove two of the three; keep the one who has actual signing power.
• Vestigial reports: a weekly report that five years ago mattered, now nobody opens. Elimination test: stop sending it for a month and see who asks.
• Status-update tasks: a human summarizes what the system already logs. The system's log is the status.
• Formal double-checks: a second person verifies a first person's work on tasks where the first person has never been wrong. Replace with random sampling.

Eliminate sounds aggressive but is usually the easiest political sell because the cost saving is large and concrete. If a task runs 200 times per month and you eliminate it, that is 200 × the task's full cost saved every month with no downstream integration risk. The LucidFlow classifier flags a task as an eliminate candidate when its value-stream classification returns "pure waste": a formal designation in the Lean Six Sigma tradition, not a rhetorical one.

Simplify means the task's purpose is legitimate but the current implementation is over-engineered: a three-page form when a one-field form would do, a fifteen-step procedure when the first three steps are always sufficient, a committee review when a delegated decision would reach the same outcome. Simplify is a reduction in complexity, not in count. The task still happens; it just takes less time, fewer people, or less input data.

Simplify candidates are often the easiest wins to identify but the hardest to ship, because the complexity exists for a reason: usually a one-off incident three years ago that led to a permanent process addition. Surfacing that reason and asking whether it is still relevant is the honest work of simplify. The LucidFlow classifier flags a task as a simplify candidate when it has disproportionately high duration for its output: a signal that the task does more work than its value justifies.

Standardize targets variance. The task is legitimate and correctly sized, but it runs differently in four different teams, or in four different branches of the diagram, or on four different data formats. Each variant is defensible on its own; the collective cost of the variance is the need to train people on four procedures, tool four different implementations, and debug four different failure modes. Standardize collapses the four variants into one, accepting that one variant will not be perfectly optimal for every case.

Standardize is where the most quietly expensive processes live. Nobody loses sleep over a slightly different variant of the same task; everyone loses time on the onboarding cost of learning all the variants. A process that runs in four variants is often identifiable because the training documentation mentions "depending on which team" or "if the input comes from region X": the variance is baked into the description itself. Standardize is also the axis most likely to be a prerequisite for integrate and intelligize: an AI cannot reliably intelligize a task that has four silent variants.

Integrate is the axis that catches redundancy across systems rather than across tasks. A task that copies data from the CRM into the billing system is a classic integrate candidate: the billing system can read from the CRM's API and the human transcription is pure overhead. A task that reconciles two reports pulled from two systems that already share an underlying database is another integrate candidate. The general pattern: the data exists, the system can retrieve it, and a human is acting as an expensive data pipeline.

Integrate usually costs money to implement: integration work, API subscriptions, connector maintenance, but the cost is one-time (or at worst, a small recurring fee) while the saving compounds with every execution. The ROI report's payback period is the number that decides whether integrate is worth it: if the integration costs $8,000 to build and saves $2,000 per month, 4-month payback is a clear yes; if it costs $80,000 and saves $2,000 per month, the question is harder.

Intelligize is the axis most people reach for first and should reach for last. It means applying AI: specifically, an LLM or a specialised ML model: to a task that requires judgement: classifying ambiguous inputs, drafting text that needs review, making a probabilistic decision with incomplete data. If the task is deterministic (eliminate, simplify, standardize, or integrate is usually the right answer) AI is overkill and expensive. If the task genuinely requires judgement, AI is a legitimate tool.

LucidFlow breaks intelligize into three maturity levels rather than treating it as one axis. Companion (formerly Copilot) is human-in-the-loop: AI suggests, human decides. Automation is AI-first with human exception handling: AI handles the routine cases, humans handle the edge cases. Agent is fully autonomous: the AI completes the task end-to-end, with monitoring rather than approval. Each level has a different cost-accuracy-risk profile; the framework forces an explicit choice of level rather than "add AI" as a vague intent.

• Companion: $10–50 per month per user for an AI assistant layer; accuracy is as good as the human (the human is still deciding); risk is minimal because nothing autonomous happens.
• Automation: $100–500 per month for an AI service that handles 70–90% of cases; accuracy on automated cases is typically 95%+ but edge cases need human routing; risk is moderate because autonomous decisions are bounded.
• Agent: $500–2000+ per month for an autonomous agent handling 95%+ of cases end-to-end; accuracy is as good as the training data; risk is higher because the human oversight is sampled rather than continuous.

The v2 classifier runs in three passes. Pass 0 (macro) asks whether the entire process can be replaced by a single platform: a quick sanity check before any per-task work. Pass 1 (diagnostic) runs a value-stream map across every task (value-add / necessary-waste / pure-waste), identifies flow-level issues, and spots bottlenecks. Pass 2 (essii) evaluates every task on all five dimensions and returns the recommended approach: the one that scores highest for that task given its context. The output is a ranked list of approaches per task, not a single forced answer.

The classifier is constrained, it does not freely generate recommendations. It maps each task to patterns from a curated knowledge base of 100 verified automation patterns, and the recommendation for a task is the best matching pattern from the KB, not a freshly invented idea. This design choice prevents the most common AI-transformation failure mode: confident recommendations for patterns that do not actually work. If the KB has no good match, the classifier returns "no intelligize pattern found" and pushes you back toward eliminate, simplify, standardize, or integrate.