There are two ways to put AI agents into contract work. One gives them the keyboard: an agent that negotiates, marks up and sends. The other gives them the preparation: an agent that reads the draft, finds the clause, compares it with the playbook, assembles the redline package and then stops, with the decision laid out for a lawyer. InsightContracts is built the second way, and the line between preparing and deciding is drawn in the code, not in a policy document.

In short

  • Seven agents, one job each. Five work on a matter (intake, clause extractor, playbook reviewer, redline drafter, supervisor); two watch the signed repository (obligations, renewals).
  • Every action is capped at L2, “Ask first”. An agent prepares a decision and waits. Nothing is sent to a counterparty, signed, accepted or approved by an agent.
  • The facts come from the engines. Clauses, positions, severities and deadlines are computed by deterministic code; a model, when it is switched on, only phrases them.
  • Autonomy is earned and can be lost. Every answer to a prepared decision is feedback; agreement rates decide what an agent may be recommended for, and a falling rate demotes it at once.

The seven agents

AgentWorks onWhat it preparesWhat it never does
Intake agentA matterWhat the contract is, whose paper, whether personal data is involved, what is missing (exhibits, a DPA); a request to the counterparty for itInvent a document nobody sent, or send the request
Clause extractorA matterThe draft read into twelve clause types, each quoted with page and line; a look at the required clauses it couldn’t findInvent a clause
Playbook reviewerA matterEvery clause’s position against the playbook, with the playbook’s severity; the review summaryDecide a position: the playbook does
Redline drafterA matterThe playbook’s fallback language for each open deviation; the redline package, heldWrite clause language, or send the package
SupervisorA matterThe approval controls’ verdict; the submission for approval, to the General Counsel where referredApprove: people approve
Obligations agentThe repositoryOverdue and due-soon obligations; requests to counterparties for what they owe, reminders for ownersInvent an obligation: each is quoted from its clause
Renewals agentThe repositoryAuto-renewals whose notice deadline is within 45 days; a renewal reviewDecide a renewal or give notice
The agent catalogue: seven contract agents grouped by intake and read, review and redline, route for approval and after signing, each with what it does, the action it may prepare, its starting level and what it never invents
The catalogue. Each agent with the one action it may prepare and the thing it never invents.

What a run looks like

“Run the agents” on a matter runs the five matter agents in order, each as itself, at its own autonomy level, on the shared pipeline. Each writes a step: what it found, which facts it relied on, and whether it prepared something for a person. Anything prepared lands on the matter’s Agents tab and on the counsel’s home page as “waiting on you”.

CounselSupervisorRedline drafterPlaybook reviewerClause extractorIntake agentCounselSupervisorRedline drafterPlaybook reviewerClause extractorIntake agentEach may prepare one decision. None acts on it.Matter triaged, missing items noted112 clause types read, page and line2Positions and severities from the playbook3Fallback language for each open deviation4Controls: what blocks, who approves5Accept, reject or ask, one by one6

The matter agents in their order. The counsel answers what they prepared; accepting carries out only what is described.

The Agents tab on matter CTR-2026-000001: two decisions waiting on the counsel, using the drafted review summary and redlining two clauses with the playbook's fallback language, each with Accept, Reject and Ask; on the right the last run's steps for the intake agent, clause extractor, playbook reviewer, redline drafter and supervisor, at L1 with the model off
Waiting on the counsel. The review summary and a two-clause redline, each with the facts behind it. The run on the right says the model was off: every step reasoned by rules.

Prepared, not done

A prepared decision has three answers. Accept carries out exactly what it describes and nothing more: accepting the redline drafter’s package marks those clauses redlined and drafts a request that is held; it doesn’t send it. Accepting the supervisor’s submission submits the matter; it doesn’t approve it. Reject records that a person disagreed. Ask sends a question back. Each answer, with who gave it, goes on the record and counts toward the agent’s agreement rate.

AGENT ACTS “The agent handled it”

A message went to the counterparty, a deviation was waved through, or a contract moved to signature, and the only record is that an agent did it.

AGENT PREPARES “The agent prepared it; Aisha accepted it”

The prepared decision, the facts it rested on, who accepted it and when. The send, the acceptance of risk and the approval are separate steps by people.

The hard lines are enforced where the action happens, not just in the agent’s prompt. Sending a request refuses an agent actor (an agent can’t send anything to a counterparty; a person releases it). So do accepting a deviation, approving a matter, recording a signature and deciding a renewal. An agent that somehow tried would be stopped by the same check that stops a counsel from approving their own submission.

Autonomy is earned, one level at a time

LevelNameWhat the agent may do
L1DraftPrepares a draft; a person does the work. Where every agent starts
L2Ask firstPrepares the decision and asks a person before it acts. The tenant ceiling, and the hard cap on every InsightContracts action
L3Act and tellActs, tells the person and lets them pull it back. Locked
L4ActActs on its own. Locked

The effective level of an agent for an action is the lowest of three: its own level for that action, the tenant ceiling (set by CONTRACTS_AGENTS_MAX_LEVEL, L2 in the demo) and the cap in the code, which is L2 for every action. An administrator can also switch an agent off, which drops it to L1. The evidence for a change is the agents’ agreement rate over 30 days: a promotion is recommended at 90% agreement or more over at least 50 answers, and only a manager can accept it; below 70% over at least 20 answers the agent is demoted at once, with the change audited.

The autonomy page signed in as the administrator: seven agents, the tenant ceiling of L2 Ask first, the four levels with L3 and L4 locked, the promotion and demotion rules, and each agent's action with its current level
The autonomy page. The ceiling, the levels, and each agent’s action with its level and recent answers. L3 and L4 are locked.

Where the model fits

The engines do the work that has to be right: the reader finds each clause and its terms, the playbook comparison gives each a position and severity, the controls evaluate, the repository computes notice deadlines. When a model is switched on, the agents use it to explain those results in plain sentences over numbered facts, and every sentence is checked: one carrying a name or number that isn’t in the facts is thrown away and the engine’s own wording stands. With the model off (CONTRACTS_AGENTS_LLM=0), every agent runs on its rules and each step says “reasoned by rules”. The demo runs that way.

No model writes contract language

The one thing the model is never asked to produce is a clause. Redlines are the playbook’s fallback text, copied exactly; requests to counterparties keep their list of items, link and date exactly as the engine drafted them.

For the General Counsel

Every consequential step (sending, accepting risk, approving, signing, renewing) stays with a named person.

You can show an auditor or a board what each agent did and who agreed with it.

For legal operations

Counsel open a matter that is already read, reviewed and assembled, and spend their time on the decisions.

Agreement rates show which agents are trusted and where the playbook or the reader needs work.

For the board

AI is used in legal work with explicit limits that are enforced in the system.

Raising autonomy is a decision taken on evidence, by a manager, one action at a time.

Agents prepare. Lawyers decide.

Seven agents read, compare, assemble and watch. None of them sends, accepts, approves, signs or renews.

The demo company, its matters and its playbook are fictional and illustrative; InsightContracts is not legal advice.

Keep reading