Agent and Human Activity Log
Executed NDA
Certificate of Negotiation
webMCP test page
Home
Executed NDA Signature

Mutual Assent AI

Inspiration

I got off an intro call recently and needed to send an NDA. Standard stuff, and drudgery on both ends. The sender digs up a template, guesses at terms, emails it, and waits. The signer gets eight clauses of legalese and their choices are read it carefully, pay a lawyer, or skim it and hope. Any change means redlines flying back and forth over email for a document that's supposed to be routine.

I asked DocuSign's assistant for help. It can't summarize the contract. It can't redline a clause. It definitely can't negotiate. It can answer questions about using DocuSign, so it can help me find the sign button. That's it.

And whatever AI DocuSign ships next will live in their platform. Both parties can have DocuSign accounts, and maybe someday their agent helps both. But then it's one company's AI on both sides of an adversarial negotiation. It can't represent either party, and it doesn't know what each side's own agent already knows: your situation, your other clients, your limits, everything from every other conversation you've had with it.

An agent that represents you can't be a feature of a platform. It has to be yours.

So the idea: make the contract page neutral ground and let each party bring their own agent. Mine knows me. Theirs knows them. Neither one works for the platform. The page is just the table.

WebMCP is what makes that work: the tools live in the page itself, so each side's agent can use them no matter which agent it is. ChatGPT on one side, Claude on the other, doesn't matter.

What it does

Mutual Assent AI is contract negotiation where agents do the haggling and humans do the signing. It works on any templated two-party agreement. The NDA is just the first template, and it's what the demo shows.

An author creates an NDA from a template and sends a link. Each party gets their own capability link, their own seat at the table. The signer opens it and hands it to whatever agent they use. No briefing needed. His agent already knows he does prior work for other clients and won't go past a two year term, so it just confirms: protect the prior work, cap the term at two years? He says yes and it gets to work. None of that context ever touches my server.

The agents negotiate term by term, in the document itself. Proposals show up as redlines with the reasoning attached. When an agent hits something above its pay grade, it stops and asks its human. When all terms are agreed, both humans review the final redline and sign. Agents can't sign. There's no signing tool for them to call, and that's on purpose.

At the end you get an executed NDA plus a Certificate of Negotiation: a sealed, hash-verified record of which agent proposed what, under whose authority, and which human approved it. E-signature proves who signed. This also proves how the deal was reached.

How I built it

I built it with Sol 5.6 in Codex using loop engineering: worker models build against the spec in an automated loop, and a judge model checks their output and sends back anything that doesn't pass. I wrote the spec, watched the loops, and made the final calls on what shipped.

It's hosted on Vercel, with Supabase behind it and Resend for the emails. Nano Banana helped with the graphics.

WebMCP tools register directly in the page: read the deal, propose a term, respond to a proposal, escalate to the human, mark ready to sign. They register and unregister based on your role and the deal's phase, so an agent can't take an action the page doesn't offer its human.

The design keeps the contract front and center. Proposals show up as redlines right in the clause, marked with which side's agent made them, so a human can glance at the page and see where the negotiation stands. Templates are just data, a list of terms with options, and the tools generate from the template. Swap in a different template, same engine negotiates a different contract. That's why the next document type is about an hour of work.

Challenges

The hard part wasn't building the negotiation, it was making WebMCP's benefits visible. They're structural: tools ship with the page, identity comes from the link, no platform sits between the parties. Like any great technology, it's invisible when done right. It just looks like a live web page.

The nastiest bug was a security hole. Both parties originally shared one URL, which meant either side could propose, accept, and sign as the other, poisoning the audit trail the whole product depends on. I fixed it with independent 128-bit capability tokens per party, server-side role resolution on every request, and a rule that no response ever contains the other party's token.

What I learned

Agent identity is the interesting problem. Everything in the WebMCP showcase is one human plus their agent collaborating. Two parties is harder: the sides have opposing interests, there's no shared platform mediating, and when agents did part of the negotiating, you need a trustworthy record of who did what. That's what the certificate is for, and it turned out to matter more than I expected when I started.

Also, WebMCP turns out to be a gift for legacy systems. My demo doesn't show this, but it was a lightbulb moment for me. In an old internal app, the business rules live in the pages and the only reliable way to do anything is through the UI. Building a normal MCP server means recreating those rules outside the app, basically a rewrite. With WebMCP you add tools to the pages you have, calling the same functions the buttons already call. Validation, permissions, sessions all come along for free. Systems that were never getting an API can go agent-ready from the front end alone.

What's next

More templates. Consulting SOWs are next because I'll use them myself. Then user testing with real freelancers and small firms sending real contracts, since that's where I'll find out what people actually trust an agent to negotiate. Once the idea is validated, I'll start charging for it. The long game is a neutral table for every two-party document: leases, offer letters, creator deals.