Comprehensible agreements with Lawpatch

TL;DR

Lawpatch is a collection of open source legal language that makes drafting agreements simple. LawPatch can:

  • shorten technical legal documents to a quarter of the usual length;
  • make technical legal drafting comprehensible to non-lawyers; and
  • create language that operates across jurisdictions (think jQuery for law).

The comparison below shows a LawPatch clause on the left and the legalese equivalent on the right.

Lawpatch (14 words) Legalese (76 words)
Provider limits liability as much as the law allows to Customer for the Services. Client deals with Provider in respect of the Services at its own risk. To the fullest extent permitted by law, Provider excludes all liability (including any kind of consequential or indirect loss like loss of profits, pure economic loss or loss of opportunity) to Client for any liabilities connected directly or indirectly with the dealings of the Client and the Provider in relation to the Services, including liabilities based on contract law, tort law and legislation.

The legalese problem

Legal agreements govern almost everything important… and everyone hates reading them.

It’s clear why: agreements use lengthy, jargon heavy language to describe even the simplest arrangements. Bad drafting is often to blame, but even the best plain-english-drafting lawyer is forced to draft agreements that are partly verbose and obscure.

Centuries of court judgements and legislation endeavouring to govern the world's complexities, edge cases and loophole seekers add up to a complex web of concepts (the law) that an agreement needs to weave into a set of instructions for a relationship (the agreement).

The law is so complex that the simpler a legal agreement is, the fewer relevant details it will cover. With one eye on their insurance policies, lawyers tend to opt for the comparative safety of well worn but unfriendly legalese.

Incorporation by reference

We (lawyers from the United States, United Kingdom and Australia working on Lawpatch) think there is a way out of the “simple equals risky” conundrum.

“Incorporation by reference” is a simple idea: if you want a contract to include a set of rules that’s written somewhere else, you can make those rules part of the agreement by referring to them. For example, in some employment agreements, a company’s HR policy will be incorporated by reference. Breaking a rule in the HR policy is breaching the contract.

Documents can be identified and included by reference to a title and date or, for our purposes, a URL or defined phrase.

Boilerplate: easy application

At the end of most legal agreements are a bunch of clauses known as “boilerplate”. Boilerplate clauses cover topics like:

  • legal expenses;
  • scope of the agreement; and
  • how to remove invalid parts of the agreement.

These clauses stay the same for almost every agreement.

To avoid repeating the boilerplate every time, we drafted open source “sensible boilerplate” for the US, UK and Australia, and put it in a version controlled filing system on the Web so that it can be incorporated by reference with a URL - we use Git). Adding the boilerplate to an agreement then becomes as simple as adding this clause:

The parties agree to the sensible boilerplate terms at this URL.

Implementing boilerplate like this saves time, reduces document length and emphasises terms unique to the transaction. When you need to review the language, it's just a click away.

Folding this much information into such a small, accessible space wasn’t practical before hyperlinks made an extra dimension to documents possible.

Limitation of liability: complex to simple

While we were drafting Sensible Boilerplate and another “patch” for interpretation, we decided to draft a proof of concept for the technical area of "limitation of liability”. This is the agreement section that effectively governs who can sue who for what.

You can see one of the positions here. The drafting assumes that certain information is in the clause of the agreement (the “Provision”) that incorporates the patch:

  • a party benefiting from the liability limitation (“Limiting Party”);
  • a party limited by the limitation (“Recipient”); and
  • a subject for the limitation (“Subject”).

To draft a clause with this information and the patch URL is as simple as:

Provider limits liability as much as the law allows to Customer for the Services.

We don’t want people to use LawPatch to hide adverse clauses. Agreements should be clear. To that end, we propose to add this snippet to agreements using patches.

The parties agree to this document using Lawpatch language. The LawPatch language referenced by hyperlink is legally effective, but text used in the hyperlink is for convenience only and is not legally effective.

Spectrum of positions

The limitation language above limits all the Provider’s liability to the Client (to the extent that you can lawfully limit liability).

In many cases, you won’t want to limit liability that much. We’ve created a spectrum of limitation positions (read about it here) ordered from least liability to most liability:

Each LawPatch limitation position has an optional exception parameter. These are known as “carve outs”, and they’re often used to negotiate compromises. Here’s an example of how a carve out would look using LawPatch positions.

Provider limits liability as much as the law allows to Customer for the Services, except for Provider limiting consequential loss only to Customer for the Maintenance.

Where Lawpatch can work

LawPatch will work where everyone wants a clear agreement. That will tend to be in transactions where the parties have fairly equal bargaining power.

Where there’s less equality in bargaining power (like companies contracting with consumers), few businesses will think it's worth making their agreements easier to understand (though we’d be happy to let everyone know about enlightened companies who want to lead the charge).

It’s time we stop accepting legal agreements where crucial sections are unintelligible to ordinary people. We think Lawpatch is an easy-to-implement, concrete step in the right direction.

If you're interested, do get in touch. We’d love to speak with:

  • businesses who want to implement Lawpatch (it’s free); and
  • lawyers who’d like to work with us to draft open source language for more areas.

On twitter, my handle is @pjbrow. My email is pat@codepact.com.