Review documents against your standard terms

Why this matters

Documents that need careful review pile up. Vendor contracts, RFPs, NDAs, master services agreements, and partner addenda. Most small teams handle this two ways, both bad: rubber-stamp because “it’s probably fine,” or bottleneck on legal because “better safe than sorry” and lose two weeks per document.

The middle path is an agent that does the labor part: read every word, compare line-by-line against your standard terms, surface every deviation, and classify by risk. Your reviewer (you, or your lawyer when needed) reads the flags, not the whole document. Same-day pass on most contracts. Real review attention reserved for the deviations that warrant it. Today, you build that.

Quick start

1. Sign in: open Auxot in your browser and log in.

2. Open chat with the Admin Agent: click Chat in the left menu, make sure the agent picker reads “Admin Agent.”

3. Build the document-review agent: paste this:

   I want a "Document Review" agent. When I paste in a contract or document, it compares it against my standard terms (which I'll attach as a context file) and produces: (1) every deviation from our standards, (2) a risk classification per deviation (acceptable, negotiate, blocker), and (3) suggested redline language for the negotiate and blocker items. Don't summarize the whole document — focus on what's different from our standards.
   

4. Answer the Admin Agent’s questions: what’s your standard contract template, what counts as a blocker for you, and what’s your tone in negotiation. Two or three exchanges.

5. Test on a real recent document: paste a contract you reviewed in the last month into chat with the agent. Compare its flags to what you actually flagged.

Done? The agent is in Settings → Agents and selectable from the agent picker. Optional next step: attach your standard terms as a context file (Add your first context file) if you haven’t already: the agent’s quality depends entirely on this.

The agent can do that?

Without the right structure, document review produces a long list of yellow flags you skim past. These three prompts make the output actually drive decisions.

1. Have the agent classify every deviation by risk, not just flag it

Open chat with Document Review and ask:

For every deviation you find, classify it as one of three:
- Acceptable — different from our standard but not worth negotiating (e.g., wording variation that doesn't change meaning).
- Negotiate — different in a way that affects us; we'd want to push back but could accept it if pressed.
- Blocker — never accept this; deal-breaker if they won't move.
Show the count of each at the top. Order the list by risk: blockers first, then negotiate, then acceptable.

Why it’s non-obvious: A flat list of “deviations from your standard terms” is overwhelming and useless: every contract has 30 of them and most don’t matter. The three-tier classification turns the output into a triage. You read the blockers in 30 seconds, decide on the negotiate items in five minutes, skim the acceptable list to confirm nothing was miscategorized, and you’re done.

2. Have the agent suggest specific redline language, not just flag issues

After the first review, ask:

For every "negotiate" or "blocker" deviation, propose specific redline language — exactly what to strike out and what to replace it with. Use plain text edits I can paste directly into a redline tool. Don't just say "negotiate this clause" — show me the words.

Why it’s non-obvious: Most reviewers leave you with a list of issues and you have to draft the counter-language yourself. The redline-ready output collapses the steps. You read the suggestion, decide if it’s the right pushback, paste it. The agent can’t have judgment about whether to push back (that’s still you), but it removes the typing.

3. Build a “Standards Audit” agent that reviews your last 30 days of approvals

Inverted-usage move. Open chat with the Admin Agent:

Build me a "Standards Audit" agent. Once a month, it looks at the documents I've approved in the last 30 days, compares the deviations I let pass to my standard terms, and tells me: (1) am I quietly accepting the same kind of deviation repeatedly without noticing, and (2) should I update my standards to reflect what I'm actually willing to accept? Run on the first of each month. Pair with my Monday briefing.

Why it’s non-obvious: Your accepted terms slowly stop matching your written standards without anyone noticing. You accept “governing law: Delaware” once because the customer was big; six months later you’ve accepted it 14 times and your “standard” terms still say something else. The standards-audit agent exposes the gap so you either (a) actually push back next time or (b) update your standards to match reality. Either way the documents the next month get more accurate flags.

Go deeper

Your standards file is everything

The document-review agent is only as good as its understanding of your standard terms. If you give it a vague “we like favorable terms,” you’ll get vague flags. The right context file is your actual standard contract template, with annotations:

• The clause itself.
• Why it’s the standard (one line: “this protects us from X”).
• What deviations are acceptable and which aren’t.
• What language to fall back to in negotiation.

Add your first context file covers context file mechanics. For document review specifically, the file is closer to a commented contract template than a free-form description.

When to keep a human (lawyer) in the loop

The document-review agent is fine to send straight to you for:

• NDAs.
• Standard vendor agreements under your threshold.
• RFPs with predictable shapes.

Send to an actual lawyer for:

• Anything multi-million dollar.
• Anything new (a contract type you’ve never reviewed).
• Anything the document-review agent flags with three or more blockers: at that point you’re not negotiating, you’re rebuilding.
• M&A, IP licensing, and anything with regulatory implications.

The human-in-the-loop pattern from Set up a content review pipeline applies: the agent drafts the analysis, the human approves the disposition.

Don’t review documents whose source you can’t trust

The document-review agent reads what you paste. If the document was tampered with after legal review, the agent has no way to know. Two safeguards:

• For high-stakes documents, work from the same canonical source through the whole negotiation cycle (DocuSign, Ironclad, etc.). Don’t pass copies around.
• Treat “legally final” as a state the agent can’t verify. Your final-final review still happens against the version your lawyer approved, not against the agent’s version.

Troubleshooting

• The agent flags 80 things and most are noise. Your standards file isn’t specific enough about what counts as acceptable deviation. Update it with explicit examples: “if the indemnification clause uses ‘reasonable efforts’ instead of ‘best efforts,’ that’s acceptable; if it caps damages below the contract value, that’s a negotiate; if it removes indemnification entirely, that’s a blocker.”
• The agent misses things you’d flag. Your standards file doesn’t include them. The fix is always in the standards file, not in the agent’s description. If you’d flag “automatic renewal without notice,” that needs to be in the standards.
• Suggested redlines feel weak. The agent’s tone is too cautious. Edit its description: “In suggested redlines, propose strong language. I’ll soften it if I want to.”
• The agent confidently disagrees with my actual lawyer. Your lawyer wins. Update the standards file to reflect what your lawyer told you, so the agent doesn’t make the same mistake on the next document.

Variations & edge cases

• Free tier: the agent works at all tiers. The standards file lives as a context file.
• Multi-document workflows: you can chain the document-review agent with another agent that drafts your counter-proposal email (using the redlines as input). Run a workflow covers workflows.
• Review of outgoing documents: flip the framing — “I’m sending this to a customer; flag anything that deviates from our standard customer terms that we shouldn’t be conceding.” Same agent, different prompt.
• Sensitive documents (under NDA, attorney-client privileged): Auxot can be self-hosted on your own infrastructure (View and manage your License covers licensing). For privileged content, run on local GPU (Connect a GPU worker) so nothing leaves your environment.
• When NOT to use this: when you’re reviewing documents that aren’t comparable to a standard: novel deal structures, one-off settlements, anything where the standard doesn’t exist. The agent has nothing to compare against.

Walkthrough

Step 1: Open chat with the Admin Agent

Click Chat in the left menu. Make sure the agent picker at the top reads “Admin Agent.”

Step 2: Prepare your standards file

Before building the agent, write the standards file. It’s the single most important asset for this workflow. Format suggestion (one entry per clause):

## Limitation of Liability

Our standard: Liability capped at 12 months of fees paid.

Acceptable deviations:
- Cap raised to 24 months for enterprise customers.
- Carve-outs for IP infringement and breach of confidentiality.

Negotiate:
- Cap below 12 months — push back, willing to accept 6 months for small contracts.
- Mutual cap at different levels.

Blocker:
- No cap (uncapped liability).
- Cap below the contract value.

Repeat for every clause that matters: payment terms, IP ownership, governing law, termination, warranties, indemnification, etc. This file makes the agent: invest the hour.

Step 3: Build the document-review agent

Paste this:

Build me a "Document Review" agent. When I paste in a contract or RFP, it:

1. Reads it line by line.
2. Compares each clause to our standard terms (attached context file).
3. Flags every deviation, classified as Acceptable / Negotiate / Blocker.
4. Orders the output: blockers first, then negotiate, then acceptable.
5. For every negotiate and blocker, suggests specific redline language.
6. Skips clauses that match our standards — don't review what's already correct.

Attach the standards file I'll provide. Make it ready to use.

The Admin Agent will ask which standards file to attach (use the one from Step 2), what your tone should be in suggested redlines, and how to handle ambiguous clauses.

Step 4: Test on a real recent document

Pick a contract you reviewed in the last 1–3 months. Paste it into chat with Document Review. Compare:

• Did it catch the deviations you actually flagged?
• Did it correctly classify them by risk?
• Are the suggested redlines usable, or would you rewrite from scratch?
• Did it miss anything?

For every miss, update the standards file. The agent is reading what you give it; if a clause type isn’t in the standards, the agent has no opinion about it.

Step 5: Adopt the workflow

Once the agent is reliable on test documents, adopt it for live review:

• New contract arrives → paste into chat with Document Review.
• Read the blockers (30 seconds). Decide if any are deal-breakers.
• Read the negotiate items (5 minutes). Decide which to push back on.
• Skim the acceptable list (1 minute) to spot-check classification.
• For high-stakes documents, send the document-review agent’s output to your lawyer: saves them reading time too.

Step 6: (Optional) Build the standards-audit agent

After a month of running the document-review agent, use power move 3 to build the standards-audit agent. Pair it with your Monday briefing (Set up your Monday morning briefing). Once a month you’ll see whether your standards still match what you’re actually accepting.

What’s next

• → Add your first context file. The standards file lives here.
• → Build an internal Q&A agent for your team. What legal flags on paper should match what employees actually read in Slack.
• → Answer vendor security questionnaires from your own evidence. Opposite direction: your answers for incoming vendor procurement, grounded in your own manuals and audit logs.
• → Connect a GPU worker. For sensitive documents, run on local GPU.
• → Set up your Monday morning briefing. Fold the standards-audit agent’s report into your weekly briefing.
• → Set up a content review pipeline. The human-in-the-loop pattern applies for high-stakes documents that need a lawyer in the loop.
• → Run a deal desk for pricing and legal exceptions. When contract flags need routing and approver memos, this is the internal concession workflow with human-owned legal sign-off.

Reference

• Three-tier classification (Acceptable / Negotiate / Blocker) is how flags become triage, not noise.
• Standards file is everything: the agent’s quality depends entirely on this context file.
• Suggested redlines collapse the work from “agent flags issue” to “I paste counter-language.”
• Lawyer in the loop for: novel structures, three+ blockers, and anything with regulatory implications.
• Standards Audit catches when your “standards” are quietly slipping out of sync with what you’re actually accepting.
• See also: Triage and follow up on inbound leads, Build an internal Q&A agent for your team, Add your first context file, Set up a content review pipeline, Set up your Monday morning briefing.