An AI agent that can read an agreement is a convenience. An agent that can send, void, or resend one is a delegate of your company. The Model Context Protocol (MCP) makes the second case easy to build, because it lets a compatible client discover and call tools without custom glue code for each one. That ease is the risk. A signature request goes to a real person, carries a real legal expectation, and cannot be quietly recalled once the recipient has seen it.
This article is for solution architects and platform engineers who are deciding how an agent should touch an eSignature account. It proposes a design, called Propose, Approve, Execute, that separates what an agent may prepare from what only an approved, hash-bound operation may commit. It is a proposed design for you to adapt. It is not a feature list of a shipped product, and it does not claim that any eSignature vendor already implements every control described here.
You will get:
- A tiered model of agent actions, from discovery to commit.
- A comparison of three wiring options with their failure modes.
- A ledger and state vocabulary that handles timeouts, retries, and uncertain input.
- A go/no-go checklist where every item is required.
- A rollout path that uses test credentials before live ones.
Key Takeaways
- Bottom line: let agents read and prepare freely, but make every commit (send, void, resend, delete) pass through an approval record bound to an immutable payload hash.
- Annotations are hints, not enforcement. The MCP specification says clients must treat tool annotations as untrusted unless they come from trusted servers. Your gateway has to enforce the rules.
- A timeout is not a failure. When a send call times out, the outcome is unknown. Reconcile against authoritative state before any retry, and tell the agent exactly that.
- Idempotency is tenant-scoped and payload-bound. Reuse of an operation identity with a changed payload must be rejected, and a legitimate later action needs its own identity.
- Privacy is owned by you. Recipient emails, document text, and signing links all flow through the model context. Minimize what the agent sees.
- Start with test credentials. eSignly's MCP guide describes test keys for reads, schema discovery, sample validation, and preflight without live side effects.
Why Agent-Initiated eSignature Actions Are a Different Risk Class
Key takeaway: an agent changes who decides to act, not what the action does. A signature request still reaches a real person, so the control has to live where the decision becomes a side effect.
Traditional integrations are deterministic. A developer writes code that calls an endpoint when a business event occurs, and a reviewer can read the trigger. An agent's trigger is a natural-language instruction interpreted by a model. The same sentence can resolve to different templates, different recipients, or a different action on a different day. The MCP tools specification describes tools as model-controlled: the model can discover and invoke them based on context. The same page says there should always be a human in the loop with the ability to deny tool invocations, and that applications should show tool inputs to the user before calling the server.
That guidance is sensible, but it leaves the hard part to you. Which calls need a human? What exactly does the human approve? What happens when the approved call times out? Those answers are architecture, not protocol.
The OWASP Top 10 for Large Language Model Applications names excessive agency as a risk category: a model given more functionality, permissions, or autonomy than the task needs. Signing workflows are a textbook case, because the worst action (send the wrong contract to the wrong person) sits one tool call away from the most common action (look up an agreement).
A tiered model of agent actions
Before choosing controls, classify every tool you plan to expose. The tiers below are a proposed taxonomy, not an MCP or vendor standard.
| Tier | Examples | Side effect | Default agent permission | Control needed |
|---|---|---|---|---|
| 0: Discover | List tools, read schemas | None | Allowed | Inventory of exposed tools |
| 1: Read | Find an agreement, read status | None, but data exposure | Allowed, scoped by role and tenant | Field minimization, logging |
| 2: Prepare | Validate a sample, run a preflight, draft a proposed request | None live | Allowed | Store the proposal as data, never as an action |
| 3: Commit | Send, void, resend, change recipients, delete | Real and hard to reverse | Denied until approved | Approval record, payload hash, ledger, reconciliation |
eSignly's MCP guide describes a similar split on the vendor side: test keys support reading, schema discovery, sample validation, and preflight behavior without live side effects, while live keys can support production actions when plan access, permissions, credits, and restrictions allow. That is a vendor statement about credential types. Your own gateway still decides which tier each tool belongs to and who may cross from tier 2 to tier 3.
How Most Teams Wire Agents to Signing, and Why It Fails
Key takeaway: the common first build connects the agent straight to a send tool and relies on the model's judgment plus tool annotations. Both are soft signals, and neither survives a retry storm or a hostile document.
The first prototype usually looks like this: expose a send_for_signature tool, write a careful system prompt, and test on a few friendly examples. It works. Then the pilot widens, and three assumptions quietly break.
- The prompt is treated as a control. Instructions such as "always confirm before sending" are requests to a model, not enforcement.
- Annotations are treated as guarantees. The MCP team's own post on tool annotations as a risk vocabulary states that annotations are hints, that an untrusted server can lie, and that they are not enforcement. A tool with no annotations is assumed to be non-read-only, potentially destructive, non-idempotent, and open-world.
- Retries are treated as free. An agent that sees an error or a timeout will often try again. For a read, that is harmless. For a send, it can create a second request to a real person.
Three wiring options compared
| Dimension | A: Direct commit by agent | B: Propose, Approve, Execute (proposed) | C: Application-driven REST, agent as interface only |
|---|---|---|---|
| Speed to first demo | Fastest | Moderate | Slowest |
| Build effort | Low | Medium: ledger, approval UI, reconciler | Medium to high: deterministic workflow code |
| Risk of wrong send | High, depends on model behavior | Low, bounded by approval and hash | Low, no model in the commit path |
| Duplicate send on retry | High unless handled ad hoc | Controlled by claim and reconcile | Controlled by your code |
| Auditability | Tool logs only | Proposal, approver, hash, outcome | Your application logs |
| Flexibility for open-ended requests | High | High for prepare, gated for commit | Low |
| Best fit | Throwaway prototypes with test credentials | Governed agent assistance with live consequences | High-volume, fixed workflows |
Option C is not a lesser choice. eSignly's guide frames the decision as choosing MCP when a compatible AI client or agent needs governed agreement operations, and considering the REST API for an application-driven integration. If your workflow is a fixed trigger such as "when the CRM stage becomes Closed Won, send the order form," a deterministic service built on the eSignly API is usually easier to reason about than an agent. Option B is for cases where the open-ended, conversational part has real value.
A Proposed Design: Propose, Approve, Execute
Key takeaway: the agent never holds the authority to commit. It writes a proposal. A human approves a specific hash. A separate worker executes that one approved operation exactly once, or reports honestly that it cannot confirm.
This is a proposed design. It is built from the MCP tool-safety guidance, general idempotency practice, and the failure patterns that integration teams commonly report. It is not a method eSignly claims to ship, and you should adapt it to your datastore, identity provider, and risk appetite.
The five components
- Gateway. A server you control sits between the agent and the eSignature account. It exposes only tier 0 to 2 tools to the model, plus one tool,
request_commit, that records a proposal. The model cannot reach a send endpoint directly. - Operation ledger. A durable table keyed by tenant and operation identity. It stores the action, the canonical payload hash, the status, the approver, and lease data.
- Approval surface. A screen or chat card that renders the structured payload from the ledger, never the model's own summary of it.
- Executor. A worker that atomically claims one approved operation and calls the signing service.
- Reconciler. A job that resolves operations in an unknown state by reading authoritative state before anything is retried.
What the payload hash covers
The hash must bind everything a human would consider material: the action, the template or document content hash, every recipient and role, signing order, field values that affect meaning, the message text, expiry, and the tenant. Canonicalize the JSON before hashing so equivalent payloads produce the same digest. RFC 8785, the JSON Canonicalization Scheme, defines one such method for JSON. It addresses serialization only. It does not tell you which fields are material. That judgment is yours, and an omitted field is an unapproved field.
Illustrative ledger schema and claim
The following SQL is illustrative. It shows the invariants, not a vendor API, and you would adapt types and syntax to your database.
-- Illustrative only: adapt to your datastore. CREATE TABLE agent_operations ( tenant_id text NOT NULL, operation_id text NOT NULL, action text NOT NULL, -- send | void | resend | ... payload_hash text NOT NULL, -- hash of canonical approved payload status text NOT NULL, -- see state table approved_by text, approval_expires timestamptz, lease_owner text, lease_expires timestamptz, supersedes text, -- links a legitimate later operation PRIMARY KEY (tenant_id, operation_id) ); -- Propose: create once; a repeat with a different hash is a conflict, not an update. INSERT INTO agent_operations (tenant_id, operation_id, action, payload_hash, status) VALUES ($1, $2, $3, $4, 'awaiting_approval') ON CONFLICT (tenant_id, operation_id) DO NOTHING; -- Then read the row: if payload_hash differs from $4, reject as conflict. -- Claim: one worker wins, and only for the exact approved hash. UPDATE agent_operations SET status = 'executing', lease_owner = $5, lease_expires = now() + interval '2 minutes' WHERE tenant_id = $1 AND operation_id = $2 AND payload_hash = $4 AND status = 'approved' AND approval_expires > now() RETURNING operation_id; -- Zero rows: not claimable. Never fall through to executing anyway.The claim is a conditional write inside your own ledger, so it is a real compare-and-swap for your own state. A read followed by a separate write would not be. Note the limit: this protects your ledger. It does not, by itself, make the downstream signing service deduplicate a repeated call. Confirm in the eSignly API guide and documentation whether a request can carry a client-supplied reference you can later search by. If it cannot, you are relying on serialization (one in-flight attempt per operation) plus reconciliation, and you should document that limitation openly.
Also write the approval and the executor's work item in one transaction, for example with an outbox row, so an approval cannot be recorded without work being scheduled, and work cannot be scheduled without an approval.
Why This Fails in the Real World
Key takeaway: capable teams still ship these failures because each control looks optional in isolation. The gaps are in process and system boundaries, not in people.
The scenarios below are illustrative composites of common integration failure shapes. They are not customer results.
Scenario 1: The retry that became a second request
An agent calls a send tool. The call times out at the gateway after the signing service has already accepted it. The tool returns a generic error. The model, trained to be helpful, tries again, and the recipient receives two requests with different links. Nobody was careless. The gateway reported failure when the truth was unknown, and nothing in the system could tell the two states apart.
Why intelligent teams miss it: the happy-path demo never times out, and "error" is the only vocabulary the tool schema offered.
Scenario 2: The approval that approved something else
A manager approves a card that says "Send renewal to Acme." Between approval and execution, the agent refines the proposal and swaps a template that has a different pricing exhibit. The ledger updated the existing row in place. The approver approved a sentence, not a payload.
Why intelligent teams miss it: approvals feel like a workflow step, so teams model them as a status flag rather than a signature over specific content.
Scenario 3: The document that gave instructions
The agent reads an incoming agreement to summarize it. Buried in a footnote is text that reads like an instruction to add a recipient. The model has no reliable way to separate the user's request from text it just read, and annotations cannot help, as the MCP post on annotations notes, since they are static metadata that do not make a model resist prompt injection. If the agent can commit directly, the injected instruction has a path to a side effect.
Why intelligent teams miss it: the read tool and the send tool were reviewed separately. The risk lives in the combination, which no single tool review surfaces.
Scenario 4: The shared key that ignored tenant boundaries
A multi-tenant platform keys its idempotency table on operation ID alone. Two customers' agents generate the same short ID. One customer's send is silently treated as a duplicate of the other's and is dropped, with a success message returned.
Why intelligent teams miss it: identifiers looked unique in testing with one tenant.
| Failure pattern | Root cause (system, not person) | Design control that addresses it |
|---|---|---|
| Duplicate send after timeout | No "unknown" state in the tool contract | Unknown state, reconcile-first retry |
| Approved content differs from executed content | Approval bound to intent, not payload | Immutable payload hash, claim requires hash match |
| Injected instruction triggers action | Read and commit tools share one model session | Commit only via approved ledger operation |
| Cross-tenant dedupe collision | Global operation identity | Composite key of tenant and operation |
The Details That Carry the Risk: Outcomes, Retries, Uncertain Input, and Privacy
Key takeaway: most of the safety in this design comes from a small, honest vocabulary of outcomes, returned to the agent in a form that discourages guessing.
A tool-result vocabulary the agent can act on
Give the model a closed set of statuses. Each one tells it what it may say to the user and what it must not do.
| Status | Meaning | Agent may say | Agent must not |
|---|---|---|---|
| awaiting_approval | Proposal recorded, nothing sent | "I prepared this and it needs approval." | Claim it was sent |
| approved_queued | Approval recorded, work scheduled | "Approved and queued." | Claim delivery |
| confirmed | Authoritative state shows the request exists | "Sent, reference X." | Retry |
| failed_terminal | Authoritative state shows it did not happen and cannot | Explain the reason; offer a new proposal | Reuse the same operation identity with changed content |
| unknown_reconciling | Completion could not be confirmed | "I could not confirm this yet; checking." | Say it failed or succeeded, or call the commit tool again |
| needs_clarification | Input was ambiguous or invalid | Ask the user one specific question | Choose a template or recipient by guess |
| rejected_conflict | Same operation identity, different payload hash | Report a conflict; start a new proposal | Overwrite the original |
An unknown result means completion could not be confirmed. It is neither success nor verified failure, and the vocabulary must keep those apart.
Acknowledgment: when may the gateway say "accepted"?
Return approved_queued only after the approval row and the outbox row have committed in one transaction. If the gateway answers before that, a crash loses an approved action silently. After execution, return confirmed only when you have read authoritative state, not merely when the HTTP call returned.
Retries and timeouts
- On timeout or a connection reset, move the operation from
executingtounknown_reconciling. Do not release it for re-execution. - The reconciler reads authoritative state from the signing service. Use a stored reference if the API supports one. Otherwise search by recipient, document or template, and creation window, and escalate to a human if matches are ambiguous.
- If a matching request exists, mark
confirmed. If the service gives a definitive rejection, markfailed_terminal. If neither can be established, keep the state and alert an operator. - An expired lease means the worker's fate is unknown. Treat it as unknown, never as permission to claim again.
For the underlying pattern, see the existing guide to reconcile-first recovery for timeouts and unknown outcomes and the developer guide to idempotency, retries, and webhook resilience.
Legitimate later operations
A void followed by a corrected resend is not a duplicate. It is a new operation with a new identity and a new approval, linked through supersedes to the original. The design for that sequence is covered in safely voiding, correcting, and re-sending eSignature requests. The rule is simple: same identity means same approved payload, and anything else gets a new identity.
Uncertain input
Use strict schemas. The MCP specification expects servers to validate all tool inputs, and it recommends additionalProperties: false for parameterless tools. Extend that discipline: use enums for action types, require explicit recipient objects rather than free text, and return needs_clarification when two templates match a description. A guess that happens to be right in testing is a defect waiting for production.
Privacy ownership
Everything the tool returns enters the model context. Treat these as sensitive: document text, recipient names and emails (identifiers can themselves be sensitive data), and signing links. eSignly's guide tells users not to send raw credentials, private signing links, or full provider payloads when seeking support, which is a sound rule for model context too. Practical controls:
- Return opaque IDs and status, not signing URLs, to the model.
- Mask emails in logs and show full values only on the approval surface.
- Decide, before launch, which team owns retention and erasure of proposals and transcripts. Your organization determines the privacy obligations that apply to its data, so involve counsel and your privacy lead.
- Log tool use for audit purposes, as the specification recommends, but keep the log free of raw credentials and payload bodies. Telemetry design is covered in privacy-safe observability for eSignature APIs.
Risks, Constraints, and a Go/No-Go Checklist
Key takeaway: this design reduces risk. It does not remove it. Use the checklist as an all-required gate, not as a score that certifies readiness.
Trade-offs to accept openly
- Friction. Human approval slows the conversational flow. That is the cost of a bounded commit, and you can reduce it by batching approvals, not by dropping them.
- Approval fatigue. If people approve everything reflexively, the gate is decorative. Keep the approval surface short, show what changed, and review approval patterns periodically.
- Serialization, not provider-side CAS. Unless the signing API offers target-side conditional mutation or a dedupe reference, your protection against duplicates is serialization plus reconciliation. Disclose that limitation to stakeholders.
- Hints are not enforcement. Even a trusted server's annotations only feed confirmation prompts. Network controls, scoped credentials, and the gateway do the enforcing.
- Extra moving parts. A ledger, a worker, and a reconciler need ownership, on-call coverage, and tests.
Legal and compliance boundaries
Agent assistance does not change what makes an electronic signature defensible: the signer's intent, consent, attribution, and a retained record. It also does not settle your internal authority rules, such as who may bind the company to which contract. Whether a regulated workflow permits agent preparation is a question for your counsel and compliance function. eSignly's MCP guide states that live actions remain subject to plan, permissions, credits, restrictions, and Legal Center gates, and that a connected client does not receive unrestricted access to agreements. That is helpful scoping from the vendor. It is not a substitute for your own policy. For identity assurance questions, see the overview of identity governance, and for regulated workflows see the regulated workflow page. AI-assisted outputs such as contract summaries still need human review, and the Contract Intelligence page describes eligibility and usage controls for that add-on.
Go/no-go checklist: every item is required
| # | Control | Evidence you should be able to show |
|---|---|---|
| 1 | The model can reach no tier 3 tool directly | Gateway tool list and credential scope review |
| 2 | Approvals bind to a canonical payload hash covering all material fields | Field list signed off by the workflow owner |
| 3 | Operation identity is unique per tenant, and a changed payload under the same identity is rejected | Test that returns rejected_conflict |
| 4 | Claim is a single conditional write, and expired leases move to unknown, not to re-execution | Concurrency test with parallel workers |
| 5 | Approval, outbox, and scheduling commit atomically, or recovery is explicitly defined | Crash test between steps |
| 6 | Timeouts produce unknown_reconciling, and no retry occurs before authoritative state is read | Fault injection run |
| 7 | Terminal failure and needs_clarification states exist and are tested | Tool-contract tests |
| 8 | Signing links and raw credentials never enter model context or logs | Log and transcript sampling |
| 9 | Privacy owner, retention rule, and erasure path are named | Written assignment |
| 10 | Counsel and compliance have reviewed agent-initiated sends for the document classes in scope | Recorded sign-off |
If any row is unanswered, the answer is no-go for live commits. Keep running tiers 0 to 2 with test credentials while you close the gap. A failure-injection approach for items 4 to 6 is described in the guide to integration testing with failure injection.
A Lower-Risk Rollout Path With eSignly MCP, and What to Re-Verify Over Time
Key takeaway: widen capability in stages, and keep the specification and your vendor's current documentation as the source of truth for what a connection can do.
Four rollout stages
- Discovery and read-only. Contact the eSignly team, as the MCP guide suggests, to confirm that your client and account support the workflow. Configure credentials and permissions, protect keys, and plan to rotate or revoke them. Use test keys for schema discovery and safe status reads.
- Prepare with preflight. Use sample validation and preflight behavior to exercise your proposal format and your approval surface. No live side effects occur at this stage, according to the vendor's description of test keys.
- Gated commits for one document class. Enable live credentials only inside the executor, never in the agent's reach. Start with a low-consequence document type and review each approval and each outcome.
- Expand with evidence. Add document classes only after the checklist rows hold under load, and after you have reviewed unknown-state rates and reconciliation outcomes from your own telemetry. Downstream triggers after completion should follow the pattern in completion handoff for backend teams, and embedded flows should never treat a return URL as proof of signing, as explained in embedded eSignature security.
Where the documents live
The vendor guide says MCP follows the same Agreement Workspace, Template Library, and add-on access rules as web and API access, and does not introduce a separate agreement storage or billing model. If you are weighing how agreements are organized, see the Agreement Workspace page. For assurance questions during vendor due diligence, review the security page and the compliance page. These pages describe eSignly's own statements about its certifications and controls. Request current reports and confirm scope for your own regulatory situation, because a vendor certification does not by itself make your agent workflow compliant.
What to re-verify as standards and products evolve
MCP is a living specification, and this article draws on the tools page of the 2026-07-28 revision. Revisit these items whenever you upgrade clients or servers:
- Whether the tool annotation guidance and trust language have changed.
- Whether your transport (local process or HTTP) changes how credentials and authorization are handled. Authorization requirements are transport-specific, so read the authorization section of the revision you target.
- Whether the signing service has added client references, conditional updates, or other features that let you replace serialization with target-side deduplication.
- Whether the actions available to your account, role, and plan have changed. The vendor says available actions depend on account, role, and configuration.
The approval-gate principle should outlast any revision: the party that decides should not be the party that is easiest to manipulate, and the system should know the difference between unknown and failed. If you want to test the pattern against your own workflow, you can review account plans and start with a free option, then discuss MCP setup and test credentials with the team.
Conclusion: Decisions to Make Before an Agent Touches a Live Signature
The choice is not whether agents will interact with agreements. It is where the authority to commit lives. Use these actions as decision guidance for your next design review.
- Classify every tool by tier. Expose tiers 0 to 2 to the model and keep tier 3 behind a gateway you control.
- Define the material payload and hash it. Have the workflow owner sign off on the field list, then bind approvals and claims to that hash.
- Add the unknown state to your tool contract. Train stakeholders that unknown means unconfirmed, and require reconciliation before any retry.
- Assign ownership. Name the privacy owner, the on-call owner for the reconciler, and the counsel contact for document classes in scope.
- Run the checklist with fault injection. Treat any unanswered row as no-go for live commits, and continue in test mode until it is closed.
About this guide
This article was prepared and reviewed by the eSignly Expert Team. eSignly is an online eSignature SaaS and API provider serving customers since 2014, and its public security and compliance pages list ISO 27001, SOC 2, HIPAA, GDPR, 21 CFR Part 11, and PCI DSS among its attestations and compliance programs. The design above is a proposal for architects to adapt. Product behavior described here follows eSignly's published MCP guide, and you should confirm current capabilities, limits, and certification scope directly with the team and in your account before relying on them.
Frequently Asked Questions
Should an AI agent be allowed to send documents for signature?
It depends on document consequence, your authority policy, and the controls around the agent. A defensible default is to let agents read and prepare, and to require a human approval bound to a specific payload hash before any send. Low-consequence document classes can move to lighter approval only after evidence from tested, observed operation, and counsel should review the classes in scope.
Should I use MCP or the REST API for eSignature workflows?
eSignly's guide suggests choosing MCP when a compatible AI client or agent needs governed agreement operations, and considering the REST API for an application-driven integration. If your trigger is a fixed business event and no conversation is needed, deterministic code on the API is often simpler to verify. Confirm needed actions and client support with the team first.
Are MCP tool annotations such as destructiveHint enough to keep sends safe?
No. The MCP specification says clients must treat annotations as untrusted unless they come from trusted servers, and the MCP team's own writing says they are hints, not enforcement. They can drive confirmation prompts, but your gateway, scoped credentials, and approval ledger must enforce the actual rules.
What should an agent do when a send call times out?
It should not retry. A timeout means completion could not be confirmed. The gateway should record the operation as unknown, reconcile against authoritative state, and then report confirmed or terminal failure. If neither can be established, an operator should resolve it.
- Never report an unknown outcome as a failure.
- Never release an expired lease for automatic re-execution.
Does an MCP connection bypass eSignly account permissions?
According to eSignly's MCP guide, no. MCP uses the same applicable plan, role, document permissions, usage controls, and Legal Center gates as other access paths, and a connected client does not receive unrestricted access to agreements. Available actions depend on your account, role, and configuration.
How do I defend against instructions hidden inside documents the agent reads?
Assume the model cannot reliably separate your instruction from text it just read. Keep the commit path out of the model's reach, render approvals from structured ledger data rather than the model's summary, bind approvals to a payload hash, and treat any session that read untrusted content as needing stricter review.
Who owns privacy for data that passes through an agent?
Your organization does. Recipient identifiers, document text, and signing links all enter the model context, so minimize what is returned, mask logs, and name an owner for retention and erasure. Involve your privacy lead and counsel, because obligations depend on your data, jurisdictions, and contracts.
Planning an agent-assisted signing workflow?
Keep the agent useful and keep commits accountable. Start in test mode, prove the approval gate, then go live with confidence.
Compare eSignly account plans, then talk to the team about MCP setup and test options.
Free TrialeSignature API integration
This article is most relevant for CTOs and developers who need to roll out a practical signing workflow. Use the related eSignly path to compare plans, API options, compliance fit, and implementation next steps.
Reviewed for electronic signature decision makers
This guide is reviewed for clarity, legal and operational relevance, service alignment, and practical conversion path before being connected to an eSignly plan or API workflow.
For regulated, high-volume, or customer-facing workflows, validate legal duties, plan assumptions, and integration requirements with your internal stakeholders before rollout.

