When an owner-caused delay hits your project, the difference between recovering the time and the money and absorbing them is a time impact analysis that holds up, and at the center of every TIA is a fragnet, the small fragmentary network of schedule activities that models exactly how the delay propagated through your critical path. Building that fragnet and the TIA narrative around it is specialized, time-consuming schedule work, which is why impacts that deserve a TIA sometimes do not get one, the same friction problem as the ASI impact statement. AI can accelerate the drafting and the structuring, but a TIA is schedule analysis that an arbitrator may one day scrutinize, so the fragnet logic and the entitlement basis stay rigorously human. This lesson shows you how to use AI to accelerate the TIA without producing a fragnet that falls apart under examination.

What a Fragnet Is and Why the TIA Rests on It

A fragnet, short for fragmentary network, is a small set of schedule activities that models a specific impact, inserted into the accepted schedule to show how a delaying event flowed through the logic and pushed the completion date. It is the schedule-analysis core of a time impact analysis, the rigorous demonstration that the delay did not just happen but propagated through the critical path in a specific, traceable way that caused a specific amount of project delay. The TIA uses the fragnet to establish the cause, the effect, and the duration of the impact, which is the foundation of a delay claim that can be defended, and the standard methodology, AACE Recommended Practice 52R-06, frames how a fragnet is built and inserted into the schedule update to model the impact.

The reason the fragnet matters so much is that a delay claim without a rigorous schedule demonstration is just an assertion that you were delayed, which an owner or an arbitrator can dismiss, while a fragnet-based TIA shows the mechanism: this event delayed this activity, which was on or drove the critical path, which pushed completion by this many days. The fragnet is what turns a claim of delay into a demonstration of delay, and the rigor of the fragnet, its correct insertion, its correct logic, its faithful modeling of the actual impact, is what makes the TIA survive scrutiny. This is high-stakes schedule analysis where the consequence of getting it wrong is a defeated claim, so it sits at the strict end of the verification spectrum, and the AI's role is bounded accordingly.

Where AI Helps on a TIA, and Where It Must Not

AI helps with the parts of the TIA that are structured and narrative, and must not touch the parts that are schedule logic. On the helpful side, the TIA includes a substantial narrative, the cause-and-effect explanation, the description of the delaying event, the entitlement argument, the documentation of the contemporaneous records, and that narrative is structured explanatory writing AI can draft fast from the analysis you provide. AI can also help organize the contemporaneous records, the daily reports, the correspondence, the RFI log, into the supporting documentation the TIA narrative references, which is the kind of assembly AI accelerates.

What AI must not do is build or validate the fragnet logic, because the fragnet is schedule analysis, modeling how the delay propagated through the network, that requires understanding the schedule's critical path, the logic relationships, and the actual impact, which is the scheduler's expert work and which the AI cannot reliably perform. An AI that generated a fragnet might produce one with incorrect logic, a wrong insertion point, or a propagation that does not reflect how the delay actually flowed, and a flawed fragnet is a defeated claim, because the opposing scheduling expert will find the error. So the scheduler builds and validates the fragnet, the rigorous schedule analysis that is the TIA's defensible core, and the AI drafts the narrative and assembles the documentation around it, which is the division that captures the drafting speed without risking the analysis that the claim depends on. The fragnet is the scheduler's; the narrative is the AI's draft of the scheduler's analysis.

A flawed fragnet is a defeated claim, because the opposing scheduling expert will find the error. The scheduler builds and validates the fragnet, the TIA's defensible core; the AI drafts the narrative and assembles the records around it. The analysis is human; the writing is AI's draft of it.

The Adversarial Audience and Why It Raises the Bar

The TIA has the most adversarial audience of any document in this level, more adversarial even than the plan checker, because a delay claim that goes to dispute is examined by the owner's scheduling expert and potentially an arbitrator, both of whom are specifically looking to defeat the claim by finding flaws in the fragnet and the analysis. This adversarial scrutiny is why the TIA sits at the strictest verification level: any error in the fragnet logic, any inconsistency between the narrative and the schedule, any unsupported assertion in the entitlement argument is a vulnerability the opposing expert will exploit.

This raises the bar on everything AI touches in the TIA, not just the fragnet. The narrative, which AI drafts, must be consistent with the fragnet and the records in every particular, because an inconsistency between the AI-drafted narrative and the schedule analysis is exactly the kind of discrepancy the opposing expert hunts for, so the verification confirms the AI-drafted narrative matches the scheduler's analysis precisely. The entitlement argument, which establishes the contractual basis for the time extension under the contract's provisions, must cite the real contract provisions correctly, which is the decide-then-draft contract discipline applied at the highest stakes, because a TIA's entitlement argument that misstates the contract basis is attackable on that basis. The adversarial audience means the whole document must be airtight, so even the AI-drafted parts get the strictest verification against the analysis and the contract, because a TIA is read by someone trying to break it, and anything AI got slightly wrong is where it breaks.

The Friction Problem and AI's Real Value

The real value of AI on the TIA is the same friction problem as the ASI impact statement, raised to a higher power: building a complete TIA is enough work that impacts which deserve a TIA sometimes do not get one, because the scheduler does not have the time to build the fragnet, write the narrative, and assemble the records for every delay event. When a TIA is too much work to produce, legitimate delay impacts go unclaimed, the time and money absorbed, exactly as small ASI impacts get absorbed when the response is too much friction.

AI reduces the friction on the parts it can touch, the narrative and the documentation assembly, which lowers the total effort of producing a TIA enough that more legitimate impacts can get the analysis they warrant. The fragnet itself still requires the scheduler's time, that part is irreducible, but if the AI handles the substantial narrative drafting and the records assembly, the scheduler's time concentrates on the fragnet analysis rather than being spread across the whole document, which makes producing a TIA more feasible. This matters because, as with the ASI, the impacts that go unclaimed because the TIA was too much work are real lost recovery, so reducing the production friction means more legitimate impacts get claimed and recovered. The value is not that AI makes the fragnet, it cannot and must not, but that it makes the rest of the TIA fast enough that the scheduler can afford to do the fragnet for more of the impacts that deserve it, which is real recovered entitlement achieved without touching the analysis that the claim depends on.

The Contemporaneous Records and Why AI's Assembly Helps Most There

One part of the TIA where AI's help is both substantial and low-risk is the assembly of the contemporaneous records, the daily reports, weather logs, correspondence, RFI entries, and photos that document the delay as it happened, and understanding why this is the safest high-value AI use on a TIA is worth dwelling on. A TIA's credibility rests heavily on contemporaneous documentation, the records made at the time that show the delay occurring, because records created during the event are far more persuasive than after-the-fact reconstruction, and assembling those scattered records into the organized supporting documentation the TIA references is tedious, time-consuming work that does not require schedule judgment.

This makes records assembly an ideal AI task: it is high-volume organizing work, exactly what AI does well, and it carries low analytical risk because the records are facts being gathered and organized, not analysis being generated, so the AI is finding and arranging existing documents rather than producing schedule logic. The discipline is light here compared to the fragnet, you confirm the assembled records are the right ones and actually support the assertions they are cited for, but the assembly itself is truly accelerated with little risk, because a misfiled record is a quick fix while a flawed fragnet is a defeated claim. This is a clean example of matching the AI to the task by risk: the fragnet, high analytical risk, stays entirely human, while the records assembly, low analytical risk and high tedium, is heavily AI-accelerated, and recognizing which parts of a complex deliverable are which lets you apply AI aggressively where it is safe and not at all where it is dangerous, which is the nuanced tool-matching that distinguishes skilled AI use from blanket adoption or blanket avoidance.

The Cause-Effect Discipline in the Narrative

The TIA narrative's core is the cause-and-effect argument, this event caused this delay to this activity which drove this much project delay, and there is a specific discipline in how AI drafts it that protects the claim. The cause-effect chain must exactly match the fragnet's logic, because the narrative is the prose explanation of what the fragnet demonstrates, and any divergence between the story the narrative tells and the mechanism the fragnet models is a discrepancy the opposing expert exploits. So the AI drafts the narrative strictly from the scheduler's fragnet and analysis, narrating what the fragnet shows, never adding causal claims the fragnet does not support.

The danger specific to AI here is its tendency to produce a smooth, complete-sounding causal narrative that may overstate or simplify the actual causal chain, because a fluent narrative wants to tell a clean story and the real causation may be more nuanced or more carefully bounded than a clean story allows. An AI narrative that claims more causation than the fragnet demonstrates is worse than a plainer one that matches the analysis exactly, because the overclaim is precisely what the opposing expert attacks, showing the narrative asserts more than the schedule supports. So the verification confirms the narrative's causal claims are exactly those the fragnet demonstrates, no more, with the scheduler checking that the AI did not smooth the causation into something stronger than the analysis supports. The narrative must be the faithful prose of the fragnet's logic, and the scheduler's verification that it is faithful, rather than fluently overstated, is what keeps the narrative from becoming the claim's vulnerability instead of its explanation.

The Applied Problem: Produce a TIA for a Weather and Design-Change Impact

Here is the exercise. Take a real or representative delay, for instance a fourteen-day impact from a combination of weather and a design change, and produce a complete TIA with full backup, owner-issuable: the scheduler builds and validates the fragnet, and AI drafts the narrative and assembles the documentation. Run the workflow: the scheduler builds the fragnet modeling how the weather and design-change delay propagated through the critical path, validates it against the accepted schedule per the AACE RP 52R-06 methodology, and determines the entitlement basis under the contract's time-extension provisions; AI drafts the TIA narrative presenting the cause, effect, and duration from the scheduler's analysis, and assembles the contemporaneous records, the daily reports showing the weather, the correspondence on the design change, into the supporting documentation; and you verify the narrative against the fragnet and the records, and the entitlement argument against the contract.

Produce two things. First, the TIA, owner-issuable, with the scheduler's validated fragnet, the AI-drafted narrative consistent with it, the entitlement argument citing the correct contract provisions, and the assembled supporting records. Second, the verification record: confirmation that the narrative matches the fragnet analysis in every particular, the records support the assertions, and the entitlement basis cites the real contract provisions, because that verification is what makes the TIA defensible to an adversarial reader. Treat it throughout as a document an opposing scheduling expert will try to break, verifying everything AI drafted against the scheduler's analysis and the contract.

The deliverable is the defensible TIA and the verification record, and the lasting product is a TIA workflow that lets the scheduler concentrate on the fragnet, the irreducible expert analysis, while AI handles the narrative and the documentation, so more legitimate delay impacts get the rigorous TIA they deserve. This is the scheduling-claims core of the field chapter, and it follows the pattern at its strictest: AI drafts the narrative and assembles the records, the scheduler owns the fragnet and the entitlement, and the whole document is verified against the analysis and the contract for an adversarial audience. The scheduler who masters this produces more defensible TIAs for more impacts in less total time, which over a project with multiple delays is real recovered time and money, achieved because the narrative drafting was fast and the fragnet analysis, the thing the claim lives or dies on, stayed rigorously human.

Key Takeaways

• A fragnet is the small fragmentary network of activities that models how a delay propagated through the critical path, inserted into the accepted schedule per AACE RP 52R-06. It is the schedule-analysis core of a TIA, turning a claim of delay into a demonstration of delay.
• AI helps with the structured and narrative parts: drafting the cause-effect narrative and the entitlement argument from the scheduler's analysis, and assembling the contemporaneous records (daily reports, correspondence, RFI log) into the supporting documentation.
• AI must not build or validate the fragnet logic, because that is schedule analysis requiring understanding of the critical path, the logic, and the actual impact, which the AI cannot reliably perform. A flawed fragnet is a defeated claim, because the opposing scheduling expert will find the error.
• The TIA has the most adversarial audience in the level, the owner's scheduling expert and an arbitrator looking to defeat the claim, so it sits at the strictest verification level. The AI-drafted narrative must be consistent with the fragnet and records in every particular, because an inconsistency is exactly what the opposing expert hunts.
• The entitlement argument must cite the real contract provisions correctly, decide-then-draft at the highest stakes, because a TIA whose entitlement basis misstates the contract is attackable on that basis.
• The friction problem, raised from the ASI: a complete TIA is enough work that legitimate impacts sometimes go unclaimed. AI reducing the narrative and documentation effort lets the scheduler concentrate on the fragnet and afford a TIA for more of the impacts that deserve one, which is real recovered entitlement.
• The artifact: a complete, owner-issuable TIA for a weather-and-design-change impact, with the scheduler's validated fragnet, the AI-drafted consistent narrative, the correct entitlement basis, and assembled records, plus a verification record confirming everything AI drafted matches the analysis and the contract, treated throughout as a document an opposing expert will try to break.