You draft a service agreement in an AI contract generator. It looks polished, it covers the basics, and it saves you legal fees. Then your customer disputes a payment term that isn't in your original email. You argue it's invalid. The contract says otherwise—because the AI invented it. This happens more often than contract lawyers like to admit. AI contract tools are built on pattern-matching, not legal expertise. They see thousands of contracts, predict what usually comes next, and fill in blanks. Sometimes those predictions are wrong, sometimes they're unenforceable, and sometimes they create liability you never intended to assume. We tested seven major AI contract generators on real-world clauses: payment terms, liability caps, termination rights, indemnification, warranty scope, dispute resolution, and confidentiality boundaries. Here's what they got wrong. 1. Payment terms: AI adds clauses you never agreed to The most common error: AI inserts specific payment percentages, holdback rates, or milestone triggers that don't match your input. We tested this by feeding three generators the same prompt: "Service agreement for web design, client pays on invoice, net 30." Generator A output: "Client pays 50% upon contract signature, 30% at milestone, 20% upon final delivery. Net 30 applies only to the final 20%." This was never mentioned in the input. A customer could argue you agreed to a holdback structure you didn't specify. Generator B output: "Invoices due within 30 days of receipt. If payment is not received within 45 days, a 1.5% monthly late fee accrues." You didn't ask for a late fee. Now it's binding if you sign. Generator C stayed close to the input but added: "Payment shall be made via bank transfer only." If your customer prefers card or check, you've now locked them out. The root cause: these tools are trained on contracts where milestone holdbacks are common, so they predict them as defaults even when they shouldn't appear. What to check: Does every payment term (percentage, timing, method, late fees) appear in your original brief or email? If it's in the draft and wasn't in your input, delete it. 2. Liability caps: AI either makes them too generous or too vague Liability capping is where AI makes two opposing mistakes—sometimes in the same document. Test scenario: "Software service provider contract, limit liability to contract value, exclude indirect damages." Generator A wrote: "In no event shall either party's total aggregate liability exceed the fees paid in the 12 months preceding the claim." Sounds tight until your customer pays quarterly in advance. If they pay ₹100K upfront for the year and you cause ₹500K in data loss on month 11, your cap is still ₹100K. That's correct but harsh. Generator B wrote: "Liability is limited to direct damages only." No cap amount, no mention of the contract value. A court would likely find this unenforceable—it's too vague. Your customer could argue there's no real limit. Generator C excluded "indirect, incidental, consequential, or punitive damages" but never defined them. If your service loses a customer's client list, is that indirect or direct? AI didn't clarify. The pattern: AI generators copy language from templates without tying it to your actual contract value or risk profile. What to check: (1) Is the cap explicitly tied to a dollar amount or contract value? (2) Does it define what counts as indirect vs. direct? (3) Are exclusions (data loss, business interruption) listed separately so a court can't argue the cap itself was too vague? 3. Termination rights: AI misses termination-for-convenience clauses Termination is the clause AI most often skips or handles too narrowly. We requested: "Client can end the contract if they want." Generator A created only a "termination for cause" clause (breach, non-payment). It never mentioned termination for convenience. The customer would have to sue to exit, or you'd have to release them anyway. Generator B added termination for convenience but only for the customer, not for you. "Client may terminate at any time with 30 days' notice. Termination by Provider requires cause." You're locked in; they're not. Generator C included termination for convenience but buried a $50K termination fee inside. That wasn't in the original spec—AI predicted it from templates where such fees exist for retainer contracts. Why this happens: Termination clauses are rare in training data (most contracts don't reach termination). So AI either skips them or copies the most common pattern, which is often one-sided. What to check: Can both parties end the contract without cause? Is there notice (30, 60, 90 days)? If there's a termination fee, did you intend it, or did AI invent it? 4. Indemnification: AI creates asymmetric risk Indemnification—who pays for third-party claims—is where AI most often favors one side without justification. Scenario: "Software vendor indemnifies customer against IP infringement claims. Customer indemnifies ven