One of the projects that we’ve been working on here at Robot Robot and Hwang headquarters is an open source project to develop the legal infrastructure to allow for large scale securitizing of lawsuits. We’ve been working on some of the basic pseudocode necessary for this to happen that’ll be releasing up on Github in a little bit, but wanted to drop out a post outlining the project and what we’ve been thinking about recently.
The basic concept is that there’s convertible risk in the current setup that’d allow for a potential restructuring of the legal market. Individual people have legal claims that they might want to pursue, but pursuing them tends to be an extremely costly and potentially risky proposition. There’s situations where they’d prefer to take an upfront, certain payout in exchange for the rights to a risky payment from pursuing the case.
Firms that have the capital are able to pool the risk by taking on a large number of claims, and reaping the benefit from the payments that come back. At the same time, these pooled bodies of lawsuits are also potentially attractive investments as assets for a whole range of financial firms, who would be willing to buy the rights and take a chunk of the payment as they are processed by firms and the court system. Firms would be willing to sell these pools as bundled assets if there was a framework, since it’d allow them to receive money upfront and fund the pursuit of these claims in the first place. As we’ve noted before, this happens already — though generally on a more one-off scale that doesn’t permit for a larger market to form.
The legal securities project is an effort to set up the legal code that’d put this into place and allow for this to happen. Specifically, there’s two big chunks of contract language that’s needed for something like this to happen:
1) A compiler: Which would allow for a standardized, boilerplate structure for people with claims to exchange the rights to the payout from those claims for a certain upfront payment. These claims would be sold to a bundler, who would act as a wholesale buyer of claims. In the simplest form of the idea, the bundler is a large law firm, who would also take on the role of processing these claims. In future iterations, we might add an initial decoupling step where the bundler sells the claims out to bidding law firms before assembling the complete security.
2) A “securitizer”: Which would allow for a bundler or law firm to stack and merge these purchased claims into a single contract which could then be sold out in the open market. Essentially the contract would allow a purchaser to receive regular payouts as the lawsuits are processed by the bundler.
We’re currently cranking on getting an alpha version of the compiler together and documented so people can take a look at the source and contribute/make suggestions. Stay tuned.