Google Antigravity & Gemini CLI + Signbee MCP: Autonomous E-Signature Workflows (2026)
How to equip Google Antigravity IDE, subagent swarms, and Gemini CLI with Signbee's Model Context Protocol server (npx -y signbee-mcp) and Agent Skill (npx skills add signbee/skill) for single-call contract generation and SHA-256 certified e-signing.
Quick Answer (TL;DR)
Google Antigravity IDE • Gemini CLI • MCP & Direct REST Integration
To add legally binding contract execution to Google Antigravity IDE and Gemini CLI, register npx -y signbee-mcp in your MCP configuration or install the global skill via npx skills add signbee/skill --skill signbee -g. Gemini 2.5 Pro and Flash agents can then synthesize Statements of Work, release sign-offs, and NDAs directly from your repository context and dispatch them via send_document, send_document_pdf, or POST https://signb.ee/api/v1/send—producing a two-pass SHA-256 sealed PDF in under 200ms with zero OAuth browser popups.
1. Why Agentic IDEs Like Google Antigravity Need a Deterministic Signing Primitive
Google Antigravity and the Gemini CLI have transformed how engineering leads, technical founders, and agency orchestrators ship software. With a 1-million-plus token context window and native subagent delegation (invoke_subagent), an Antigravity orchestrator can inspect an entire monorepo, audit a Prisma database schema, calculate scope changes, and prepare a client deliverable schedule in seconds.
However, until recently, the final mile of commercial execution—getting a client, vendor, or security officer to legally sign off on a Statement of Work (SOW), penetration test authorization, data processing addendum (DPA), or production deployment waiver—forced engineers out of the terminal and into clunky legacy web portals.
As demonstrated in our October 2026 State of AI Agent Contract Signing Benchmark, legacy e-signature APIs fail on 34.2% of autonomous LLM calls because they require 2D X/Y pixel coordinates and multi-step OAuth 2.0 multipart uploads. Signbee solves this by giving Antigravity and Gemini CLI a single-call, Markdown-first and PDF-ready execution layer.
2. Integration Architecture Matrix: Antigravity MCP vs. Agent Skill vs. Direct REST
Depending on whether you are configuring a persistent local workstation in Google Antigravity, equipping autonomous subagents with workspace skills, or building headless CI/CD pipelines with Gemini CLI, Signbee supports three complementary integration surfaces:
| Integration Surface | Installation Command | Primary Tools / Endpoints | Best For |
|---|---|---|---|
| Signbee Stdio MCP Server | npx -y signbee-mcp | send_document, send_document_pdf | Interactive Antigravity IDE & Gemini CLI tool calling |
| Signbee Agent Skill (SKILL.md) | npx skills add signbee/skill | SKILL.md + Direct HTTP fetch | Zero-process subagent swarms & portable repo rules |
| Direct REST API (v1) | Zero install (HTTPS) | POST /api/v1/send, GET /documents/{id} | Headless Gemini 2.5 SDK scripts & CI release gates |
3. Configuring Signbee MCP & Skills in Google Antigravity and Gemini CLI
Setting up Signbee inside Google Antigravity or Gemini CLI takes less than one minute. You can register the stdio MCP server in your global settings and optionally add the declarative signbee/skill so subagents know the exact payload invariants before invoking any tool:
{
"mcpServers": {
"signbee": {
"command": "npx",
"args": ["-y", "signbee-mcp"],
"env": {
"SIGNBEE_API_KEY": "signbee_live_your_api_key_here"
}
}
}
}Alongside the MCP server, install the official Signbee skill into your agent environment so both your primary orchestrator and spawned subagents have instant access to endpoint schemas and status-polling patterns:
# 1. Install the declarative Signbee skill globally for Antigravity / Gemini CLI / Claude Code
npx skills add signbee/skill --skill signbee -g
# 2. Or launch the stdio MCP server directly
SIGNBEE_API_KEY="signbee_live_..." npx -y signbee-mcp4. Production Pattern: Turning Repository Commits into Signed Client Change Orders
One of the highest-leverage workflows in Google Antigravity is automated scope-to-contract generation. When a client requests a new architectural module, an Antigravity subagent can inspect the proposed implementation plan, synthesize a formal Change Order agreement, and dispatch it via POST https://signb.ee/api/v1/send (or the send_document MCP tool) before merging to production.
Below is a complete TypeScript automation script compatible with @google/genai (Gemini 2.5 Pro) and Signbee's REST API. For more details on Gemini tool declarations, see our guide on Google Gemini 2.5 Function Calling + Signbee:
export interface ChangeOrderDispatchInput {
projectCode: string;
clientDirectorName: string;
clientDirectorEmail: string;
deliverableSummary: string[];
fixedFeeUsd: number;
targetReleaseDate: string;
}
export async function dispatchAntigravityChangeOrder(input: ChangeOrderDispatchInput) {
const deliverablesList = input.deliverableSummary
.map((item, idx) => `${idx + 1}. **Deliverable ${idx + 1}:** ${item}`)
.join("\n");
const markdownContract = `# Engineering Change Order & Production Release Authorization
**Project Reference:** ${input.projectCode}
**Effective Date:** ${new Date().toISOString().split("T")[0]}
**Client Counterparty:** ${input.clientDirectorName} (${input.clientDirectorEmail})
---
## 1. Authorized Engineering Deliverables
The Client hereby authorizes implementation and production deployment of the following engineering scope:
${deliverablesList}
## 2. Commercial Terms & Release Milestone
* **Agreed Fixed Engineering Fee:** $${input.fixedFeeUsd.toLocaleString()} USD
* **Scheduled Production Deployment:** ${input.targetReleaseDate}
* **Payment Schedule:** 50% upon Change Order execution; 50% upon production verification.
## 3. Acceptance & Cryptographic Execution
By executing this Change Order electronically, both parties agree that this instrument modifies the underlying Master Services Agreement and is sealed with an immutable SHA-256 audit certificate.`;
// 1. Dispatch via POST /api/v1/send (with Bearer API key, sender is pre-verified)
const sendRes = await fetch("https://signb.ee/api/v1/send", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.SIGNBEE_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
title: `Engineering Change Order — ${input.projectCode}`,
markdown: markdownContract,
recipient_name: input.clientDirectorName,
recipient_email: input.clientDirectorEmail,
expires_in_days: 7,
}),
});
if (!sendRes.ok) {
const errText = await sendRes.text();
throw new Error(`Signbee dispatch failed (${sendRes.status}): ${errText}`);
}
const dispatched = await sendRes.json();
// Returns: { document_id: "cmm...", status: "pending_recipient", sender: "...", recipient: "...", expires_at: "..." }
return dispatched;
}5. Webhook-Free Status Checks & Two-Pass SHA-256 Cryptographic Verification
Because Google Antigravity and Gemini CLI run inside developer workstations or isolated cloud sandboxes without public inbound webhooks, agents can verify signature completion on demand by calling GET https://signb.ee/api/v1/documents/{id}. Compare this approach with other IDE integrations in our Cursor .cursor/rules + Signbee MCP guide and Windsurf Cascade MCP workflow guide.
Once the client signs on mobile or desktop, Signbee executes its deterministic two-pass pdf-lib sealing pipeline: appending the A4 Signing Certificate with both parties' timestamps, IP addresses, and signature visuals, and computing the final SHA-256 digest over the sealed PDF byte stream:
# 1. Query document status from Antigravity or Gemini CLI
curl -s https://signb.ee/api/v1/documents/cmm_9f83a71b28d4e9 \
-H "Authorization: Bearer $SIGNBEE_API_KEY" | jq .
# Response when signed:
# {
# "document_id": "cmm_9f83a71b28d4e9",
# "status": "signed",
# "title": "Engineering Change Order — PRJ-2026-11",
# "signed_pdf_url": "https://signb.ee/storage/signed_cmm_9f83a71b28d4e9.pdf"
# }
# 2. Download the sealed PDF and compute its local SHA-256 hash
curl -sL "https://signb.ee/storage/signed_cmm_9f83a71b28d4e9.pdf" -o signed_change_order.pdf
shasum -a 256 signed_change_order.pdf6. Frequently Asked Questions: Google Antigravity & Gemini CLI E-Signatures
How do I connect Google Antigravity IDE and Gemini CLI to Signbee for automated e-signatures?
You can connect Google Antigravity IDE and Gemini CLI to Signbee in under 60 seconds using either the Model Context Protocol (npx -y signbee-mcp in your MCP settings JSON) or by installing the reusable agent skill (npx skills add signbee/skill --skill signbee -g). Once configured with your SIGNBEE_API_KEY, Gemini 2.5 Pro and Flash agents can invoke send_document (for Markdown agreements) or send_document_pdf (for existing PDF URLs) directly from your workspace.
Can multi-agent swarms in Google Antigravity dispatch contracts in parallel without race conditions?
Yes. Because Signbee's POST /api/v1/send endpoint and signbee-mcp server are stateless and atomic, parallel subagents spawned in Google Antigravity can generate and dispatch distinct statements of work, vendor NDAs, or release approvals simultaneously. Each invocation returns an isolated document_id and triggers a tamper-evident two-pass SHA-256 signing ceremony without envelope state collisions.
When should an Antigravity or Gemini CLI agent use send_document versus send_document_pdf?
Use send_document when the Gemini agent is drafting dynamic legal prose, clauses, or bulleted schedules in CommonMark Markdown directly from codebase context or CRM records. Use send_document_pdf (or pdf_base64 / pdf_url on POST /api/v1/send) when dispatching pre-rendered PDFs, branded client proposals, or complex multi-column tabular schedules.
Do Google Antigravity agents need a webhook server or ngrok tunnel to verify when a contract is signed?
No. Local IDE agents in Google Antigravity and terminal sessions in Gemini CLI operate behind NAT firewalls without public ingress ports. Instead of running ngrok or standing up a webhook server, the agent simply queries GET https://signb.ee/api/v1/documents/{id} with its Bearer API key to check whether status has transitioned to signed and retrieve the signed_pdf_url.
How does Signbee verify the cryptographic integrity of contracts sent by Gemini CLI agents?
Every document executed via Signbee undergoes a deterministic two-pass SHA-256 cryptographic seal using pdf-lib. Pass 1 binds Party A (the authenticated API caller) and Party B (the counterparty signer) along with IP telemetry, user-agent strings, and UTC ISO-8601 timestamps onto an appended Signing Certificate page. Pass 2 computes the SHA-256 digest of the final PDF byte stream and registers it permanently at https://signb.ee/verify/[id].
Equip Your Antigravity & Gemini Agents with Instant E-Signatures
Add npx -y signbee-mcp to your IDE in 60 seconds. Start free with 5 documents/month or upgrade for high-velocity autonomous agent workflows.