# How we do first-pass contract review

Drop a contract into a Drive folder and an agent reads it, flags any clause that breaks our playbook, posts a summary for legal and drafts redlines a lawyer must approve.

Canonical page: https://themachine.myapps.ai/use-cases/contract-review

New contracts show up faster than anyone can read them properly. An NDA, a vendor
agreement or an order form lands in a shared Drive folder. Someone in legal then
has to open it, hold it up against our usual terms, mark the clauses that wander
off, and write a short brief for the person running the deal. That first read is
routine work, yet it eats hours, and it sits squarely between "the contract
arrived" and "a lawyer can think about the parts that matter."

We tie that first read to the moment that sets it off: a new file in the folder.
This piece walks through how we run it on Machine, covering the connections, the
steps and the limits, so you can build the same review for your team.

- **Team:** Machine
- **Trigger:** A contract dropped into a Drive folder
- **Connected systems:** Google Drive · Slack
- **Mode:** Starts on arrival · a lawyer signs off

## The problem

The usual setups all come up short. Let contracts stack up in a shared inbox and
the first read happens whenever someone has a spare hour. Run them through an
off-the-shelf AI summary and you get a tidy recap that has no idea where we stand,
so it misses everything we care about. Skip the first read altogether and a lawyer
ends up reading every contract cover to cover, dull ones included.

Our goal was a summary and a playbook check for every contract as soon as it
arrives. The summary should show up where the team already works, and the redlines
should wait for a lawyer to approve.

## What we built

On Machine, a fresh contract in a Drive folder starts an agent. Every contract gets
a session of its own, which is a fresh cloud computer (sandbox), with narrow access
to Drive and Slack. The agent reads the document, writes a summary, marks any
clause that strays from our playbook, and posts the summary in the legal channel.
It also drafts redlines on the unusual clauses, though nothing goes back to the
other side until a lawyer has signed off.

## How it works

### Make the Drive folder the starting gun

A signed webhook keeps watch over the contracts folder in Drive. When a new file
appears, the webhook fires and creates a brand-new **session** in a sandbox of its
own, with the document already loaded. Each contract gets one session and one
throwaway computer, and nothing is carried over to the next.

### Teach the agent our playbook

Where we stand on contracts lives in **skills** and **memory**, the playbook loaded
into every session. It says which clauses are normal, which terms we resist, and
what a fair liability cap or notice period looks like. The agent compares each
contract with our playbook, not with some generic idea of "standard," and the
playbook is updated whenever our positions move.

### Choose what a review can reach

**Connectors** are scoped connections to your tools, and the keys stay on our
servers, out of the model's sight. Through them the agent can:

- **Open the contract in Drive:** the whole document, start to finish, not a
snippet.
- **Draft redlines:** suggested wording for any clause that breaks from the
playbook.
- **Write in Slack:** the summary and its flags, posted to the legal channel.

### Draw the lines

What the agent hands over is a first read, never a verdict. It drafts redlines but
never sends them: each one stops at a **human approval gate** until a lawyer
approves it for the counterparty. The agent reads the contract, writes a summary
and drafts, and stays out of the deal itself. Credentials are stored encrypted in
the **Secrets Manager** and only handed to the agents you grant them to, at the
moment a run starts.

### Get every contract back with notes

Once this is running, any contract dropped into the folder returns as a summary in
the legal channel, with off-playbook clauses marked and draft redlines attached
for a lawyer to check. A vendor agreement turns into a short brief plus suggested
edits. The lawyer begins with the flags, not a blank first read.

> **The pattern**
> Hook the Drive folder up as a **trigger**. Give the agent narrow **connectors**
> into Drive and Slack. Write your contract positions down as **skills** and
> **memory**. Then make every redline wait for a lawyer.

## Guardrails

Handing an agent the first read of your contracts takes trust. Here is what keeps
it in bounds on Machine:

- **Isolation.** Each contract runs in a sandbox and on a branch of its own. The
  session only reaches what it was scoped to, and the only things that come back
  out are its summary and drafts.
- **Scoped secrets.** Credentials are stored encrypted in the Secrets Manager and
  only handed to the agents you grant them to, injected into the sandbox when the
  run starts.
- **Human approval gate.** Redlines are drafts and never leave on their own. A
  lawyer reads and approves them before anything reaches the counterparty.
- **Everything is code.** The agent's persona, skills and permissions are files in
  the repo. They keep a version history and change only through a reviewed
  **change request**, not a setting in a dashboard.

## The outcome

- **Every contract:** Summarised and checked against our playbook as it arrives
- **Lawyer-gated:** Redlines are drafts until a lawyer approves them
- **2 systems:** Drive and Slack, handled by a single agent

The first read used to sit in a queue until someone was free. Now a summary and a
set of playbook flags show up the moment a contract lands, with draft redlines
ready. Lawyers start from the flags rather than page one, and the routine contracts
no longer steal the hours that the tricky ones need.