AI sales automation tools, mapped.
The agent-native sales stack splits into four layers. The agent does the work: Claude, ChatGPT in developer mode, Cursor, Claude Code, and frameworks like LangGraph or CrewAI. The context layer feeds it: call recorders like Fathom, Granola, and Fireflies. The closing layer turns talk into money: contract, e-signature, and payment in one flow, which is LetSign. And the rails run it on a schedule: n8n, Make, and Zapier's beta MCP client. This page maps every layer to the exact playbook, recipe, or comparison you need.
Pick the agent that does the selling
Every playbook below wires the same closing layer into a different agent, from chat assistants to coding agents to full orchestration frameworks. Each one covers the verified MCP setup, a working prompt, and the sign-and-pay flow. If you want the whole architecture in one page, start with the reference stack.
Claude
Automate your sales with Claude on claude.ai or Desktop, via a custom connector.
OpenClaw
Drop LetSign into a self-hosted OpenClaw agent's mcpServers; it drafts, sends, and gets contracts signed and paid.
Hermes
Connect LetSign to a Hermes agent (Nous Research) over MCP; it drafts, you send, the client signs and pays.
Claude Code
Run the whole sales loop from the CLI you already live in.
ChatGPT
Connect LetSign in developer mode and close deals from a chat.
OpenAI Codex CLI
Add LetSign to config.toml and sell from the terminal.
Cursor
Draft, send, and track contracts without leaving the editor.
Cline
Wire the remote MCP server into Cline inside VS Code.
Windsurf
One mcp_config.json entry and Windsurf can close deals.
VS Code + Copilot
Run the flow in Copilot agent mode via MCP: Add Server.
Goose
Add LetSign as a remote extension with goose configure.
n8n
Attach the MCP Client Tool node to an AI Agent node.
Make.com
Drop the MCP Client module into any Make scenario.
Zapier
Turn LetSign tools into Zap actions with MCP Client by Zapier, in beta.
LangGraph
Load LetSign tools into any LangGraph agent with MCP adapters.
CrewAI
Hand LetSign tools to a crew with the MCPServerAdapter.
Feed the agent what was actually said
Call recorders capture the scope, the numbers, and the promises from your sales calls, so the agent drafts the proposal from what the client actually heard. The recipe for going from a recorded call to a sent contract lives in the call-to-contract recipe on the MCP docs.
Fathom
Records and summarizes your sales calls, so the numbers and promises you made are already written down.
Granola
Turns meeting audio into clean, structured notes your agent can quote terms from.
Fireflies
Transcribes and searches every call, giving the agent the full history of a deal.
Turn the conversation into a signed, paid deal
The closing layer is where contract, e-signature, and payment collapse into one link. The agent authors the proposal, a human reviews and sends it, and the client picks a plan, verifies their email, signs a binding e-signature, and pays through your own Stripe. Start with the definition guide, then see how it compares with the tools it replaces.
What is an agent-native contract?
The definition guide: a binding agreement an agent can generate, send, get signed, and collect payment on.
LetSign vs DocuSign
Agent-native contracts against the incumbent e-signature dashboard.
LetSign vs PandaDoc
How an MCP-first closing layer compares with proposal software.
LetSign vs Proposify
Proposals your agent writes versus proposals you assemble by hand.
LetSign vs Qwilr
Interactive proposal pages compared with sign-and-pay links.
LetSign vs Bonsai
The freelancer suite next to a closing layer your agent operates.
Put the whole loop on rails
Rails trigger the stack without a human kicking it off: a form submission, a finished call, a CRM stage change. Each playbook shows how the automation platform consumes LetSign's MCP server directly.
Frequently asked questions
Which layer should I start with?
Start with the agent you already use and the closing layer. Pick your agent's playbook, install LetSign, and you can take a deal from draft to signed and paid the same day. The context layer and the rails make that loop richer and more automatic, but the agent plus the closing layer is the working core.
Do I need all four layers?
No. An agent with LetSign installed already covers drafting, sending, signing, and payment. Add a call recorder like Fathom, Granola, or Fireflies when you want proposals written from real call notes, and add rails like n8n, Make, or Zapier when you want the flow to trigger itself instead of waiting for a prompt.
What does the closing layer cost?
LetSign has a free plan at $0 per month with a 0.20% fee on payments collected. The launch plan is $19 per month if you subscribe before October 1, 2026, with the price and rates locked until October 1, 2028; after the deadline the standard plan is $49 per month. Paid plans pay 0% on payments up to $20,000 collected per month, then 0.05% on the amount above the cap only.
Start at the layer that closes: install LetSign
Install LetSign in one click, connect your Stripe, and let the agent you already use take deals from draft to signed and paid.