Contractual Obligation Gate Check Prompt

This prompt is a compliance gate for AI systems and agents that propose actions with contractual implications. Its job is to take a specific, proposed action and the relevant sections of a governing contract, then produce a structured obligation compliance report. The ideal user is a legal engineering team embedding automated checks into a product workflow—for example, an AI agent that drafts vendor communications, a document generation pipeline, or an autonomous contract review system. The prompt requires the exact text of the proposed action and the verbatim contract clauses as input context. Without both, the gate cannot function reliably.

Use this prompt when the cost of a breach is high and you need a reviewable, deterministic gate before execution. It is designed for scenarios where the AI must map an action to specific clauses, assess breach risk (low, medium, high), and recommend one of three paths: proceed, block, or escalate_for_human_review. The output is a structured JSON report, making it directly consumable by an orchestration engine. For example, if an agent wants to auto-renew a service, the prompt checks the proposed renewal against the contract's termination and auto-renewal clauses, flags any notice-period violations, and blocks the action if the risk is high, attaching the specific clause text as evidence.

Do not use this prompt for general legal advice, for interpreting regulations without providing the regulation text, or in situations where the governing contract is unavailable or incomplete. It is a gate check, not a replacement for legal counsel. The prompt's effectiveness is entirely dependent on the quality and completeness of the provided contract sections. If the contract is silent on a matter, the prompt must be instructed to flag this as an ambiguity requiring escalation, not to infer obligations. The next section provides the copy-ready prompt template you can adapt for your own contract types and risk thresholds.

This template is the core instruction set for a contractual obligation gate check. It is designed to be dropped into your prompt management system, an AI gateway, or a pre-execution hook in an agent loop. The prompt forces the model to act as a compliance analyst, mapping a proposed action against specific contractual clauses you provide. It does not ask for permission; it produces a structured, auditable decision.

textCopy
You are a contract compliance analyst. Your task is to evaluate a proposed AI action against the provided contract sections and determine if executing the action would breach any explicit contractual obligation.

## INPUTS
[CONTRACT_SECTIONS]
[PROPOSED_ACTION]
[ACTION_CONTEXT]

## CONSTRAINTS
- Base your analysis ONLY on the text in [CONTRACT_SECTIONS]. Do not infer obligations from general legal principles.
- If the contract text is ambiguous, flag it as "Needs Human Review" and explain the ambiguity.
- If the proposed action is outside the scope of the provided contract sections, state that explicitly.
- Do not provide legal advice. Your output is a risk assessment for a human reviewer.

## OUTPUT_SCHEMA
Return a single JSON object with the following structure:
{
  "gate_decision": "PASS" | "BREACH_RISK" | "NEEDS_HUMAN_REVIEW",
  "obligation_checks": [
    {
      "clause_reference": "string (e.g., 'Section 4.2') or 'N/A'",
      "obligation_summary": "string",
      "compliance_assessment": "COMPLIANT" | "BREACH" | "UNCERTAIN",
      "rationale": "string explaining the assessment with direct reference to the contract text"
    }
  ],
  "overall_rationale": "A concise summary of the decision.",
  "required_approvals": ["string (e.g., 'Legal', 'Data Protection Officer')"],
  "recommended_mitigations": ["string (e.g., 'Anonymize data before processing')"]
}

## RISK_LEVEL
[RISK_LEVEL]

To adapt this template, replace the square-bracket placeholders with real data. [CONTRACT_SECTIONS] should contain the exact text of the relevant clauses, not just a link or summary. [PROPOSED_ACTION] must be a precise description of what the AI system intends to do (e.g., 'Send an email to all users in the EU with their usage summary'). [ACTION_CONTEXT] provides non-contractual facts, such as 'The user has opted into marketing emails.' The [RISK_LEVEL] placeholder should be set to 'HIGH', 'MEDIUM', or 'LOW' to calibrate the model's conservatism. For high-risk actions, always route the output to a human reviewer, regardless of the model's gate_decision.

The Contractual Obligation Gate Check Prompt is not a standalone chatbot interaction. It functions as a deterministic gate inside a larger application pipeline—typically a CI/CD release workflow, an agent action pre-approval step, or a contract-aware content generation system. The prompt expects structured inputs: the proposed action description, the relevant contract sections as grounding context, and a defined output schema. The application layer is responsible for assembling these inputs, invoking the model, validating the structured output, and routing the result to the appropriate path: proceed, block, or escalate for human review.

Wire the prompt into your application as a synchronous gate function with a clear contract. The function signature might look like check_contractual_obligation(action: ActionDescription, contract_sections: List[ContractSection]) -> GateDecision. Internally, the function assembles the prompt template, substituting [PROPOSED_ACTION] with a structured description including the action type, target system, data involved, and intended outcome. [CONTRACT_SECTIONS] receives the verbatim text of the relevant clauses, with section identifiers preserved for traceability. [OUTPUT_SCHEMA] should be a strict JSON schema defining the GateDecision object: fields for status (enum: PASS, BLOCK, NEEDS_REVIEW), obligation_matches (array of objects with clause_reference, obligation_text, compliance_assessment, and breach_risk enum), blocking_rationale (string, required when status is BLOCK), and required_approvals (array of role identifiers). After model invocation, validate the output against this schema programmatically. If validation fails, retry once with the validation error injected into the prompt as additional context. If the retry also fails, escalate to a human reviewer with the raw output and validation errors attached.

Model choice matters here. Use a model with strong instruction-following and structured output capabilities—GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro are appropriate. Avoid smaller or older models that may hallucinate clause references or produce inconsistent enum values. Set temperature to 0 or a very low value (0.1 maximum) to maximize deterministic compliance assessments. Enable structured output mode if the model provider supports it (e.g., OpenAI's response_format with a JSON schema, or Anthropic's tool use with a defined output schema). Log every gate check invocation with a unique check_id, the input action hash, the contract section identifiers, the model version, the raw and parsed outputs, the validation result, and the final routing decision. This audit trail is essential for compliance demonstrations and debugging false positives. For high-risk actions—those involving financial commitments, data deletion, or regulatory exposure—always require human approval even when the gate returns PASS. The prompt's NEEDS_REVIEW status should trigger an immediate insertion into a review queue with the full gate decision payload, not a silent fallback. Build a review interface that displays the proposed action, the matched obligations, the model's assessment, and approve/deny/request-clarification buttons. Each human decision should be logged with the reviewer identity, timestamp, and rationale, closing the audit loop.