# Docs By Air ## Summary Docs By Air is a document execution system built around email as an execution layer rather than a communication tool. The product direction shifted from flexible AI-driven email workflows toward a deterministic system for completing signing entirely within an email thread. ## Metadata - Role: Product Design, System Architecture - Platform: Email (execution layer) - Scope: Self-initiated product, end-to-end definition and build - Timeline: 2026 — Present - Audience: Individuals and teams executing agreements - Status: Active ## Key Concepts - Email is treated as an execution layer, not just a communication channel. - The signing flow was simplified until a reply with a name became the signature. - The interface resolves to the address itself: `sign@docsbyair.com`. - The core system is deterministic, with ambiguity removed wherever possible. - AI is used only where deterministic validation breaks down. - The product is positioned as an execution system rather than a signing platform. ## Full Content ### Overview Docs By Air began as an exploration into using email as an execution layer rather than a communication tool. Early versions followed a familiar pattern, with flexible inputs, conversational flows, and broad capability. It worked, but it didn’t hold up as a product. The system relied too heavily on interpretation, and the outcomes weren’t reliable enough for execution. Prioritizing reliability over flexibility shifted the direction entirely. Instead of asking what AI could do in email, the focus became what workflows already existed there that required deterministic outcomes. Documents stood out. Email is where documents are sent, reviewed, and approved. The behavior already exists, but execution typically happens outside the thread. The opportunity wasn’t to introduce something new. It was to complete what was already happening. ### The moment it simplified The first versions of the signing flow were overdesigned. There were instructions, confirmations, structured replies, and even required legal statements the signer had to copy and paste. It was technically correct, but introduced unnecessary friction. The breakthrough came from recognizing what was already present. A reply with a name, in the context of a request, tied to a document, inside a thread functions as a signature. Nothing else needed to be added. No links. No dashboards. No signing pages. Just a reply. #### Email execution flow 1. Sender initiates - To: `sign@docsbyair.com` - CC: `jane@example.com` - Subject: `Service Agreement` - Attachment: `Service-Agreement.pdf` 2. System instruction - Subject: `Sign - Service Agreement` - Request: `You’ve been requested to sign Service-Agreement.pdf` - Instruction: `To sign, reply with your full name.` 3. Signer reply - Signature: `Jane Elizabeth Doe` 4. Execution confirmation - Subject: `Signed - Service Agreement` - Status: `Service-Agreement.pdf has been signed.` - Output: `The executed document is ready.` 5. Fulfillment - Subject: `Executed Document Ready - Service Agreement` - Message: `The executed document is now available.` - Action: `[Download Link]` ### The interface became the address That simplification exposed something more fundamental. The interface wasn’t the email. It was the address. #### Address breakdown - `sign` — Action - `@` — Transport - `docsbyair.com` — Execution System `sign@docsbyair.com` isn’t just where the request is sent. It defines the action itself. The intent exists before the email is even written. That removes the need for almost everything else. No subject or body requirements. No structured inputs. No instructions beyond the action itself. Attach the document. CC the signer. Send. The rest happens. ### The system became deterministic Every decision after that followed the same pattern. Anything that introduced ambiguity was removed. Anything that required interpretation was reduced. The system became entirely deterministic. A request *is* valid or it *isn’t*. A reply *is* accepted or it *isn’t*. A document *is* executed or it *isn’t.* The entire flow collapses into a single sequence: - Send Email - Request Validation - Await Signature - Reply Received - Reply Validation - Executed - Awaiting Payment - Fulfilled There are no alternative paths. That’s the point. ### Where AI actually fits By the time the system worked, it didn’t require AI. All critical behavior was handled through structure, including thread integrity, validation, and explicit state transitions. AI was introduced only where deterministic logic breaks down. A signature relies on a person identifying themselves. Most replies contain a name, but not always in a way that can be strictly validated. #### AI classification flow - Reply Received - Deterministic Check - AI Classification - Accept - Reject - Review - Initiator Decision AI is used to evaluate plausibility by classifying whether a reply functions as a name and deferring to the initiator when uncertain. It doesn’t determine identity. It reinforces the system where strict rules are insufficient. ### An execution system Docs By Air isn’t a signing platform. It’s an execution system. There’s no interface to open. No dashboard to manage. No place to go. You send something into it, and it completes the action. The thread is the record. The document is the source of truth. The reply is the signature. Everything else is removed. Most software adds layers to support more capability. Docs By Air moves in the opposite direction by collapsing those layers so the intent behind an action can pass through without friction. The result isn’t less capability, but a clearer path from intent to outcome, where the system exists to complete the action rather than mediate it. ## Key Decisions - Shifted the product from flexible AI-driven email workflows toward deterministic document execution. - Reduced the signing interaction to a reply with a name inside the existing thread context. - Treated the address itself, `sign@docsbyair.com`, as the interface. - Removed requirements for subject lines, body formatting, structured inputs, and extra instructions. - Constrained AI to reply classification where deterministic validation is insufficient. ## Outcome Docs By Air became a deterministic execution system for signing through email, with a clearer path from intent to outcome and no separate interface to open or manage.