How it works

How it works — and how you know it's right.

What goes in, how ClearWork works out what's missing, what the human approval gate actually does, what comes out the other end, and how it stays true once the project moves on.

Every line links back to the interview, page or timestamp behind it Source-linked
The shape of it

Three acts, running on a loop.

Not a one-off exercise you finish. A cycle that keeps running for as long as the process or the engagement does.

01

Source

Read everything that's already written down. Work out what's missing from it. Then go and ask the people who know — by interview link, on their own time.

02

Validate

Every finding arrives as a proposed change with its source attached. A person on your team accepts, edits or rejects it. Nothing enters the record on its own.

03

Create

Process maps, requirements, SOPs, user stories and summaries generate from the confirmed record — and flag themselves when a source behind them changes.

Act one · Source

Start with what exists. Then go get what doesn't.

Most of a process is already documented somewhere. The part that matters usually isn't.

Step one

Everything you already have goes in first.

Documents, decks, SOPs, spreadsheets, existing process maps, policy manuals, meeting transcripts, recordings. ClearWork reads all of it and drafts a first baseline of the current state.

You're not starting from a blank canvas, and you're not paying anyone to retype what's already written.

DocumentsDecksSpreadsheets TranscriptsRecordingsExisting maps
Source documents imported into a ClearWork project
Existing material becomes structured source knowledge, not an attachment folder.
Step two

It works out what's missing — and names it three ways.

ClearWork reads what it has against what the work actually needs, then separates the gaps rather than lumping them together as "issues":

Variations — the same process run differently by two teams or sites. Conflicts — two sources that disagree, both surfaced with their evidence. Unknowns — nobody has said yet, tracked as an open gap rather than filled with a plausible guess.

You review the plan and approve it before a single interview goes out.

Generated discovery plan showing baselines, gaps and assigned interviews
Baselines, gaps and the interviews needed to close them — for your approval.
Step three

Then it asks the people who know.

Interview links go out by email, by role and by gap. Each opens a private response page — no scheduling, no human interviewer waiting, no calendar tetris across shifts and time zones.

This extends live discovery rather than replacing it. Run your workshops. Async interviews reach the second-shift supervisor, the regional team, and the person who was on leave that week.

Interview assignment table showing topics, methods, respondents and status
Assigned by process area and role, tracked to completion.

Voice or chat

A conversation that follows up on ambiguity and asks the second question — whichever the person prefers.

Structured questions

Targeted by role, process area and the specific gap being closed.

Screen walkthrough

A narrated day-in-the-life recording, so they show you the workflow instead of describing it.

Files and context

Screenshots, spreadsheets and notes that would normally disappear after a call.

Whether async interviews suit your organisation depends on its culture. Some teams use them constantly; others upload their own transcripts and never touch them. Both produce the same record — the interviews are a way to reach further, not a requirement.

Act two · Validate

Nothing enters the record until a person confirms it.

This is the part that makes the rest of it trustworthy, and it's the part a chat assistant has no equivalent for.

Human gate
Document review showing proposed changes with their sources, awaiting accept, edit or reject
Shown
What it is
The proposed change, in context, alongside what the record currently says.
Shown
Where it came from
The interview moment, document page or recording timestamp behind it.
Shown
What it affects
Which existing artifacts will need review if you accept it.

"But how do I know it read the document correctly?"

Fair question, and a different one from traceability. Traceability tells you where a line came from. It doesn't tell you the extraction was right.

So the record shows its work. Every claim carries what it pulled and how confident it is. Ambiguity is flagged rather than resolved quietly. Where two sources disagree, both are surfaced with their evidence rather than one being silently chosen. Where nothing supports a claim, it stays an unknown instead of becoming a plausible guess.

Then a person confirms it. The gate is the answer, not the citation.

Act three · Create

The deliverables generate from the confirmed record.

Not from a template you populate by hand, and not from a prompt you have to re-engineer every time. From the validated knowledge underneath.

Generated process flow diagram

Process maps & swimlane diagrams

Role-based flows with handoffs, decision points, system touchpoints and the exception paths that only surfaced in interviews.

Generated user stories with source provenance

Requirements, RTMs & user stories

Functional and non-functional requirements, traceability matrices, epics and acceptance criteria — each item linked to what produced it.

Every line source-linked
Generated standard operating procedure

SOPs & work instructions

Procedure documents written from how the work is actually done, including the exceptions the old SOP never mentioned.

Generated executive summary

Summaries & roadmaps

Current-state reads, gap analyses and leadership-ready narratives grounded in the same validated record.

Risk & gap registers

What's unresolved, unmapped or dependent on a decision.

KPI definitions

Metrics grounded in what teams actually do, not assumed cycle times.

Exports

Word and PDF for documents, Visio and draw.io for diagrams, structured formats for requirements.

And then it keeps going

When a source changes, the document tells you.

Discovery isn't a phase that ends. The loop keeps running for as long as the process or the engagement does.

Every artifact stays connected to the sources behind it. When one of those changes — a corrected interview answer, a new policy, an updated procedure — every document built on it flags itself for review, with the change summarised and linked to what caused it.

A person approves it. Version history records who and when. Nothing rewrites itself behind your back, and nothing goes stale quietly.

Source-linked

Every output traces to the knowledge that produced it.

Version history

What changed, when, and who reviewed it.

Owners & reviewers

Assigned, so documents don't become orphaned.

Review cycles

Scheduled re-checks plus flags when a source moves.

A document flagged for review after its source changed, with version history and approval
The question everyone asks

Why not just do this with Claude or ChatGPT?

Start with what's true: a good model can draft a solid process map from documents you paste into it. That was never the hard part, and it gets easier every month. We're not betting against the models — we use them. The difference is everything around them.

 
An LLM on its own
ClearWork
Reaching what isn't written
Can only work with what you paste in. It can't notice that one team does it differently and go ask them.
Identifies the gap, then sends an interview to the person who can close it.
Repeatability
Ask twice, get two different documents. Correct it, and the correction survives until the context window forgets.
A correction becomes a fact the system honours from then on. Every artifact built on it re-surfaces for review.
Structure you can navigate
A conversation. Nothing to browse, nothing to hand to the next person on the project.
A typed, linked record of people, roles, processes, systems, decisions and risks.
Evidence
You can ask for citations. You can't click a line and land on the moment someone said it.
Every line links to the interview timestamp, document page or recording behind it.
Who maintains it
Someone on your team, indefinitely — and every model release destabilises the prompts and rules holding it together.
The system does, and tells you when something needs a human decision.

The question isn't whether an AI could draft this.
It's who maintains it on Tuesday.

You could build most of this yourself with a model, a folder of prompt templates and a set of rules. Plenty of teams start there. The honest question is whether maintaining that rig is the job you want.

Straight answers

Built for knowledge that isn't yours to leak.

Client engagements and internal operations both carry material that can't go wandering. Here's where we actually stand.

Live now

  • No AI training on your data. Documents, interviews, transcripts and recordings are contractually excluded at the provider level.
  • Project-level isolation. No shared context or cross-project retrieval between engagements.
  • Role-based access. Scope people to specific projects, process areas or read-only review.
  • Human approval on every change that enters the record.
  • Full version history — what changed, when, and who reviewed it.
  • Source traceability on every generated line, so any finding can be challenged.
In progress

SOC 2. Underway. Ask us on a call and we'll give you a real status rather than a reassurance.

Questions

The ones that come up on calls.

Do we have to use the AI interviews?

No. Plenty of teams run discovery exactly as they always have — workshops, live sessions, their own note-takers — and upload the transcripts and documents that come out of it. That produces the same validated record.

The interviews exist to reach further than your calendar allows: the second-shift supervisor, the regional team, the person who was on leave. Whether your organisation takes to them varies a lot by culture, and that's fine either way.

Does this replace live workshops?

No, and we'd argue against it. Live sessions are where you read the room, resolve disagreements and build buy-in. Nothing async does that.

What async does is extend the reach and then keep the record current after the workshop ends — which is where documentation normally starts drifting.

How long before we see something usable?

Upload what you already have and you have a first baseline the same day. A single process with six or seven interview responses typically produces a current-state map, an exception list and a list of open gaps inside a week.

That's why the trial is fourteen days rather than a pilot programme — it's long enough to do one process properly.

What if two people describe the same process differently?

That's a conflict, and it's one of the more valuable things the system finds. Both versions are surfaced with their evidence rather than averaged into something true for neither.

If it's a genuine difference rather than a disagreement, it's recorded as a variation — so you can decide what to standardise and what variation is legitimate.

Can it generate process maps and swimlane diagrams?

Yes — role-based flows, handoffs, decision points, system touchpoints and exception paths. The difference from a diagramming tool is that the map is generated from the underlying record rather than drawn by hand, so it carries the context behind each step and can be challenged line by line.

Diagrams export to Visio and draw.io.

What happens to the record when the project ends?

It stays intact. Consulting projects can be archived and reactivated if the client returns for a later phase — everything is where you left it. Internal teams keep the record as the starting point for the next initiative rather than beginning discovery again.

Is this process mining?

No, and it's worth being clear about. Mining tools read system logs and tell you what your systems recorded — that's real, and it's roughly 40–50% of the picture.

ClearWork captures the rest: the judgment calls, exceptions, workarounds and reasons that happen in a spreadsheet or a hallway conversation and never touch a system of record. If you already run a mining tool, these complement each other. Analytics over system data isn't something we do today.

Bring one real project. We'll run it through.

A few documents, a recording, and the questions you need answered. Fourteen days, your own material, and a real read at the end of it.

Start free — 14 days Book a 30-minute call
Founder-led support · No AI training on your data · Cancel anytime