Cursor .cursor/rules + Signbee MCP: Automate Contracts from Your IDE (2026)

1. The Agency & CTO Bottleneck: Why Contracts Belong Next to Your Codebase

Every software consultancy, dev shop, and fractional CTO knows the friction of the “spec-to-contract gap.” Your engineering truth lives inside your repository: schema.prisma defines the data models, docs/roadmap.md outlines the delivery phases, and your git commit log proves exactly which features shipped during Sprint 4. Yet when it is time to issue a Statement of Work (SOW), a Paid Discovery Agreement, a Subcontractor NDA, or a Milestone Sign-Off Certificate, technical leaders are forced to leave their IDE, open Google Docs or Microsoft Word, manually copy-paste deliverables, export a PDF, upload it into a legacy web portal, and drag signature rectangles across the page.

This manual context switch is not merely tedious—it introduces expensive commercial drift. Scope tables in Word documents routinely fall out of sync with actual API routes and database migrations in the repository, creating billing disputes during User Acceptance Testing (UAT).

By combining Cursor's modular .cursor/rules/*.mdc architecture with the Signbee Model Context Protocol (MCP) server, your IDE becomes a deterministic legal operations terminal. Cursor Agent can read your live repository context (@Git, @Branch, @schema.prisma), apply your company's exact legal clauses from a version-controlled .mdc rule file, and dispatch the resulting CommonMark agreement through Signbee—a workflow that exemplifies why developer-first teams rank Signbee among the best e-signature APIs for developers in 2026.

“When your Statement of Work is generated directly from the same repository context as your architecture decision records and git tags—and governed by a version-controlled .cursor/rules/contracts.mdc file—scope creep and manual PDF staging disappear overnight.”— Modern AI-Native Software Agency Playbook, 2026

2. Evolution of IDE Rules: Legacy .cursorrules vs. Scoped .cursor/rules/*.mdc + MCP

In early versions of Cursor, developers placed all project instructions into a single monolithic .cursorrules file at the root of the repository. Mixing React component styling rules, database migration instructions, and commercial contract templates inside one flat file polluted the model's context window on every keystroke.

Cursor's modern .cursor/rules/ directory uses MDC (.mdc) files containing YAML frontmatter (description, globs, alwaysApply). This allows Cursor's semantic router to load your contract rules only when you ask the Agent to draft or send an agreement, or when working inside a contracts/ or sow/ directory:

3. Step 1: Register signbee-mcp in .cursor/mcp.json

First, connect Cursor's Model Context Protocol host to Signbee. Generate your API key from your Signbee dashboard (or start with a free developer key as covered in our free e-signature API guide). Then create or edit ~/.cursor/mcp.json (recommended so your secret API key stays in your personal home directory and works across all projects) or .cursor/mcp.json inside your workspace:

{
  "mcpServers": {
    "signbee": {
      "command": "npx",
      "args": ["-y", "signbee-mcp"],
      "env": {
        "SIGNBEE_API_KEY": "signbee_live_9f8e7d6c5b4a3f2e1d0c9b8a"
      }
    }
  }
}

Open Cursor Settings → MCP. You will see signbee listed with a green status indicator and its registered tools (send_document and get_document_status). Unlike legacy providers where DocuSign API pricing and OAuth setup require configuring redirect URIs and RSA keypairs before sending a single test document, signbee-mcp boots in under a second over stdio.

4. Step 2: Create Your Scoped .cursor/rules/contracts.mdc Playbook

Next, create .cursor/rules/contracts.mdc inside your repository. This file acts as your deterministic legal guardrail. Whenever you ask Cursor Agent to draft or send an SOW, NDA, Change Order, or Milestone Acceptance Certificate, Cursor automatically injects this rule file into context so the model uses your exact corporate entity details, hourly rate card, governing law, and CommonMark table schema:

---
description: Legal contract generation, Statement of Work (SOW) drafting, UAT Acceptance Certificates, NDAs, and Signbee MCP e-signature dispatch rules.
globs: ["contracts/**/*.md", "docs/sow/**/*.md", "docs/proposals/**/*.md"]
alwaysApply: false
---

# Corporate Contract & Signbee MCP Execution Rules

When asked to draft, generate, or send any legal contract, Statement of Work (SOW), Change Order, NDA, or Deliverable Acceptance Certificate:

## 1. Authorized Party A Identity (Default Sender)
- **Legal Entity**: B2bee Ltd (Company No. 15482910)
- **Authorized Signer (`sender_name`)**: Michael Beckett
- **Authorized Email (`sender_email`)**: michael@b2bee.ai
- **Governing Law**: England and Wales

## 2. Mandatory CommonMark Formatting for Signbee PDF Compiler
- Always generate contracts in strict CommonMark markdown.
- Never use raw HTML tags inside the contract body.
- Always include an itemized Markdown Table for deliverables, git commits/PRs, target dates, and fees:
  | Milestone / Deliverable | Technical Scope & Verification | Target Date | Fee (GBP/USD) |
  |---|---|---|---|
- Compute exact arithmetic totals before populating table footers and VAT rows.

## 3. Mandatory Protective Clauses
- **Intellectual Property**: Background IP remains the property of Provider (B2bee Ltd). Custom foreground code assigns to Client only upon receipt of cleared payment in full.
- **Limitation of Liability**: Total aggregate liability under any SOW is strictly capped at 100% of fees paid in the preceding 6 months.
- **Payment Terms**: 50% upfront upon SOW signature, 50% upon UAT deployment. Net 7 days.

## 4. Signbee MCP Dispatch Protocol
- Before calling the `send_document` tool on the `signbee` MCP server, verify that `recipient_name`, `recipient_email`, and `title` are explicitly stated.
- Default `expires_in_days` to `14` unless instructed otherwise.
- After calling `send_document`, output the returned `document_id` and `https://signb.ee/verify/[id]` URL in a summary block.

Look closely at the YAML frontmatter at the top of .cursor/rules/contracts.mdc. Because alwaysApply: false is combined with a rich semantic description and globs pattern, this rule consumes zero tokens while you are debugging TypeScript components or writing SQL queries. The moment you mention “SOW”, “NDA”, “Acceptance Certificate”, or “Signbee” in Cursor Agent, Cursor attaches contracts.mdc automatically.

5. Three High-Leverage Developer Workflows Inside Cursor Agent (Cmd+I)

Once .cursor/mcp.json and .cursor/rules/contracts.mdc are in place, technical founders and agency leads can run end-to-end commercial workflows directly from Cursor Composer. Teams that previously evaluated self-hosted containers in our open-source e-signature API comparison or sought an affordable e-signature API integration use these three daily prompts:

# Workflow 1: Generate & Send a Fixed-Scope SOW from Architecture Docs
"@docs/phase2-architecture.md @prisma/schema.prisma Draft a Phase 2 Statement of Work
for 'Tapton Capital Ltd' (Matthew Archer, matt@taptoncapital.co.uk) covering the
new multi-lender underwriting pipeline and webhook routes defined in the spec.
Price Phase 2A (Schema & API) at £4,500 and Phase 2B (Admin Dashboard) at £3,500 + VAT.
Save a local copy to contracts/tapton-phase2-sow.md and send it via Signbee MCP."

# Workflow 2: Issue a UAT Deliverable Acceptance Certificate from Git History
"@Git (last 12 commits on main) Draft a formal Phase 1 Deliverable Acceptance & Sign-Off
Certificate for 'Ruislip Windows Ltd' (David Collins, d.collins@ruislipwindows.co.uk).
Include a markdown table listing the exact shipped commits, API endpoints, and PWA screens
completed this sprint, and dispatch it for signature via Signbee MCP."

# Workflow 3: Instant Contractor NDA + IP Assignment Before Granting Repo Access
"Draft a Subcontractor Mutual NDA and Foreground IP Assignment Agreement for incoming
freelance engineer 'Lucas Meyer' (lucas@meyerdev.io) covering the 'signbee-core'
repository, and dispatch it via Signbee MCP with a 7-day expiry."

In Workflow 2 above, Cursor Agent executes git log -n 12 --oneline (or reads the @Git context object), extracts the real commit hashes and feature descriptions, builds a verifiable acceptance table in CommonMark, and presents the signbee:send_document tool confirmation card in the Composer sidebar. One click on Run Tool compiles the A4 PDF on Signbee's servers and emails your client their interactive signing link.

6. Agency ROI & Pricing Benchmark: Cursor + Signbee MCP vs. Traditional CLM Stacks

For software consultancies, fractional CTOs, and SaaS teams that also embed customer-facing contracts via a white-label e-signature API, replacing manual document preparation and legacy per-seat CLM subscriptions yields measurable engineering time savings. Reviewing our 2026 e-signature API pricing comparison alongside agency time-tracking benchmarks highlights the operational impact across 100 client agreements per year:

7. Secret Hygiene, Tool Confirmation & SHA-256 Legal Validity

When running contract automation inside an AI IDE, follow three golden security practices:

• Keep SIGNBEE_API_KEY Out of Git History: Store your active signbee MCP server block in your user-level ~/.cursor/mcp.json file rather than committing live tokens to a shared repository. Commit only .cursor/rules/contracts.mdc to version control so every team member shares the exact same legal clauses.
• Keep Cursor's MCP Tool Confirmation Gate Active: Do not add send_document to Cursor's Yolo/Auto-Run allowlist. Keeping the single-click confirmation card enabled lets you visually verify the recipient email and fee table in Cursor Composer before the HTTP POST request fires.
• Two-Party SHA-256 Non-Repudiation: Once confirmed, Signbee binds Party A via your API key, emails Party B an interactive signing ceremony link (https://signb.ee/sign/[token]), and seals the completed PDF with an A4 Signing Certificate and SHA-256 hash verifiable at https://signb.ee/verify/[id].

8. Frequently Asked Questions: Cursor .cursor/rules + Signbee MCP