Building a Context-Aware Legal Contract Analyzer with Gemma and Gemini

Building a Legal Contract Analyzer with a Multi-Agent AI Architecture

Legal contracts are often difficult to understand without legal expertise. The challenge isn't just reading individual clauses—important obligations, exceptions, definitions, and amendments can be spread across dozens of pages.

For our hackathon project, Legal Contract Analyzer, we're building an AI-powered system that helps people understand contract terms, identify potential risks, and prepare better questions for a qualified lawyer.

What we're building

Our system uses three specialized AI agents:

1. Document & Context Analyst

Extracts text and clauses, identifies definitions and references, and traces relationships between clauses, schedules, and amendments. The goal is to preserve context instead of analyzing every clause in isolation.

2. Contract Risk & Consultancy Analyst

Examines potentially risky clauses, explains their practical implications in plain language, and suggests questions users may want to raise with a lawyer.

3. India Central-Law Verification Agent

Checks legal claims against available legal sources, grounds findings in evidence, and flags uncertainty when adequate support cannot be found.

The system is designed to assist users in understanding contracts, not to replace professional legal advice.

The key technical challenge: long-range dependencies

Consider a contract that allows termination with 90 days' notice. An amendment near the end of the document changes that period to 30 days.

A basic document summarizer might report the original clause without noticing the amendment. Our approach aims to connect the original clause to the later modification so that the final analysis reflects the relevant context.

We also want to trace relationships such as:

• A payment deadline that triggers a defined material breach.
• A breach that enables termination after a cure period.
• A schedule that expressly overrides a clause in the main agreement.
• A liability cap that interacts with exceptions and special limitations.

How we're building it

Our planned architecture combines:

• Python for document processing and orchestration.
• Structured schemas to pass clause-level evidence between agents.
• Hybrid retrieval using keyword-based search, embeddings, and explicit cross-reference detection.
• A dependency graph to represent relationships such as REFERENCES, MODIFIED_BY, OVERRIDES, and DEFINED_BY.
• Gemma/Gemini API integration, depending on the selected model and supported API capabilities.
• Legal retrieval and verification to connect findings to relevant legal sources and flag unsupported claims.

The exact models, retrieval infrastructure, and implemented features will be documented in the repository as development progresses.

What we want the final report to provide

For each potential risk, the system aims to provide:

1. The relevant contract clause and location.
2. Related clauses, definitions, schedules, or amendments.
3. A plain-language explanation of the potential issue.
4. Relevant legal evidence where available.
5. Uncertainty flags and questions to discuss with a lawyer.

What's next?

We are focusing on making the analysis traceable and context-aware, rather than generating confident-sounding summaries without evidence. Evaluation with synthetic contracts containing deliberate cross-references, conflicting clauses, and amendments is an important part of that process.

Built by Team CoolBerg Testers.

Disclaimer: This project is an informational aid and does not provide legal advice. Findings require appropriate verification and, where necessary, review by a qualified legal professional.