Legal & Compliance

Vendorcontractsredlining

A cloud infrastructure vendor sends over their standard MSA. Sixty-two pages. The agent reads it against the company's contracting playbook and flags every deviation: indemnification clauses that exceed the accepted liability threshold, data processing terms that conflict with the privacy policy, SLA commitments in the statement of work that didn't make it into the contract. It generates a redline draft substituting preferred clause language wherever a vendor term is unacceptable. Legal reviews the exceptions and sends the markup in one pass.

Key Takeaways

First redline in minutes

What used to take a senior attorney two to three hours to mark up is ready for review before the negotiation call is scheduled.

Position-consistent markup

Every redline matches the organization's standard positions. No deviation based on which attorney did the markup or how busy they were.

Clause-level justification

Every proposed change includes the standard position it's drawn from and a one-line explanation of what the vendor clause says.

Nothing missed

Every clause in the vendor draft is reviewed against the standard — including clauses the organization's template doesn't address.

Risk-ranked output

Unacceptable provisions (unlimited liability, IP assignment to vendor, one-sided termination) surface at the top, not buried in a track-changes document.

Every vendor sends their own paper. The markup is always the same work.

Commercial and legal teams spend hours on contract markup that follows the same logic every time. The vendor sends their paper. The attorney opens the standard positions playbook. They mark up the indemnity clause, the liability cap, the IP ownership, the data processing addendum, and the governing law. The same negotiating positions, applied to a different contract.

The automation reads the vendor contract and the organization's standard positions library. For each clause in the vendor draft, it finds the corresponding standard position — whether it's an exact match, a variant that needs adjustment, or a clause type the organization's template doesn't address. It generates the redlined version with the proposed change and a one-line justification referencing the standard.

High-risk provisions surface at the top: unlimited liability, IP assignment to the vendor, one-sided termination rights, data processing terms that don't meet minimum requirements. The attorney reviews a prioritized list of concerns, not a marked-up document from scratch.

One signature per clause

A single DSPy signature compares each vendor clause to the standard positions library and returns the deviation level, proposed language, and a one-sentence justification. The same signature runs for all 34 clauses — each independently, in parallel.

python

import dspy
from predict_rlm import File, PredictRLM

class RedlineContractClause(dspy.Signature):
    """Compare a vendor contract clause to standard positions and generate a redline."""
    vendor_clause: str = dspy.InputField(
        desc="Vendor contract clause text with clause reference"
    )
    standard_positions: File = dspy.InputField(
        desc="Standard contract positions library with acceptable language for each clause type"
    )
    clause_type: str = dspy.OutputField(
        desc="Clause category (e.g., indemnity, liability_cap, ip_ownership, data_processing)"
    )
    deviation_level: str = dspy.OutputField(
        desc="One of: acceptable, minor_deviation, material_deviation, unacceptable"
    )
    proposed_language: str = dspy.OutputField(
        desc="Proposed replacement language drawn from the standard positions library"
    )
    justification: str = dspy.OutputField(
        desc="One sentence: what the vendor clause says and why the proposed language is preferred"
    )

agent = PredictRLM(RedlineContractClause, lm="openai/gpt-5.1", max_iterations=8)
result = agent(
    vendor_clause="Vendor's liability shall not exceed $500 for any claim.",
    standard_positions=File(path="legal/standard_positions_v8.pdf")
)
# result.clause_type     → "liability_cap"
# result.deviation_level → "unacceptable"
# result.proposed_language → "Vendor's aggregate liability shall not exceed 12 months of fees paid."
# result.justification   → "$500 cap provides no meaningful recourse; standard position requires 12-month fee cap."

Built on predict-rlm — open source. github.com/Trampoline-AI/predict-rlm

What counsel receives

Counsel receives a redlined Word document with all proposed changes tracked and a comment on each with the justification and the standard position it references. A separate risk summary memo groups issues by tier: unacceptable provisions first, then material deviations, then minor deviations. The memo is structured for a 10-minute review before a negotiation call — the attorney reads the triage list and decides which positions to hold, which to trade, and which to accept.