Claude Skills (SKILL.md) + Signbee MCP: Packaging Zero-Hallucination Contract Signing for Teams (2026)
How to combine Anthropic's 3-layer Agent Skills architecture (SKILL.md + reference clause libraries) with npx -y signbee-mcp and npx skills add signbee/skill so enterprise AI agents draft and dispatch legally binding agreements with zero schema or clause hallucinations.
Quick Answer (TL;DR)
SKILL.md Progressive Disclosure • Signbee MCP • Enterprise Contract Governance
Raw MCP tool definitions tell an LLM how to call an endpoint, but not which legal clauses your general counsel approves. By pairing the Signbee MCP server (npx -y signbee-mcp) with the official declarative skill (npx skills add signbee/skill --skill signbee -g) and a team-specific SKILL.md playbook, your agents load canonical Markdown contract templates on demand and execute send_document or POST /api/v1/send with 100% deterministic compliance.
1. Why MCP Alone Isn't Enough for Enterprise Legal Ops
When engineering and revenue teams connect an autonomous agent to an e-signature API via Model Context Protocol (see our Claude Desktop MCP setup guide), they solve transport and authentication. The agent can call send_document or send_document_pdf in a single turn.
However, in multi-person organizations, a second failure mode emerges: clause drift and payload improvisation. Left to draft an NDA or Master Services Agreement from generic training weights, an LLM might invent governing law jurisdictions, omit mandatory GDPR data processing schedules, or pass malformed Markdown tables. Anthropic's SKILL.md standard eliminates this by separating declarative domain playbooks from MCP tool execution.
2. The 3-Layer Claude Skill + Signbee MCP Architecture
Instead of bloating every agent conversation with 15,000 tokens of legal templates, a well-structured Signbee contract skill uses three progressive layers:
| Skill Layer | File / Artifact | Token Footprint | Role in Contract Execution |
|---|---|---|---|
| Layer 1: Discovery Metadata | SKILL.md (YAML Frontmatter) | ~45 tokens (Always loaded) | Triggers skill when user asks to send an NDA, SOW, MSA, or DPA |
| Layer 2: Execution Guardrails | SKILL.md (Instruction Body) | ~500 tokens (On trigger) | Enforces pre-flight checks, fee thresholds, and Signbee API/MCP schema |
| Layer 3: Canonical Templates | references/*.md | 0 tokens until read | Exact General Counsel-approved Markdown templates with variable slots |
| Execution Engine | npx -y signbee-mcp | Tool Call (Stdio / HTTP) | Renders PDF, emails magic link, and seals two-pass SHA-256 certificate |
3. Installing the Official Signbee Skill & Building a Team Playbook
First, install the base Signbee skill and configure the MCP server so Claude Code, Claude Desktop, or Cursor has both the declarative API reference and the live tool runner:
# 1. Install the official Signbee skill globally
npx skills add signbee/skill --skill signbee -g
# 2. Register the Signbee MCP server in Claude Code
claude mcp add signbee -e SIGNBEE_API_KEY="signbee_live_your_key" -- npx -y signbee-mcpNext, create a workspace-level skill at .claude/skills/enterprise-contracts/SKILL.md that locks in your company's commercial guardrails before dispatching via Signbee:
---
name: enterprise-contracts
description: Draft and dispatch approved NDAs, Statements of Work (SOW), and DPAs via Signbee MCP (send_document / send_document_pdf) or POST https://signb.ee/api/v1/send.
---
# Enterprise Contract Execution Playbook (Signbee MCP)
## 1. Mandatory Pre-Flight Rules (Zero Hallucination Gate)
1. **Never improvise legal clauses**: Always read the matching template from `./references/` (`mutual-nda.md`, `sow-fixed-fee.md`, or `uk-gdpr-dpa.md`) before calling Signbee.
2. **Commercial Approval Cap**: If a Statement of Work exceeds $50,000 USD or modifies Section 8 (Limitation of Liability), ask the user for explicit confirmation before invoking `send_document`.
3. **Payload Validation**: Verify `recipient_name` and `recipient_email` are non-empty and never include synthetic placeholder emails (`example.com`).
## 2. Execution via Signbee MCP or REST API
- **For Markdown Templates**: Invoke `send_document` (or `POST https://signb.ee/api/v1/send`) with `title`, `markdown`, `recipient_name`, `recipient_email`, and `expires_in_days: 14`.
- **For Pre-Rendered PDFs**: Invoke `send_document_pdf` with `title`, `pdf_url`, `recipient_name`, and `recipient_email`.
- **Status Verification**: Poll `GET https://signb.ee/api/v1/documents/{id}` using `Authorization: Bearer $SIGNBEE_API_KEY` to confirm `status === "signed"` and retrieve `signed_pdf_url`.4. Automated Verification & Two-Pass SHA-256 Audit Trail
Once the Claude agent populates the approved template and calls send_document, Signbee immediately records Party A's API-authenticated signature and dispatches a zero-login signing link to Party B. Upon counterparty execution, Signbee's pdf-lib engine appends a tamper-evident Signing Certificate page and hashes the final PDF byte stream with SHA-256. For deeper comparisons of skill-driven IDE workflows, see our Cursor .cursor/rules MCP guide and Google Antigravity & Gemini CLI MCP guide.
5. Frequently Asked Questions: Claude Skills & Signbee MCP
How do Anthropic Claude Skills (SKILL.md) complement the Signbee MCP server?
While the Signbee MCP server (npx -y signbee-mcp) exposes deterministic execution tools (send_document and send_document_pdf), a 3-layer Claude Skill (SKILL.md + references/) enforces your organization's legal playbook, pre-approved clause library, and mandatory JSON field invariants before the tool call is ever invoked.
How do I install the official Signbee Agent Skill for Claude Code, Cursor, and Antigravity?
Run npx skills add signbee/skill --skill signbee -g in your terminal. This installs the canonical SKILL.md definition globally so Claude 4.5 Sonnet/Opus, Cursor, and Gemini agents automatically load Signbee's exact API schema, Markdown formatting rules, and status-polling conventions on demand.
Why does progressive disclosure in SKILL.md reduce contract payload hallucinations?
Instead of stuffing 20,000 tokens of legal boilerplates into the system prompt on every turn, Claude Skills use a 3-layer progressive disclosure model: YAML frontmatter (~50 tokens) for intent matching, SKILL.md (~500 tokens) for workflow guardrails, and on-demand reference files (references/sow-fixed-fee.md) read only when drafting a specific contract type.
Can a Claude Skill enforce mandatory human approval or fee caps before calling send_document?
Yes. By encoding explicit pre-flight verification rules in SKILL.md—such as requiring liability caps to match standard tiers or validating recipient email domains before calling POST /api/v1/send—teams prevent autonomous agents from dispatching unapproved commercial terms.
Standardize Your Team's AI Contract Playbooks
Install npx skills add signbee/skill and npx -y signbee-mcp in 60 seconds. Start free with 5 documents/month.