Charter

Charter turns a plain description of a business into a sealed, ready to sign formation packet. It does everything around the government filing, then hands it to the owners to sign themselves.

Comment

Three men, a company, and nothing in writing

Three men agreed to own a Texas company in equal thirds. Nothing was signed. One of them later registered himself as the sole owner.

The other two lost, and the court never reached the question of whether the deal had existed. Chase v. Hodge, 95 F.4th 223 (5th Cir. 2024): an unwritten promise about ownership fails the statute of frauds before anybody asks whether it was made. In Sohani v. Sunesara, 546 S.W.3d 393 (Tex. App. 2018), a man claiming a third of three companies recovered nothing, on his own testimony and no records.

That document is free, and it is still the one nobody writes, because writing it means asking a friend an uncomfortable question today about a fight you might have in three years. Form fillers hand you a template with blanks. The blanks are exactly those questions.

So I built the thing that asks them.

What it does, and the step that exists to be empty

You describe a business in plain English. Charter works out which questions actually change the document and asks only those. It researches the name against businesses already trading, secures a web address, drafts the ownership agreement with every article number worked out in ordinary code rather than by a model, reads the owners' identity documents, and seals one packet.

Then step seven hands the model an empty tool list. Not tools it is discouraged from using, not a rule written into a prompt: there is nothing to call and nothing to argue with. The run stops and waits for a person to approve the packet by its own fingerprint. The owners sign it themselves.

The mechanism worth checking

An empty tool list on its own is a promise. This is not:

// src/boundary/policy.ts
guards: ['src/sign/'],
mayReach: ['src/case/send-for-signature.ts', 'src/vendors/roll-call.ts'],

One short file names every part of the program allowed to reach the module that carries a document to a person for signature. A test follows every import in the project, at any depth, and fails the build if anything else can arrive there. Code that cannot be reached cannot be run, whatever a model asks for. The same rule guards the code that writes down a person's permission to spend, so the agent has a tool for asking permission and no tool for granting one.

What I learned

A passing test is the software agreeing with itself. One outside client sat looking finished for weeks: written from the documentation, covered by tests that all passed, and wrong three ways at once. Wrong address, wrong request, wrong reply shape. The tests never saw it, because they handed the client answers of the shape it already expected. The first real call found all three in ten minutes.

So every outside company now carries one of exactly three words, and a test enforces that there are only three: live, written, not proven, not built. Nothing is called live without naming a command a stranger can run.

Three things only running it could have taught me:

  • Foxit's own engine refuses to modify our sealed packet, answering "no permission". Our rule is that nothing rewrites a sealed packet. Theirs enforces the same rule for its own reasons, and neither was told about the other.
  • The second visitor took the site down. Every run opens its own PostgreSQL engine inside the server process, which is what lets a stranger clone this and run it with no database to install, and nothing closed them. Measured, not guessed: about 210 MB each against 512 MB on the plan.
  • The site called an attestation a signature, directly above the button that starts a run. A machine act on a document is a seal, a machine vouching for its own record is an attestation, and signature is kept for what a person does. The checker built to catch exactly this missed it three ways at once.

The law took three tries

An earlier version of this project said, in three documents at once, that only humans sign what binds them. That is not the law. The Uniform Electronic Transactions Act, section 14, lets a contract be formed by electronic agents even when no person is aware of it, attributed to the person to be bound. But it defines a signature as a process executed or adopted by a person, with the intent to sign. Formation may be delegated. The signature is the act of a person, and a machine has no intent to lend it.

What is not true yet

Charter does not file with the state. It prepares everything around that filing, and the packet names the exact office and the exact form for your state, with no invented fee and no invented waiting time. Putting the finished business website online is still done by a stand-in, and two of the nine outside companies are written and have never been called. The site says so beside each of them.

The verification page asks eight questions and answers seven yes. The eighth comes back as a question mark: has anybody outside Charter confirmed this record existed when it claims? Nobody has. It stays a question mark, because a checklist that only shows the questions it passes is an advert.

npm install
npm run agent:demo   # eight steps, no account, no key, no network

1,297 tests, and a failing one is a failed deploy, on purpose.

Built With

Share this project:

Updates

Submission history