Inside Clause: The Contract Engine
This post continues our “Inside Clause” series looking into the future of contracting being pioneered at Clause HQ. We started with framing this series with a discussion of the Contract Stack — the basic layers that will “transform the fundamental nature of legal contracts from static documentation to data-driven, integrated, components of the digital business world”. We begin our unpacking of the Contract Stack, by looking at the core of it — the contract itself.
Unlike legal contracts that currently exist, contracts on Clause are not static text-based agreements, but are largely executable on an ongoing basis and in real-time. By that we mean that contracts perform operations — both internally to the contract and upon external systems. This paradigmatic shift represents one of the most fundamental changes to contracting; not recently but ever. As we mentioned in the last ‘Inside Clause’ post — this takes us way past executing a natural language contract using e-signature to: (a) actually executing the terms and conditions of contractual agreements using external data, and (b) integrating the contract into wider enterprise workflows. This is achieved using the Contract Engine.
What is the Contract Engine?
The Contract Engine is the world’s first and only legal contract execution environment; representing a significant innovation in contracting. The Clause Contract Engine enables a legal contract to be executed using external contract data (e.g. IoT data about the state of the physical world, such as the shipment of a good), inputs from the parties, and perform external events on other platforms and systems (e.g. accounting, payment, employment, distributed ledgers…you get the idea). The purpose of the Contract Engine is twofold: (a) to enable contracts to become real-time entities, not static text-based documents; and (b) to enable contracts to be incorporated into enterprise workflow processes. The latter becomes possible when the former is achieved. It should not be the case that contracts — the operating system upon which all businesses run — do not communicate with other enterprise systems.
Embedding contracts into workflows fundamentally transitions the contract from a document to a form of operating entity which, together with other contracts and these connections with enterprise systems and infrastructure, effectively form the operating system of an enterprise. the technology developed in this vein by Clause is thus moving the ‘nexus of contracts’ theory into practical reality.
By solving these two issues, the Contract Engine fundamentally changes the nature of the legal contract from a document that requires constant management to a force of automation and benefit to an organization. As we mentioned previously, along with AI, this is the next major wave to affect legal contracts. The Contract Engine is the core of this and creates what we call the era of ‘connected contracting’.
How does Connected Contracting Work?
‘Connected Contracting’ is the paradigm by which contracts are connected to external sources. A typical (and simple) example that we have used in the past is of a sales contract that is connected to a delivery data, payments systems, and accounting systems. If the delivery of goods is not made on time and/or the goods are faulty, then the price is decreased in accordance with the terms of the contract. The new price is then reconciled with invoicing and accounting systems and, ultimately, with the payment system. No management required. This is a very basic example. There are a multitude of interesting applications that result from having a contract that operates as a real-time entity (more on this in future posts).
We believe that connected contracting is the next generation of contracting, and will become ubiquitous — just like e-signatures and PDFs have before it.
Stay tuned as we have some very exciting announcements and a project launch on this topic coming in the next few weeks! Follow @clauseHQ for more updates.