SignLatch

• 

  SignLatch keeps AI document preparation reversible until a person approves the exact release.

Inspiration

AI agents can prepare agreements, choose recipients and place signature fields, but preparation is not authority. In a signing workflow, one plausible agent mistake can create a real legal or commercial commitment. SignLatch asks: who approved this exact document, for these exact recipients and fields, before it left the system?

What it does

SignLatch turns a plain-language agreement request into a controlled signing workflow. Foxit's PDF MCP tools perform reversible document preparation. The system binds the PDF hash, recipients, fields, policy findings, business intent and Foxit provenance into one immutable review snapshot.

A person must inspect and approve that exact snapshot. Any material change invalidates the approval, and restoring an old value does not revive it. Sending is a separate, budgeted action that calls Foxit eSign with independent credentials.

The public demo also proves the completed lifecycle without exposing private document data: one consenting signer completed a real Foxit sandbox envelope; Foxit reported it executed; SignLatch reconciled eight authenticated provider events, downloaded and structurally validated the 60,071-byte executed PDF, and stored its SHA-256 digest before marking the workflow complete.

How we built it

• TypeScript, React and Next.js for the application and review experience.
• PostgreSQL for durable workflow state, approvals, attempts and provider events.
• Foxit PDF Services through Foxit's open-source MCP server for reversible work.
• Foxit eSign API for separately authorized dispatch and lifecycle completion.
• GitHub OAuth for reviewer identity.
• Deterministic snapshot hashing and atomic approval consumption.
• Authenticated reconciliation, executed-PDF validation and SHA-256 evidence.
• Unit, integration, browser, accessibility and adversarial tests.

Challenges we ran into

The hard part was not generating a PDF; it was making authority explicit across an asynchronous provider workflow. We distinguished an accepted API request from a provider-visible envelope, recovered safely from ambiguous attempts, prevented duplicate sends, and closed the workflow only when authenticated lifecycle evidence and the executed PDF agreed.

We also redesigned the first evidence-heavy screen into a human decision flow: agreement, recipient, fields, policy findings and consequence come before the technical provenance, while the audit data remains available for verification.

Accomplishments that we are proud of

• A genuine human approval boundary, not a decorative confirmation button.
• Invalidation on every material mutation, including restore-and-replay attempts.
• A complete Foxit sandbox lifecycle ending in a human-signed document.
• Privacy-safe public proof with lifecycle facts and hashes, not private contents.
• A public repository and live application built in public from day one.

What we learned

Provider success is evidence only when it can be reconciled. A safe signing agent needs explicit authority, idempotent dispatch, observable transitions and artifact-level verification. Human-in-the-loop design is strongest when the human approves a cryptographically bound decision, not a screen that may change.

What's next

Organization policies, multi-reviewer thresholds, template-specific risk rules, webhook replay tooling and more signing providers behind the same evidence model. The long-term product is an auditable commitment boundary for regulated agents.

Built With

• docker
• foxit
• github
• next.js
• playwright
• postgresql
• react
• typescript