Missing Governing Law Clause Prompt

This prompt is designed for contract review pipelines that must determine which jurisdiction's laws govern an agreement. It detects governing law clauses, extracts the specified jurisdiction and venue, and explicitly flags contracts where governing law is missing, ambiguous, or distributed across multiple sections. Use this prompt when your system needs to route contracts by jurisdiction, assess enforceability risk, or validate contract completeness before ingestion into a contract management platform.

The ideal deployment context is a document intelligence pipeline where contracts arrive in varied formats and must be triaged before downstream processing. For example, a procurement system might use this prompt to route contracts governed by California law to a California-specific review queue, while flagging contracts with missing governing law for manual attorney review. The prompt expects a full contract text as input and returns a structured JSON object with governing_law_found, jurisdiction, venue, clause_text, citation_location, and ambiguity_flags fields. This structured output makes it straightforward to integrate with contract management APIs, compliance databases, or routing rules engines.

Do not use this prompt when you need legal advice about whether a governing law clause is enforceable, when you need to interpret choice-of-law rules across multiple jurisdictions, or when the contract is governed by international treaties or arbitration rules that require specialized analysis. This prompt identifies presence, absence, and ambiguity—it does not provide legal opinions. Human legal review is required for contracts flagged as ambiguous or missing governing law. For contracts where governing law is implied by the parties' locations or the contract's subject matter, pair this prompt with a separate jurisdiction inference step rather than expecting the model to perform legal reasoning beyond the text.

The prompt below is designed to be pasted directly into your AI system. It instructs the model to analyze a contract, locate any governing law provision, extract the jurisdiction and venue, and—critically—produce an explicit flag when such a clause is absent, ambiguous, or split across multiple sections. Replace every square-bracket placeholder with your actual contract text and configuration values before use.

textCopy
You are a contract analysis assistant. Your task is to examine the provided contract text and determine the governing law and venue.

INPUT CONTRACT:
[CONTRACT_TEXT]

OUTPUT SCHEMA:
Return a single JSON object with the following fields:
- "governing_law_found": boolean
- "jurisdiction": string or null
- "venue": string or null
- "clause_text": string or null (the exact text of the governing law clause)
- "section_reference": string or null (e.g., "Section 12.4")
- "confidence": "high" | "medium" | "low"
- "absence_reason": string or null (required if governing_law_found is false; explain why, e.g., "No clause found", "Clause is ambiguous", "Jurisdiction split across sections 5.2 and 8.1")
- "notes": string (any additional observations)

CONSTRAINTS:
- If no governing law clause is found, set "governing_law_found" to false and all extraction fields to null.
- If a clause is present but the jurisdiction is ambiguous (e.g., "the laws of the State of the parties' principal place of business"), set "jurisdiction" to null, "confidence" to "low", and explain in "absence_reason".
- Do not infer a jurisdiction from the parties' addresses or other contextual clues unless explicitly stated as the governing law.
- If the governing law and venue are stated in separate sections, extract both and note the split in "notes".

[EXAMPLES]
Example 1 - Clause Found:
Input: "This Agreement shall be governed by and construed in accordance with the laws of the State of New York, without regard to its conflict of laws principles. Any legal action arising out of this Agreement shall be brought in the federal or state courts located in New York County, New York."
Output: {"governing_law_found": true, "jurisdiction": "State of New York", "venue": "New York County, New York", "clause_text": "This Agreement shall be governed by...", "section_reference": null, "confidence": "high", "absence_reason": null, "notes": ""}

Example 2 - Clause Missing:
Input: "The parties agree to the terms set forth herein. IN WITNESS WHEREOF..."
Output: {"governing_law_found": false, "jurisdiction": null, "venue": null, "clause_text": null, "section_reference": null, "confidence": "high", "absence_reason": "No governing law clause found in the provided text.", "notes": ""}

Example 3 - Ambiguous Clause:
Input: "This contract is governed by the laws of the jurisdiction where the services are performed."
Output: {"governing_law_found": true, "jurisdiction": null, "venue": null, "clause_text": "This contract is governed by the laws of the jurisdiction where the services are performed.", "section_reference": null, "confidence": "low", "absence_reason": "Jurisdiction is ambiguous; it depends on an external fact (location of service performance).", "notes": ""}

After pasting this template, replace [CONTRACT_TEXT] with the full text of the document you are analyzing. The [EXAMPLES] block provides few-shot demonstrations that teach the model the distinction between a missing clause, an ambiguous clause, and a clean extraction. For production use, you should expand these examples to cover edge cases specific to your contract domain, such as international arbitration clauses or choice-of-law provisions that reference multiple jurisdictions for different parts of the agreement. The output schema is designed to be machine-readable; the absence_reason field is the critical signal for downstream routing logic—contracts with a false governing_law_found flag should be routed for human review or an escalation workflow.

The Missing Governing Law Clause prompt is designed to operate as a single step inside a larger contract ingestion pipeline. It expects pre-extracted contract text and a structured output schema as inputs. The prompt should be called after the document has been parsed, classified as a contract, and had its text extracted—but before downstream risk scoring or obligation tracking systems consume the output. This ordering matters because a missing or ambiguous governing law clause changes how every other clause in the contract is interpreted, making it a gating extraction that should block or flag downstream processing when uncertain.

Wire this prompt as a standalone function or microservice that accepts [CONTRACT_TEXT] and [OUTPUT_SCHEMA] as inputs and returns a JSON payload with jurisdiction, venue, governing_law_clause_text, is_present, is_ambiguous, and confidence fields. Implement a validation layer that checks: (1) the is_present boolean matches whether clause text was actually returned, (2) when is_present is true, the jurisdiction field is not null or empty, and (3) when confidence is below a configurable threshold (suggest 0.85), the extraction is routed to a human review queue rather than automatically ingested. For production systems, log every extraction attempt with the contract hash, prompt version, model used, confidence score, and validation result. This audit trail is essential for legal engineering teams that must explain why a contract was flagged or passed through.

Model choice matters here. Use a model with strong legal text comprehension and structured output support—GPT-4o, Claude 3.5 Sonnet, or equivalent. Avoid smaller or general-purpose models that may hallucinate jurisdiction when the clause is absent. Set temperature=0 to maximize determinism. If your pipeline processes high volumes, implement a two-stage approach: a fast classifier prompt that determines presence/absence first, then a detailed extraction prompt only when the clause is found. This reduces token costs and latency for the common case where governing law is present and straightforward. For contracts that return is_ambiguous=true or confidence < 0.85, do not retry automatically with the same prompt—escalate to a human reviewer with the extracted clause text and the model's ambiguity notes attached. Retry logic should be reserved for clear system failures like malformed JSON or schema validation errors, not for borderline legal interpretations.

When integrating this prompt into a multi-document contract review system, ensure that the governing law extraction runs before cross-document consistency checks. A contract package may have a master agreement specifying Delaware law while an exhibit references California law—this prompt should flag each document independently, and a separate reconciliation step should resolve conflicts. Do not attempt to resolve cross-document jurisdiction conflicts inside this prompt; its scope is single-document extraction with explicit uncertainty signaling. For RAG-based systems that retrieve governing law clauses from a clause library, use this prompt's output as a filter: if is_present=false, skip retrieval of governing-law-specific precedent and flag the contract for manual jurisdiction assignment before any automated analysis proceeds.