Liability Cap Parsing

The core task of identifying the exact monetary figure that caps a party's aggregate liability. This involves parsing the text for currency symbols, numerical values (both digits and words), and the specific contractual language that ties the cap to a defined scope.

• Pattern Recognition: Models must distinguish between a liability cap ($500,000) and other financial figures like purchase price or insurance requirements.
• Written Number Conversion: The system must accurately parse and convert written numbers (e.g., 'Five Hundred Thousand Dollars') into a standardized numerical format.
• Tiered Caps: Some agreements contain multiple caps for different breach types (e.g., gross negligence vs. ordinary negligence), requiring the parser to link each limit to its triggering condition.

Liability caps are meaningless without identifying the governing currency. This component detects and normalizes currency designators (USD, EUR, GBP) and links them to the contract's Governing Law clause to resolve ambiguities.

• Symbol Disambiguation: The '$' symbol is used by multiple jurisdictions (USD, CAD, AUD). The parser must cross-reference the governing law or party addresses to assign the correct ISO 4217 currency code.
• Multi-Currency Contracts: In cross-border agreements, different obligations may be capped in different currencies. The system must maintain the integrity of each cap's denomination without conversion unless explicitly stated.

A liability cap is rarely absolute. This component identifies exceptions that pierce the cap, allowing for unlimited or separately limited liability for specific breaches.

• Common Carve-Outs: Fraud, willful misconduct, death/bodily injury, breach of confidentiality, and IP infringement are standard exceptions that must be extracted and linked to the main cap.
• Layered Logic: The parser must model the logical hierarchy. For example: 'Neither party's liability shall exceed $1M, except for breach of Section 5 (Confidentiality), which shall be capped at $5M, and for fraud, for which liability shall be unlimited.'

The liability cap's meaning is defined by the scope of damages it covers. This component links the numerical cap to its qualifying language, such as 'aggregate liability,' 'direct damages only,' or 'all claims arising under this agreement.'

• Basket Interaction: The parser must identify if a liability cap is tied to a deductible basket (a threshold of losses that must be exceeded before a claim can be made). The cap and basket together define the true financial exposure window.
• Survival Periods: The system must extract the temporal scope—how long after contract termination the cap remains effective—to model the complete risk profile.

Liability caps are often asymmetrical. This component attributes each extracted cap to the correct party or parties, distinguishing between mutual caps and one-sided limitations.

• Named Entity Resolution: The parser must resolve party names, defined terms (e.g., 'Service Provider,' 'Customer'), and pronouns to correctly assign financial exposure to each legal entity.
• Cap Reciprocity: The system flags whether a cap is mutual ('each party's liability...') or unilateral ('Supplier's liability shall not exceed...'), a critical distinction for risk analysis.

A common liability cap formulation ties the limit to fees paid or payable under the agreement over a specific lookback period. This component extracts the formula and the relevant time window.

• Formula Parsing: The system must interpret language like 'the fees paid by Customer in the 12 months preceding the claim' and structure it as a computable expression.
• Variable Resolution: The parser must identify whether the cap references 'fees paid,' 'fees payable,' or 'the total contract value,' as each yields a different financial outcome.