Why Every Agent Framework Needs a Signing Primitive

The agentic stack has a gap

Look at what an autonomous agent can do today. Take Hermes Agent from Nous Research — a persistent agent that lives on your server, remembers what it learns, builds its own skills, runs scheduled automations, and reaches you on Telegram, Discord, Slack, or WhatsApp. It has 40+ built-in tools, sandboxed execution, subagent delegation, and browser automation. It can do almost anything.

Almost.

It can draft a contract. It can research a prospect. It can write a proposal. But when it's time to get that contract signed — to turn a conversation into a legally binding agreement — it hits a wall. There's no signing primitive in the stack.

What a “primitive” means

In infrastructure, a primitive is a fundamental operation that other operations are built on top of. Compute is a primitive — you run code on it. Storage is a primitive — you persist data in it. Payments are a primitive — you transfer value with them.

Each primitive has a consistent interface: you call it, it does one thing, it returns a result. The agent doesn't need to understand the internals — it just needs to know the input and output.

Signing should be that simple. It isn't — yet. Most signing tools were built for humans clicking through web UIs, not for agents calling APIs.

The framework landscape

The major agent frameworks have converged on a similar architecture: an LLM core, a tool registry, a memory layer, and an orchestration pattern. Where they differ is in which primitives they include:

Every framework can sign documents — they just need to be wired up to a signing API. Hermes Agent is ahead here: its native MCP support means you can install the Signbee MCP server and the agent gets signing as a first-class tool immediately.

Wiring the Primitive: Production Code Across Major Frameworks

To demonstrate how easily any framework adopts this primitive, here are drop-in implementations for LangGraph, CrewAI, and AutoGen:

from langchain.tools import tool
from pydantic import BaseModel, Field
import httpx
import os

class SignbeeDispatchInput(BaseModel):
    title: str = Field(description="Title of the agreement")
    markdown_content: str = Field(description="Exact legal agreement body in Markdown")
    signer_name: str = Field(description="Full legal name of the signer")
    signer_email: str = Field(description="Email address of the counterparty")

@tool("send_legal_agreement", args_schema=SignbeeDispatchInput)
def send_legal_agreement(title: str, markdown_content: str, signer_name: str, signer_email: str) -> str:
    """Dispatches a legally binding contract to a counterparty and returns document ID and signing URL."""
    api_key = os.getenv("SIGNBEE_API_KEY")
    url = "https://signb.ee/api/v1/send"
    
    payload = {
        "title": title,
        "markdown": markdown_content,
        "sender_name": "Autonomous Operations Corp",
        "sender_email": "ops@autocorp.io",
        "recipient_name": signer_name,
        "recipient_email": signer_email,
        "webhook_url": "https://api.autocorp.io/webhooks/signbee"
    }
    
    with httpx.Client(timeout=15.0) as client:
        response = client.post(url, json=payload, headers={"Authorization": f"Bearer {api_key}"})
        response.raise_for_status()
        data = response.json()
        return f"Document dispatched! Document ID: {data['document_id']}. Ceremony URL: {data.get('signing_url')}"

from crewai.tools import BaseTool
import requests
import os

class SignbeeContractTool(BaseTool):
    name: str = "Signbee Contract Dispatcher"
    description: str = "Generates and sends certified e-signature packets. Input should be a markdown contract string and counterparty email."

    def _run(self, markdown: str, counterparty_email: str, counterparty_name: str) -> str:
        headers = {
            "Authorization": f"Bearer {os.environ.get('SIGNBEE_API_KEY')}",
            "Content-Type": "application/json"
        }
        payload = {
            "markdown": markdown,
            "sender_name": "Autonomous Deal Closer",
            "sender_email": "deals@ventureai.com",
            "recipient_name": counterparty_name,
            "recipient_email": counterparty_email
        }
        r = requests.post("https://signb.ee/api/v1/send", json=payload, headers=headers)
        if r.status_code == 200:
            res = r.json()
            return f"Agreement live: doc_id={res['document_id']}, expires={res['expires_at']}"
        return f"Dispatch failed with status {r.status_code}: {r.text}"

The Legal Enforceability of Agent-Initiated Contracts

When an AI agent initiates a contract, does that agreement stand up in court? Under Anglo-American and European contract law, the answer is unequivocally yes:

• UETA § 14 (Uniform Electronic Transactions Act): Explicitly states that a contract may be formed by the interaction of electronic agents of the parties, even if no individual was aware of or reviewed the electronic agents' actions.
• ESIGN Act (15 U.S.C. § 7001): A contract or signature may not be denied legal effect, validity, or enforceability solely because it was generated or signed in electronic form.
• eIDAS Regulation (EU No 910/2014): Standard electronic signatures (SES) created via email-verified ceremonies and immutable cryptographic hashes satisfy the legal requirements for commercial business contracts across all 27 EU member states.

Because Signbee anchors every ceremony with UTC timestamps, IP logs, and an immutable SHA-256 cryptographic digest, the resulting PDF certificate qualifies as a self-authenticating record under Federal Rules of Evidence Rule 902.

Why Hermes Agent is the ideal host

Hermes Agent (23k+ stars, MIT license) is built differently from most agent frameworks. It's not a library you import into your code — it's a persistent agent that lives on your server and gets more capable over time. Three features make it the natural home for a signing primitive:

1. Persistent memory. Hermes remembers past interactions. When it signs an NDA with a client, it remembers that relationship. Next time you mention that client, it already knows the context — what was signed, when, and what the terms were.

2. Auto-generated skills. The first time Hermes sends a document through Signbee, it can create a reusable skill from the interaction. The next time it needs to send a contract, it has a proven pattern to follow — right document structure, right API call, right follow-up message.

3. Multi-platform gateway. Hermes runs on Telegram, Discord, Slack, WhatsApp, and CLI from a single gateway. You can tell it to “send the NDA to Bob” from your phone on Telegram at 11pm. It drafts the document, sends it through Signbee, and messages you back when Bob signs. You never open a laptop.

What signing enables

Without signing, agents can do everything except the step that generates revenue or creates legal obligation. With signing as a primitive, entirely new workflows become possible:

• Autonomous deal closing — Agent discovers lead, sends outreach, books meeting, drafts proposal, sends contract, closes deal. End-to-end.
• Self-executing agreements — When an agent negotiates terms on your behalf, it can formalise those terms in a signed document without waiting for human intervention.
• Compliance automation — Agent detects that a contractor's NDA is expiring, drafts a renewal, and sends it for re-signing. No human tracking required.
• Marketplace transactions — In agent-to-agent commerce, signing becomes the trust layer. Agent A hires Agent B? They sign a service agreement. Automatically.

The implementation is trivial

This is the important part. Adding signing to any agent framework takes minutes, not days. For Hermes Agent with MCP:

# In your Hermes MCP configuration:
{
  "signbee": {
    "command": "npx",
    "args": ["-y", "signbee-mcp"],
    "env": {
      "SIGNBEE_API_KEY": "sb_live_..."
    }
  }
}

Now tell Hermes: “Send a mutual NDA to alice@startup.com.” Done.

For LangChain, CrewAI, or any Python-based framework, it's a single function wrapper around the Signbee REST API. For n8n, it's an HTTP Request node. The signing primitive slots into any architecture because it's just an API call — markdown in, signed PDF out.

The bigger picture

We're at the beginning of a wave where agents need to interact with the legal and financial systems that govern human business. Payments were the first primitive to get solved — Stripe made it an API call. Signing is next.

Every agent framework will need a signing primitive. The question isn't whether — it's when. And the frameworks that adopt it earliest will be the ones that can support the most valuable autonomous workflows.