That's right! We demand rigidly defined areas of doubt and uncertainty!
(cbf to read? go straight to the tl;dr infographic)
Marc Andreessen said, software is eating the world; at Legalese, we say software is eating law. Our solution to the broken-law problem is to resolve it at a fundamental level, using math, computer science, and logic. At the core, we are an open-source complaw project working on the drafting of legal documents the way programmers develop software.
We start by creating and implementing L4, a domain-specific language (DSL) for legal that is specifically designed to capture the particularities of law, its semantics, deontics, and logic. Just as Cadence's Verilog allows programmers to draft circuits, Legalese's L4 will allow programmers to express law (whether it is contracts, legislation, regulations, business process logic, or other quasi-legal ruless).
Our activities are distributed across 2 parallel tracks:
Our first product tackles startup fundraising.
It allows entrepreneurs to create, automate, and execute entire fundraising workflows for angel or seed rounds under 5 minutes — we're talking the main investment agreement, corporate resolutions and amendments, rights notices, as well as prerequisites like ESOPs and vesting, all compiled from high-level expressions.
Currently, product development and R&D are discrete and run in parallel. In 3 years (or so), we expect the 3 strands to dovetail.
The legal industry today is where software was in the late 1950s: getting ready to make the jump from macros to compiled languages. Tomorrow's lawyers will look a lot like today's programmers: drawing on opensource libraries, they will configure code for clients that compiles to readable contracts – maybe English, Mandarin Chinese, maybe Ethereum/Hyperledger. From that future, we will look back on today's lawyers, drafting agreements in Microsoft Word and checking references mandraulically, as white-collar successors to John Henry.
A smart contracts world needs computational legal more than ever. The Institute of International Finance (2016) writes:
Because few lawyers have the coding skills to draft their own smart contracts, computer programmers would play a larger role, creating new liability questions for faulty algorithms and even ethical issues regarding the practice of law by non-lawyers. Conceivably, smart contracts could reduce some legal cost around contract execution and dispute resolution by making execution automatic. However, legal cost could shift from execution to the drafting phase. As Houman Shadab, a professor at New York Law School, has pointed out:
By requiring parties to strictly commit, at the outset, to decisions of a smart contract, the need for transactional attorneys and others to structure smart contractual relationships may increase. Parties would most likely want to specify a more detailed range of contingencies and outcomes ahead of time before committing themselves to abide by the decisions of a software-driven contract.
Efforts like Clerky, Ironclad, Docracy, Common Form and CommonAccord, we think (respectfully), tend to run aground on the shoals of English: their “logic” is templates, stitched together the way PHP stitches together HTML.
At Legalese, we're more inclined to come at this at a pure play angle: we are thinking about about how software can truly eat legal (not just the legal profession). We are talking about building core infrastructures, generativity, and GPTs.
Let's talk AI (buzzword, check) – specifically, the
neglected child of AI research
paradigms, Symbolic AIThis is
distinct from Statistical AI that's frankly been getting
most if not all of the limelight.
Statistical A.I. is rooted in the Dionysian tradition: driven by emotion, casuistic reasoning, probabilistic, and rooted and realism. Of the Apollonian tradition, it is driven by reason, rule-based reasoning, deterministic, and rooted in formalisms. This is not AI that simply ventures a guess when it doesn't quite know the answer (side glance at Statistical AI); it's AI that you are supposed to reason with from first principles; an algorithm that you can argue with.
So we're taking a cue from commercial successes like ContractExpress which uses deeper formalisms (Prolog). L4, the domain-specific language we're building from first principles, will do for the deontic modal calculus what functional languages did for the lambda calculus. This solid foundation in CS theory enables the mapping of mature software concepts to the legal domain: compilation, dependency management, static analysis, and unit & integration testing.
Essentially, moving from syntax
→ semantics → pragmatics.
From what does it say → what does it mean → what does it mean for you.
Thirty years of academic research in deontic modal logic, contract formalisation, static analysis, and language design are coming to fruition in papers like Tom Hvitved's PhD thesis (2013). Contracts are multiparadigmatic: they can be object-oriented, event-driven (reactive), functional, aspect-oriented, declarative, and imperative, all in the same document. Academic contract formalisations are just now beginning to satisfy the necessary properties for reduction to software practice.
Very clever people have thought long and hard about a world in which computers execute contracts, where programs transfer money to people and people transfer money to programs, where decentralized cryptocurrencies disrupt banks and financial institutions. Very clever people will be involved in the effort to build a bridge between formal and natural languages. Many man-years will go into developing a Github/Wikipedia of legal templates that are freely available for all to use.
Legalese is clever in a different way. The business challenge of getting from the 20th-century status quo to the 21st-century promised land requires the ability to scout and climb a monotonically increasing path through multidimensional “value-proposition” space toward the global optimax. This is as much a logistical and business challenge as a computational linguistics challenge. That’s why we’ve chosen to start with spreadsheets: we optimize for the power user while building a painless onboarding pathway for first-timers.
You know how some extreme runners run fifty marathons in fifty consecutive days? Actually running the marathons is one kind of challenge. Arranging the flights, travel, and accommodation so the runner gets from finish line in one city to starting line in another, is a different kind of challenge. Developing a domain-specific language, or a library in which to model contracts, is the former kind of challenge. Making Legalese succeed as a business is the latter kind.
Text planning and interaction effects are critical to contract generation. One part of a contract may affect another. Sometimes these interactions are simple, and can be represented by a DAG. Sometimes these interactions are, superficially and conventionally, cyclic, and need to be decomposed with some clarity. Metaprogramming helps to correctly represent these interactions. CoGenText is an example of an NLG company. See also GrammaticalFramework and Attempto English.
(Written as a response to a thread on HN)
Today’s model of contracting is fire-and-regret: spec out as much as you can of the next five or ten years, and when the world changes, litigate. That’s not very agile. And unfortunately for the non-agiles, Hart and Holstrom won the 2016 Nobel in Economics for pointing out the futility of the idea of a complete contract.
What’s the alternative? Hirschman remarked that your voice sounds loudest when you are closest to exit. What if every contract had a maximum term of one year, one month, one day? What if we treated contracts as an iterated stream instead of an immutable invariant? For example, think about how “no-contract” phone plans have made the telco market more competitive, to the benefit of the consumer. Power imbalances might be reduced precisely because nobody’s locked in: it’s a lot easier to break up when you’re just dating. After the marriage you might let yourself go.
Software is eating law, but “law is code” is only the first step. Just as the historic transition from proprietary to opensource informs ideas like “Github for law”, the historic transition from waterfall to agile will find its analog in the legal and business domains by changing the way we develop and deploy contracts, ultimately driving changes in economic relations.
Think about how agile development means less software project failure, and less software project failure means less litigation between client and outsourced development vendor. That’s just one example. If better tools and languages mean that we can better transform our intent into specification, we might be forced to be clearer about what we actually do and don’t agree on, we might be more honest in our dealings, there might be an actual “meeting of minds”, and when things don’t turn out the way we expect, rather than blaming the other party, which seems dysfunctional, we embrace change together, and agree to consciously work on the relationship, to improve the next iteration of the contract … which is due to be revised and renewed anyway, next month, not next decade.
Amber fast-forwards through the dynamic chunks of the README—boring legal UML diagrams, mostly—soaking up the gist of the plan. Yemen is one of the few countries to implement traditional Sunni shari'a law and a limited liability company scam at the same time. Owning slaves is legal—the fiction is that the owner has an option hedged on the indentured laborer's future output, with interest payments that grow faster than the unfortunate victim can pay them off—and companies are legal entities. If Amber sells herself into slavery to this company, she will become a slave and the company will be legally liable for her actions and upkeep. The rest of the legal instrument—about ninety percent of it, in fact—is a set of self-modifying corporate mechanisms coded in a variety of jurisdictions that permit Turing-complete company constitutions, and which act as an ownership shell for the slavery contract. At the far end of the corporate shell game is a trust fund of which Amber is the prime beneficiary and shareholder. When she reaches the age of majority, she'll acquire total control over all the companies in the network and can dissolve her slave contract; until then, the trust fund (which she essentially owns) oversees the company that owns her (and keeps it safe from hostile takeover bids). Oh, and the company network is primed by an extraordinary general meeting that instructed it to move the trust's assets to Paris immediately. A one-way airline ticket is enclosed.