How we do first-pass 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.
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
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.
More use cases
How we answer GDPR data-subject requests before the deadline
Our Machine agent checks each GDPR access or deletion request, finds the person's data across our product database, builds the report well within the SLA and hands it to legal before anything is sent.
How we keep our docs matching what the code does
Once a day a Machine agent reads every commit merged since its last pass, finds the doc pages those changes made wrong, rewrites them and sends you one pull request to review.
How we test every pull request without lifting a finger
Our Machine QA agent works with GitHub and our test environment. For each pull request it checks out the branch, runs the tests, tries the change for real, and posts what it found.
Put your first agentto work today.
- SSO
- RBAC
- Governed agents
- Full audit trail