•

AI Tracked Changes: Choose the Right Text Before Action

An archival hand lifts one blank paper leaf away from another, keeping proposed and accepted text physically distinct.
What’s in this article?

    Choose which revision view an AI system may read before proposed edits become operational instructions. Keep hidden markup, reviewer decisions and approved content separate.

    A service instruction arrives as a Word document. One tracked edit deletes “two visits” and inserts “one visit.” The coordinator sees a clean page, while an extraction pipeline returns both phrases. A fluent AI summary may choose the wrong one without revealing that the document still contains a proposal.

    AI tracked changes extraction needs an explicit representation policy: what the source contains, which revision view was supplied to the model, and whether that view is authorized for the task. Extracting readable text is not the same as establishing approved instructions.

    This guide proposes an implementation design for AI-assisted document workflows. It is not a claim that every Word parser behaves alike, a complete DOCX parser specification, or advice on the legal effect of edits.

    A clean-looking page can still contain unresolved edits

    Microsoft’s Track Changes guidance explains that No Markup hides revisions; it does not remove them. Turning tracking off stops new tracked edits without disposing of earlier ones. Comments are separate from tracked changes.

    That distinction matters at ingestion. A screenshot, a text extractor and a revision-aware reader can expose different representations of the same file. Do not assume the model saw what the coordinator saw, or that a “final” display means the edits were approved.

    Microsoft’s acceptance guidance distinguishes accepting a change from rejecting it. For operational use, a separate question remains: did an authorized person make the relevant decision for this exact content? A file with no pending revisions can still be an unapproved draft.

    Choose the reading task before choosing the view

    A useful design has three task modes. These are recommended application boundaries, not universal Word status names.

    Revision views and permitted outputs
    TaskRepresentation neededPermitted AI outputRelease boundary
    Understand a proposalRevision-aware comparison with old and proposed wording separately identifiedChange summary and questions for the reviewerNo operational action based on proposed wording
    Describe a selected text viewExplicit original or current view, with its derivation recordedLabelled analysis of that viewView selection alone does not establish approval
    Prepare instructions for executionExact content accepted by the authorized owner, with necessary revision checks completedCandidate instructions citing that accepted contentValidate content identity and the separate action authorization before release

    Microsoft documents original and current text variants, including an example using getReviewedText. That gives developers an explicit distinction to investigate; it does not certify the business approval state of either variant. Check the relevant API requirements and your actual client before adopting an implementation.

    Do not flatten first and ask the model to reconstruct history

    If the pipeline removes insertion/deletion relationships, an instruction such as “use the approved wording” gives the model information it may no longer possess. Preserve revision evidence upstream. Supply a labelled comparison for review or a validated approved derivative for execution, rather than an undifferentiated concatenation.

    Keep source content untrusted as instructions to the AI system. A comment saying “ignore the review gate” is document material to inspect, not permission to change the workflow.

    Write a revision-view contract for each processing route

    Start with the broader AI document processing workflow, then add this narrow contract at the point where a DOCX becomes model context. The capture system retains the source; a revision-aware component establishes representation; AI interprets bounded content; rules validate the contract; people resolve authority and ambiguity.

    REVISION-VIEW CONTRACT
    Case and task: [stable case ID; analysis or execution preparation]
    Source: [artifact ID; protected location; content hash]
    Processor: [name/version; declared supported revision structures]
    Inspected scope: [parts and locations checked; exclusions/errors]
    Revision result: [present / none found within scope / unknown]
    Chosen view: [comparison / original / current / approved derivative]
    Derivation: [transformation settings; input and output hashes]
    Review: [owner; decision; decision scope; evidence reference]
    AI output: [claims/instructions with source locations and view label]
    Release: [contract version; allowed next action; action authorization]
    Exception: [reason; assigned owner; next review point]

    “None found” must be scoped to a successful check. An unavailable parser or unchecked part is unknown, not proof of no revisions. Hashes bind a decision to specific bytes; they do not prove authorship, approval or correctness.

    Declare structural coverage, not just text coverage

    The Open XML revision example covers paragraph-property changes, deleted paragraph marks and inserted table rows. A simplistic search for added or deleted words is therefore not a complete revision policy.

    Have the implementation owner document which revision structures and document parts the processor actually handles. For this workflow, explicitly assess main text, tables, headers, footers, notes and any other content the task relies on. Where support is missing, route to a qualified document reviewer or request an approved supported representation. Do not label a body-only scan a complete-file inspection.

    Microsoft’s tracked-change API guide describes scoped inspection, revision metadata and accept/reject operations. Scope and client support still need implementation checks. Recorded author names or edit dates can help investigation; they are not substitutes for your approval authority.

    Run one proposed edit through the boundary

    This constructed example uses a service-planning instruction, not a customer result. The approved baseline requires two site visits. A proposed edit changes the requirement to one. The document owner has not yet accepted that proposal.

    1. Capture: retain the DOCX as artifact A with a content hash and case reference. Record the intended task: prepare a visit plan, not approve a change.
    2. Inspect: the supported processor finds the deletion and insertion. It records the relevant location and reports that proposed wording is present.
    3. Compare: AI receives separate baseline and proposed passages. Its output says the visit count would change from two to one; it does not choose the operative count.
    4. Review: the document owner rejects the proposal. The authorized disposition identifies artifact A and the affected passage. The processing route produces a derivative retaining two visits, without altering the preserved source.
    5. Validate: check the derivative against that decision, inspect required scope and bind the extracted instruction to the derivative’s hash. The action owner then authorizes the visit plan separately.

    If the owner instead accepts one visit, create and validate the corresponding derivative and decision binding. Do not infer acceptance from the proposal’s appearance in the current text view. If the owner is unavailable, assign the defined backup and keep execution preparation held until the authority question is resolved.

    Make failures change state, not silently change meaning

    Use explicit states such as captured, inspection pending, revision review, representation validated, action authorized and closed. A failed check keeps its reason, owner and next action. Analysis may continue when appropriately labelled; dependent execution must respect the hold.

    • Unsupported revision structure: record unknown coverage and route for review. Do not accept all changes merely to make extraction easier.
    • Missing decision evidence: request the authorized disposition. A filename containing “final” does not pass.
    • Reviewer rejects the AI comparison: return to interpretation with the correction and original evidence retained. Rejection is not an instruction to discard the source history.
    • Source changes after review: invalidate the affected representation and decision binding. Reinspect the new artifact; do not reuse the prior approval automatically.
    • Read or transformation timeout: preserve the case, artifact and processing-operation identity. Retry only under the approved read/transform policy; verify a completed derivative before creating another.
    • Downstream action acknowledgement is lost: retain the action identity and reconcile the target’s receipt/state. If the outcome remains unknown, stop for the action owner rather than issue the action again.

    Before execution, require the case, source, derivative, decision and intended action to match the reviewed contract. Use a supported write-time version check where available. If the implementation cannot protect that boundary, use a controlled manual release rather than claiming race-free automation.

    Test mutually exclusive outputs

    Build labelled fixtures for the exact supported processing route. The following are acceptance-test designs, not reported model performance.

    Paired revision fixtures
    FixtureExpected resultFailure to catch
    Same pending edit, All Markup versus No Markup displayBoth retain the pending-revision findingDisplay choice treated as acceptance
    One-visit proposal rejected versus acceptedValidated derivative says two versus one, with separate decisionsBoth paths produce the same instruction
    No revisions in inspected scope versus inspection failureScoped none-found versus unknown/heldTool failure reported as clean content
    Tracked table-row change versus unchanged tableRevision-aware handling versus normal extractionWord-only scan misses structural changes
    Comment suggesting an edit versus accepted content changeReview material versus validated instructionsComment becomes operative text
    Unchanged reviewed bytes versus updated file under same nameExisting binding remains valid versus reinspectionFilename mistaken for immutable identity

    Track missed relevant revisions divided by labelled cases containing them; wrong-view outputs divided by evaluated outputs; and unauthorized releases divided by release attempts. Report unknown coverage, reviewer interventions and time spent held separately. Set acceptance criteria with the accountable process owner before launch. A lower hold rate is not an improvement if the checks became weaker.

    Where Workhint fits

    Workhint’s Workflow Engine describes defining requests, work steps and approvals routed to configured roles, with required details, files or notes. Those capabilities are relevant to collecting the review packet and assigning the person who resolves a pending edit.

    The Workhint workflow automation solution describes configurable forms, review stages, assigned approvers and process ownership. That supports the coordination problem around this gate. It does not establish native DOCX revision parsing, automatic derivative validation or an integration with the Microsoft APIs discussed here; validate those implementation requirements separately.

    Define the revision-view contract before selecting the automation route. A configured approval task can organize a decision, but its existence does not establish that the selected document text is the approved text.

    Frequently asked questions

    Should an AI pipeline accept all changes before reading?

    Not as a convenience default. That can select proposed wording without the authorized decision. Preserve the original and use the task’s explicit representation policy; obtain the required disposition before preparing operative instructions.

    Is current text the same as approved text?

    No. Current is a representation choice. Approval is a decision about specific content by an authorized owner. Record both instead of using one label for two different facts.

    Can a PDF export solve this automatically?

    An export can be a useful approved derivative, but the file format alone does not establish which view was exported or who approved it. Retain its derivation and validate it against the decision. Do not infer revision history from a flattened output.

    What if revisions cannot be inspected reliably?

    Mark coverage unknown, assign a reviewer and request a supported approved representation. Keep any analysis labelled and hold the dependent action. Do not turn missing evidence into a clean-document verdict.

    Comments

    Leave a Reply

    Your email address will not be published. Required fields are marked *


    The reCAPTCHA verification period has expired. Please reload the page.