FerroxLabs Contract Review
Estimated time: 20-30 minutes
This workflow triages a contract before it is signed. It identifies the contract type, performs a clause-by-clause review with red/yellow/green severity flags, proposes concrete red-lines, and builds a counsel-routing list naming every clause that requires attorney sign-off before execution.
This is triage and drafting support. It does not replace a licensed attorney. The final deliverable is a Contract Review Memo whose counsel-routing section is a required gate before the contract is executed.
When to Use
- User wants a structured triage of a contract before signing
- User wants risky clauses flagged with severity and red-line suggestions
- User needs to know which clauses to escalate to counsel
- Do NOT use for a one-off question about a single clause
- Do NOT use as a replacement for licensed legal advice
Steps
Step 1: Intake the Contract (uses: legal-contract)
Ask the user to paste the full contract text (or provide a path to the file). Request the specifics that change the risk profile: the counterparty, the governing jurisdiction, the dollar value at stake, and any specific concerns the user already has. Do not proceed until you have the contract body and at least the jurisdiction and counterparty.
- Input: contract text or file path, counterparty, jurisdiction, dollar value, stated concerns
- Output: captured contract input and context for review
- Key focus: gather enough context to assess risk before reviewing
Step 2: Identify the Contract Type (uses: legal-contract)
Infer the contract type (e.g. MSA, SOW, license, vendor agreement, employment, lease) and the standard structure baseline a contract of that type should follow. State the inferred type plainly, give the reasoning, and ask the user to confirm or override before continuing. Use the standard baseline as the yardstick for the clause review in the next step.
- Input: contract input from Step 1
- Output: confirmed contract type and standard-structure baseline
- Key focus: anchor the review to the right contract archetype
Step 3: Run a Clause-by-Clause Review (uses: legal-contract)
Review the contract clause by clause against the type baseline. For each material clause, assign a severity flag: red (blocking risk, must change before signing), yellow (negotiate or clarify), or green (acceptable as written). Note missing clauses that the baseline expects. Surface the full flagged review to the user.
- Input: contract input from Step 1, contract type from Step 2
- Output: clause-by-clause review with red/yellow/green severity flags and missing-clause notes
- Key focus: every material clause gets a severity flag and a one-line rationale
Step 4: Refine the Review with the User (uses: legal-contract)
Present the flagged review and ask whether to proceed to the red-line memo or drill into specific clauses. If the user wants to refine, gather their feedback, re-run the clause review on the targeted clauses incorporating that feedback, and re-present. Loop up to three times until the user is satisfied, then proceed.
- Input: review from Step 3, user refinement feedback
- Output: finalized clause review approved by the user
- Key focus: let the user drill into clauses before drafting red-lines
Step 5: Propose Red-Lines (uses: legal-contract)
For every red and yellow clause, draft concrete red-line proposals: the suggested replacement or amended language, with a short rationale per change. Keep proposals specific and paste-ready so the user can take them into negotiation. Surface the red-line set to the user.
- Input: finalized review from Step 4, contract input from Step 1
- Output: red-line proposals with replacement language and rationale per clause
- Key focus: concrete, paste-ready amended language, not vague advice
Step 6: Build the Counsel-Routing List (uses: legal-contract)
Build the escalation list: which clauses require licensed-attorney sign-off before the contract is signed, and why. Cover jurisdiction-specific enforceability, indemnity and liability caps, IP assignment, and anything flagged red. This is the required gate before execution.
- Input: finalized review from Step 4, red-lines from Step 5
- Output: counsel-routing list of clauses requiring attorney sign-off, with reasons
- Key focus: clearly mark which clauses block execution until counsel signs off
Step 7: Finalize and Ship the Memo (uses: legal-contract)
Present the counsel-routing list and ask whether to ship the memo or refine the routing. If the user wants changes, gather feedback, re-run the routing step, and re-present (loop up to two times). When approved, assemble the final Contract Review Memo: contract type, clause-by-clause review, suggested red-lines, and the counsel-routing section marked REQUIRED before execution.
- Input: counsel-routing list from Step 6, red-lines from Step 5, user feedback
- Output: final Contract Review Memo with the counsel-routing gate
- Key focus: deliver one assembled memo with the execution gate clearly stated