Accountability by design is the only way contract agents get hired

Artificial Lawyer ran a piece this week on accountability by design in agentic contract management, and it puts a name on something we keep running into in agent pilot conversations: nobody’s real objection to contract agents is capability. The objection is that when the agent does something wrong, nobody can say who owns it.

That’s the right objection. And it’s fixable, but only if you treat accountability as an architecture decision instead of a policy memo.

Why contracts are the hardest room in the building

Think about what a contract agent actually touches. It reads negotiated terms. It proposes redlines. It extracts obligations and renewal dates and feeds them downstream to finance and ops. In more ambitious deployments it drafts counterparty emails or kicks off approval workflows on its own.

Every one of those actions has a legal consequence attached. A missed auto-renewal clause isn’t a bug ticket, it’s money. A redline that quietly softens an indemnification cap is malpractice territory if a human never saw it. Contracts are where the gap between “the model was 94% accurate” and “we are liable for the 6%” stops being abstract.

So when a GC asks “who is accountable when the agent errs,” the answer cannot be a shrug toward the vendor’s terms of service. The answer has to be visible in the system itself.

What accountability by design looks like when you build it

Here is what we mean when we talk about AgentWorks-style oversight, in concrete terms:

Every action is logged, and the log is legible. Not a JSON dump an engineer can grep. A record a lawyer can read: what the agent did, when, on which document, based on which instruction, with what confidence. If your audit trail requires a data scientist to interpret, you don’t have an audit trail. You have exhaust.

Permissions are scoped per agent, per task. The agent that extracts renewal dates does not get write access to the redlining workflow. The agent that drafts counterparty emails cannot send them. Least privilege isn’t a new idea. Legal teams have run it on humans for a century through signing authority and matter permissions. Agents deserve the same treatment, and honestly, it’s easier to enforce on software than on a partner who’s in a hurry.

Human gates sit at defined thresholds, not everywhere and not nowhere. Blanket “human reviews everything” defeats the point of the agent. Blanket autonomy defeats the point of having a legal department. The useful middle: the agent handles routine NDA turns solo, but anything touching liability caps, IP assignment, or dollar figures above a set line stops and waits for a named person. That threshold is a dial your team sets. It should live in a dashboard, not in a prompt somebody wrote in March and forgot about.

Escalations name a human. When the agent hits its confidence floor or its permission ceiling, the handoff goes to a specific person with a deadline, and the dashboard shows aging escalations the way a docket shows deadlines. Accountability that doesn’t attach to a name isn’t accountability.

You can replay the decision. Six months from now, when a counterparty disputes a term, you need to reconstruct exactly what the agent saw and suggested and what the human approved. Versioned inputs, versioned outputs, versioned instructions. This is the part most pilots skip and most regret.

None of this is exotic. It’s the same discipline legal ops already applies to matter management and billing approval, extended to a new kind of worker.

The part the article gestures at but doesn’t say out loud

There’s a quieter question under all of this: where does the oversight layer itself live?

If your agent runs inside someone else’s cloud, on someone else’s logging, under someone else’s retention policy, then your accountability story has a hole in it shaped exactly like your vendor. You can’t produce audit records the vendor didn’t keep. You can’t enforce a permission boundary the platform doesn’t expose. You can’t guarantee the contract text that flowed through the agent never trained anything, because that guarantee was never yours to make.

Your data, your rules. And in an agentic system, that has to include agency over the AI working on that data. Your AI, your rules. The oversight dashboard, the action logs, the escalation thresholds, all of it should sit on infrastructure you control, governed by policy your team wrote, auditable without asking anyone’s permission. For a legal team this isn’t a philosophical preference. Privilege and confidentiality obligations follow the documents wherever they go. An agent architecture that can’t answer “where did the contract text travel” hasn’t earned the word accountable.

This is where we think agent pilots should start, by the way. Not with the flashiest use case, but with the use case where the oversight scaffolding is easiest to prove out. Run the renewal-date extraction agent first, watch the logs, tune the escalation thresholds, let the team build trust in the dashboard. Then move up to redlining. The scaffolding is the product. The agent is just the first tenant.

The grounded version

The Artificial Lawyer piece is right that accountability has to be designed in, not bolted on. Where I’d push further: designed in means owned. Owned logs, owned permissions, owned thresholds, owned infrastructure. A vendor can sell you an agent. Nobody can sell you accountability. That one you have to hold.

If you’re running or scoping a contract agent pilot right now, I’m genuinely curious: where did you set the line between what the agent does alone and what waits for a human, and how did you pick it? That threshold decision is the whole design in miniature, and I’d like to hear how it’s playing out at your firm.