Stake Ventures

It wont hold up in court 5

Posted by Pelle Wed, 26 Mar 2008 06:06:20 GMT

Rafe Needleman wrote a review of Agree2 today: Agree2 creates binding legal documents that won’t hold up in court

I am proud of his comments about the technical aspects of the site, however the title about the legal documents that not hold up in court I find problematic. That said, I am really glad Rafe brought this up. There are plenty of myths and misunderstandings about this.

Technically, I have no beef with the service. I think it’s pretty cool, actually. But although I’m not a lawyer and even though I hate trying to decipher legal agreements when I need to, the service’s tacit encouragement to create my own non-lawyer-approved agreements scares the bejeezus out of me. Sure, I could write an agreement between me and someone I’m hiring to re-wire my house. And if the contractor I’m working with were new, he or she might even sign it. But it would still, probably, be a crappy agreement. A court might agree that the electronic edits and signatures were binding, but that doesn’t mean the agreement would be legally sound. Certainly it wouldn’t be complete.

I object to the title

Saying that Agree2 agreements don’t hold up in court is like saying agreements written in Microsoft Word, don’t hold up in court.

Agree2 is a media and a framework for you to write agreements. We take care of all phases of the contract from drafting, versioning, inviting and legal binding acceptance from the parties. We provide evidence as Rafe points out in a very easy to use manner and allow you to come back and find your contracts in the same place 2 years later.

We hope to foster a community of people to share contract templates. People have already been doing this for many years, informally emailing word documents around.

Due to California law, we can not take an active part in analyzing the contract text. However we try to provide as many tools as possible for this to be easy for you and your advisors to do.

The OAuth standards group recently used Agree2 to create their OAuth Non-Assertion Covenant and Author’s Contribution License. This has been signed by amongst others Digg, Twitter, Google and AOL. I am sure Google’s legal department would not allow them to use Agree2, if they found a problem with it.

Contracts are not between your lawyers, they are between the parties

A common misunderstanding about contracts is that they have to be scary legal documents written by lawyers.

First of all a contract is not the document itself. It is the concept of an agreement the two parties have. The written contract is a handy document that writes down the terms of the agreement in such a way that there aren’t misunderstandings of each parties duties.

We perform contracts everyday. Many of them through our actions like ordering a meal in a restaurant others written like signing a credit card slip or accepting a user agreement.

Generally speaking it is a good idea to write contracts into a document to avoid disputes in the future. This is the whole reason behind writing a contract down. Avoiding disputes. If a dispute should happen in the future this document is used by a dispute resolution institution such as arbitrators or courts.

Opaque legalese is all about fear and power

When I have had to sign long contracts in the past, I can be pretty certain that the person giving me the contract doesn’t understand it one bit. They expect that I don’t understand it either. These contracts still serve their purpose, by keeping us both too frightened to cause a dispute.

That said disputes still happen, and they happen mostly because there is some disagreement between the parties about what The Party of the First Part or some such legalese foolishness actually means. (See more)

Courts are used to standard legalese terms, that is true. There are complex hidden meanings between these. However they are also perfectly able to understand plain English. More importantly if you write your contract in Plain English yourself you are probably less likely to end up in court in the first place, because you and the other party both understand your duties under the contract.

Lawyers are needed for many things

There are definitely cases where you want to bring in lawyers. I think it’s definitely a good idea for large complex contracts. Please do NOT write up a term sheet for a large investment yourself. However in most cases it is a good idea to write the meat of the contract yourself and then have a lawyer go over it. You can then use this a private (or public) template within Agree2 and have the best of both worlds.

However it doesn’t make any sense whatsoever to have pay $400ph for a lawyer to go over a contract worth $500 to you. If you are doing this repeatedly have him go over your template.

Many contracts that should be documented end up being agreed over a phone or in a brief email instead to avoid the hassle of form documents and lawyers. Agree2 gives you a much better option than either.

We are planning a feature in the future where you can give lawyers access to review your contracts and templates.

Government requirements

Most contracts can and should be simple. There are however a few types of contracts where complexity is mandated by law. In particular apartment leases and employment contracts, where just about every state/country have specific legal requirements.

Developing OAuth clients in Ruby 4

Posted by Pelle Sat, 23 Feb 2008 22:32:33 GMT

On the request of many people here is a quick guide to developing OAuth Consumer Application (Consumer==Client in OAuth Speak) in Ruby.

I will be using Agree2 as the sample application here, so feel free to go Register and load up a irb session to follow along. You could also do the same with Twitter’s OAuth or any other OAuth server.

The general process is:

Register your consumer application with the OAuth compliant service to receive your Consumer Credentials (This is only done once)
You initiate the OAuth Token exchange process for a user by requesting a RequestToken from the Service
You store the RequestToken in your database or in the users session object
You redirect your user to the service providers authorize_url with the RequestToken’s key appended
Your user is asked by the service provider to authorize your RequestToken
Your user clicks yes and is redirected to your CallBack URL
Your callback action exchanges the RequestToken for an AccessToken
Now you can access your users data by performing http requests signed by your consumer credentials and the AccessToken.
????
PROFIT!!!

Get your Consumer Credentials

Once you are logged in to Agree2 click the Manage OAuth Applications link in the footer:

All OAuth capable applications require you to register your own application first to get your consumer credentials:

Click Register your application

Enter the name of your application, the url of your application, the callback url and an optional support url.

The callback url is the url that Agree2 redirects to after a user has authorized a token for you. For now just enter a url like http://myapp.com/oauth_client/callback. Click register and hey presto:

These are your applications Consumer Credentials.

Hooking up your code

As we are nice guys here at Agree2 also provides actual sample Ruby code on the credentials screen. I will go through this step by step.

First of all you need to install the oauth gem (make sure you have at least 0.2.2):

sudo gem install oauth

Your code needs to require the gem and the consumer part of the library:

gem 'oauth'
require 'oauth/consumer'

Instantiate your Consumer object with your credentials:

@consumer=OAuth::Consumer.new "AVff2raXvhMUxFnif06g", 
                              "u0zg77R1bQqbzutAusJYmTxqeUpWVt7U2TjWlzbVZkA", 
                              {:site=>"https://agree2.com"}

Now request a token from Agree2. This method actually performs a signed http request to https://agree2.com/oauth/request_token :

@request_token=@consumer.get_request_token

Now you need to redirect the user to the authorize_url

If you’re in irb just output the url:

@request_token.authorize_url

In a real rails application you would perform a redirect:

redirect_to @request_token.authorize_url

The user will be taken to this screen to authorize the token:

I think we need to work a bit on the user interface for this. But it does work. The user authorizes the token. and the user is redirected to the callback url you specified earlier.

In your callback action you now need to exchange the request token for an AccessToken:

@access_token=@request_token.get_access_token

Now you are ready to do whatever you wanted to do:

# Request all your users agreements
@response=@access_token.get "/agreements.xml"

The access token object has all the normal http request methods and returns a standard ruby http response.

Our next step is to integrate this with ActiveResource. This is being worked on now. Once this is done I will update this tutorial.

Create a simple NDA with zero legalese in no time at all and for free at our service Agree2.

Posted in Programming, Data Portability, Agree2
Meta no trackbacks, 4 comments, permalink

The new Instant Ruby API for Agree2 Templates

Posted by Pelle Mon, 05 Nov 2007 02:41:41 GMT

How do you get from this:

To this:

# This creates an agreement from the template
@agreement=Agree2::OptionForHolderToBuyAssetTemplate.prepare( :holder =>"John Doe",
    :asset =>"Consulting by Pelle Braendgaard",
    :amount =>"10",
    :units =>"hours",
    :price =>"$100/h",
    :valid_to =>"1 month from now")

# invite the parties
@party=@agreement.invite("johndoe@mailinator.com","John","Doe")
@party=@agreement.invite("pelle@stakeventures.com","Pelle","Br&aelig;ndgaard")

# Change something in the contract
@agreement.amount=20
@agreement.save

# Mark it as being final and ready to accept
@agreement.finalize

Hint try clicking on the Instant Ruby API in your Agree2 template: