AI Contract Analysis: A Clause-by-Clause Breakdown

Most people don't read a contract end to end. The clause that matters about a penalty or termination gets lost among pages of boilerplate, and it ends up costing more than the hour of a lawyer's time that could have caught it early. Cruxly's legal mode exists for exactly this case, and there are a few practical details worth understanding before uploading a real contract: what it actually extracts, why it only turns on manually, how it behaves on a genuinely long document, and where its usefulness ends and a lawyer's work begins. This guide covers all of that in one place.

Legal Mode Is a Checkbox, Not a Separate Product

Cruxly doesn't have a separate "contract analyzer" product with its own upload form. There's one PDF analyzer and a "This is a legal document" checkbox in its settings. Without the checkbox, any file, including a real contract, goes through the regular route: the model picks out what matters and returns a condensed breakdown. With the checkbox on, exhaustive mode kicks in and works through the document clause by clause with no exceptions. Technically it's the same analysis engine either way, just given a different job: "pick out what matters" versus "don't skip anything."

Who Actually Uses This

The checkbox usually gets checked right before signing something: a freelancer reviews a new client's contract, an employee reviews an offer before starting a new job, a business owner works through a batch of vendor contracts. A separate case is a lawyer who uses the breakdown not as a replacement for their own work, but to get through the routine part faster — seeing every clause at once instead of hunting for the right one manually through the whole document.

More on AI contract analysis for lawyers

What Kind of Contracts Work Best

Legal mode works equally well on any text-based contract regardless of type: service agreements, employment contracts, NDAs and confidentiality agreements, lease agreements, licensing and partnership agreements, contractor agreements, terms of service and user agreements. The difference between types isn't in the quality of the breakdown, it's in which clause categories tend to matter most: termination and obligations usually stand out in an employment contract, payment and penalty clauses in a vendor contract, confidentiality and governing law in an NDA. The categorization is the same across every type, but knowing which categories usually matter for a given kind of document gets you to what you actually need to check faster.

There's No Auto-Detection: How to Turn the Mode On Manually

The service doesn't try to guess from the content or the filename whether something is a contract. The mode switches on manually, with the "This is a legal document" checkbox in the analysis settings, which you check yourself after uploading a file.

What Gets Extracted Per Clause

Every clause in the contract comes back with the verbatim text from the original, a plain-language paraphrase, a category, and a risk flag. The categories are fixed: obligation, right, payment, termination, penalty, confidentiality, governing law, dispute resolution, and others. The verbatim text matters when the exact wording carries weight on its own, the plain-language paraphrase saves time on a dense piece of legalese, and the category lets you find every clause of one type fast without reading the document line by line.

The Risk Flag Filters Nothing

The flag looks like a filter, and it isn't one. Every clause gets a level: high, medium, low. It only affects how a clause is displayed, not whether it makes it into the result. Exhaustive mode returns literally every clause in the document regardless of its flag. The logic is simple: if the model decided on its own which clause of your contract wasn't worth showing, that would be exactly the importance-based selection legal mode exists to avoid in the first place.

How Long Contracts Get Handled

A long contract is split into segments with deliberate overlap between them, specifically so a clause never ends up cut in half at a segment boundary. If the model's response for a segment comes back truncated, that segment gets split and re-read recursively, up to three levels deep. A segment that still can't be parsed after every attempt doesn't silently vanish from the result — it turns into a visible marker flagged as high risk. In ordinary text, a phrase lost at a seam is a minor annoyance. In a contract, it's a potentially lost obligation, which is why the overlap between segments here is larger than in regular PDF analysis.

An Overview After the Clause-by-Clause Pass

After the line-by-line breakdown, a short overview of the whole document gets built too. One upload ends up producing two levels of result: a detailed clause-by-clause breakdown for working with specific wording, and a short overall summary to understand what the contract is about in a minute, before reading through every clause in order.

Legal Mode vs. Regular PDF Analysis

Not every document that mentions deals needs legal mode. Regular analysis is the right call when you need to understand content fast: a report, an article, a presentation, where losing a minor detail for the sake of brevity doesn't matter. Legal mode is for the cases where a missed clause can cost money or create an obligation: a contract, an agreement, an NDA, a terms-of-service document. Switching between the two is manual in both directions — neither one turns on automatically based on a file's content.

Legal Mode vs. Regular PDF Analysis: When to Use Which

Chatting About the Contract After Analysis

Once the breakdown is ready, a chat opens that keeps the entire contract text in context. Ask directly: "which clause states the termination period," "what penalty applies for a late payment," "compare the confidentiality terms in this clause against clause fifteen." The answer is built from the actual wording of that specific contract, not the model's general assumptions about typical phrasing, so a quote in the answer matches the real document instead of an averaged template of that kind of contract.

Where to Start Without a Lawyer on Retainer

Upload the PDF, check "This is a legal document," wait for the breakdown. From there, it helps to go through the high-risk-flagged clauses first rather than reading the whole document top to bottom — that's usually where termination, unilateral cancellation, or auto-renewal terms hide, and they're worth a closer read than the rest. The actual decision to sign still rests with you, or with a lawyer if the stakes justify one, but the breakdown saves the time it takes just to figure out where to start looking for the clauses that matter.

AI Contract Analysis: Where to Start Without a Lawyer on Retainer

Analyzing an Employment Contract as an Employee

An employment contract goes through the same mode as a vendor contract: same categories, same risk flag. The difference is which categories to check first: the probation period and how it can be extended, the grounds for termination by the employer, what's actually included in your duties versus what isn't, and whether there's a non-compete clause after you leave.

Analyzing an Employment Contract with AI: What to Check as an Employee

Reviewing a Vendor Contract Before You Sign

Before signing a contract with a new vendor or contractor, it's worth explicitly going through three clause categories: payment (deadlines, process, late fees on both sides), termination (whether the vendor can walk away suddenly and what that means for work already underway), and liability (the cap on damages, and what each side is actually responsible for). Legal mode returns all three as separate clause groups, not mixed in with the rest of the contract's text.

Comparing Two Contracts or Two Versions of One

Each contract is analyzed independently of the other. In practice that's less awkward than it sounds: open both finished breakdowns side by side and ask chat a specific question about the same clause in each version, the penalty amount or the notice period for termination, say. That's faster than checking two documents line by line by hand.

Reviewing a Batch of Signed Contracts

There's no batch upload for multiple files in one analysis — each contract goes through on its own, one at a time. If you're working through a dozen signed contracts with different vendors, it helps to set up a project or vendor folder right away and drop each finished breakdown into it as you go, rather than sorting results afterward. A month in, once a dozen breakdowns have piled up, finding the right one by folder name beats trying to remember what a specific file was called.

The Same PDF Analyzer, Just a Different Mode

Legal mode doesn't turn off the rest of the PDF analyzer's capabilities — the same file can also be analyzed the regular way if what's needed isn't a clause-by-clause breakdown but a fast read on the general content. The complete picture of how PDF analysis works overall, from document structure to plan limits, is in a separate guide.

The Complete Guide to AI PDF Analysis

Plan Limits

Legal mode's functionality is identical across every plan, the difference is only in the limits. Guest access with no sign-up: one document a day. The free Study plan: three documents a day, results are saved. The Pro plan: no daily limit, larger files, export to PDF, DOCX, and Markdown. A contract's size in megabytes doesn't track its number of clauses well — a short but dense agreement with attachments can weigh more than an ordinary ten-page service contract.

This Isn't Legal Advice

The clause-by-clause breakdown and the risk flag speed up reading and help you not miss a piece of wording that would otherwise get lost in the text. They don't replace a lawyer where a decision actually carries weight: the final read on the consequences of specific wording, and whether a contract holds up under the applicable law, are worth confirming with a specialist, especially when a contract materially affects something. The breakdown speeds up reading. It doesn't make the decision for you.

Common Mistakes When Analyzing a Contract With AI

Mistake one: forgetting to check "This is a legal document" and getting a regular condensed summary instead of a clause-by-clause one. Mistake two: reading clauses in document order instead of by risk flag, and burning time on clearly boilerplate sections. Mistake three: treating the breakdown as a final legal opinion instead of a tool for reading faster. Mistake four: asking chat something as broad as "what's wrong with this contract" instead of a specific question about a particular clause or term. A vague question almost always gets a less useful answer than a precise one.

Legal mode is a checkbox inside the regular PDF analyzer, not a separate product: the same service that breaks down a textbook or a report works through a contract clause by clause with nothing skipped once the mode is on. A reasonable first step is uploading a contract that's actually sitting unread right now and seeing what the breakdown shows.