The situation
A legal operations lead spends part of every day answering the same question in different words. Which envelopes are still waiting on a counterparty. Which template the sales team used for a particular order form. Whether the signed copy of the MSA is final and where it sits.
Those are lookups, and an assistant handles lookups well. The worry is never the lookup. It is that the same connection that reads envelope status can also create an envelope, change its recipients, swap a document or delete one. Nobody wants a chat window one phrasing away from sending something out for signature.
This playbook sets up DocuSign in Claude so the lookups work and the change tools do not. Each person connects their own DocuSign account. A block rule on the legal operations role blocks every DocuSign tool that makes changes, while reading stays on.
What does DocuSign in Claude actually let the team do?
It lets a person ask Claude about envelopes, templates and signed documents in their own DocuSign account. Once the block rule is in place, it lets them do nothing more.
Elaichi authors and runs the DocuSign connector itself. The connector carries 70 tools and signs in with OAuth. The reads a legal operations team actually uses are a small set of them:
list_all_docusign_envelopesandget_single_docusign_envelope_by_id, for what is out and what one envelope holds.list_all_docusign_envelopes_status, for where each envelope stands.list_all_docusign_search_envelopes, for finding one by its details rather than its id.list_all_docusign_templates, for which templates exist.list_all_docusign_envelope_documentsanddocusign_envelope_documents_download, for the documents attached to an envelope.
That covers the questions that fill a legal operations inbox. "Which agreements are still unsigned after two weeks." "What template did this one come from." "Pull the executed copy."
The change tools sit on the other side of that line. Docusign's own Create envelope API reference documents the call that creates an envelope and can send it for signature in one request (checked November 2026). That is the call this playbook keeps out of reach.
What a connection can reach in Docusign is bounded by the Docusign account behind it. Docusign's authentication documentation describes how an application obtains an access token on a user's behalf (checked November 2026). Elaichi does not widen that. A person's own Docusign permissions still apply to every call made on their connection.
How each person connects their own DocuSign account
Each member creates their own DocuSign connection in Elaichi and signs in with their own DocuSign account. Every call through that connection then runs on their sign-in.
In Elaichi, a connection is one row the organization reuses. A connection with no sharing grants is private to the person who made it. That is what you want here: the legal operations lead's connection runs as them in DocuSign, and the paralegal's connection runs as them.
The reason matters. Every call through a connection fetches credentials from that connection's bound account, whoever is calling. So a connection shared at the use level runs every caller's call as its single owner. For DocuSign, the account decides which envelopes a person sees, so per-person connections keep that straight. The same pattern holds in Salesforce, where each rep connects their own account.
Each person's steps, once:
- In Connections, choose Add connection and pick the DocuSign connector.
- Leave the share setting as private, so only they can use it.
- Complete DocuSign's own OAuth sign-in in the window that opens.
- Connect their AI client to Elaichi's MCP endpoint, https://api.elaichi.ai/mcp, and approve the consent screen.
MCP is the protocol Claude, ChatGPT, Cursor and other AI clients use to reach tools. The MCP specification on tools describes how a server lists its tools and how a client calls one (checked November 2026). Elaichi serves MCP at one address for every organization. Which organization, person and tools a client reaches comes from the OAuth grant behind its token, not from the URL.
Claude is one of the clients Elaichi's authorization server is written for, alongside ChatGPT and Cursor, while Microsoft Copilot signs in through a Copilot Studio agent. If your team uses a client Elaichi does not name, what Elaichi requires is dynamic client registration, PKCE with S256 and a browser sign-in. Test it before you plan a rollout around it.
Writing the restriction that blocks envelope changes
A block rule on the legal operations role blocks every DocuSign tool that makes changes, and a block always beats an allow.
In Elaichi, restriction targets are role or user only; the organization default is the absence of a rule, which means allow everything. So if legal operations is a custom role, write the rule on that role. If the people involved hold Member, write it on Member, or on each member individually.
In the restriction form, add DocuSign to the block list, choose Specific tools, and pick the Block all changes preset. Reading stays on, and every tool that makes changes is blocked. That is the preset to use here, because a hand-picked list of names will always lag what the connector carries.
Among the tools the preset covers are the ones a legal operations team would notice first:
create_a_docusign_envelopeupdate_a_docusign_envelope_by_idcreate_a_docusign_envelope_sender_viewupdate_a_docusign_envelope_document_by_iddelete_a_docusign_envelope_document_by_iddelete_a_docusign_recipient_by_idcreate_a_docusign_envelope_tabcreate_a_docusign_userdelete_a_docusign_user_by_id
The last two are not about contracts at all. They create and delete DocuSign users. A legal operations role has no reason to hold them. An account administration tool reached from a chat window is the kind of thing that turns up in a security review.
The form offers two other presets beside it. Block deleting covers deleting only. Block everything covers reading too, which is more than this playbook wants.
One trap to avoid. An allow rule turns on the allowlist for its layer just by existing, whatever it names. An allow rule that names nothing therefore blocks every connector and tool for its target. If you reach for an allow rule instead, the role also needs allow rules for every other app it uses, because a layer's allow rules merge into one allowlist. A block list avoids that problem for a single-app change like this one. For the wider comparison, see when an allowlist is the right shape.
When does the restriction take effect?
A role or restriction change takes effect within about two minutes. Plan the change with that in mind rather than testing it the second after you save.
Elaichi caches a member's roles, teams, permissions and resolved restrictions. Every restriction change writes a new epoch that invalidates the cache. The worst case across a remote point of presence is roughly two minutes, and that is a worst case rather than a typical delay.
Two other timings behave differently. In Elaichi, revoking a share or disconnecting an account takes effect on the caller's next call. Removing or suspending a member revokes their MCP grants, so their clients fail on the next request too.
What happens when Claude tries a blocked tool
The call is refused in-band. The refusal tells the person whether the block comes from their role or from their own account, and that an admin can lift it through an access request.
The refusal does not name the rule, who wrote it, why, or what else it covers. That is deliberate. The person finds out they cannot do the thing, not the shape of your whole policy.
Restricted tools are not invisible. A restricted tool is left out of the tools Elaichi offers a client and cannot be called. Search still names it, flagged restricted, with no schema. So a paralegal searching for "send envelope" sees that something exists and that it is not theirs to call, rather than being told the tool never existed.
That visibility is a feature in a legal operations team. Somebody who needs the ability occasionally can file an access request from the client, and an admin decides it in the console under Governance. Only a person can approve or deny one. No AI client and no Elaichi Agent can decide a request, including a denial.
What the audit log records afterwards
Every DocuSign call that reaches execution is written to the audit log, with the person, the tool, the connection it ran on and which AI client made it.
Each connected-tool row records the acting person, the toolbox the call went through, and the tool's advertised and catalog names. It also records the connector, the connection the call reached, the tool's classification, how approval was given, the surface, the MCP client's id when the surface is MCP, and the outcome. A call refused by a restriction writes no row, because the refusal happens before any executor runs.
In the console, a connected-tool entry reads as one sentence. Something on the lines of "Using Claude, a named person viewed envelopes in DocuSign through the connection 'DocuSign (their name)'." Reads carry an Approval line that says they did not need approval because they only read data.
Everyone can read the audit log for their own activity. With the audit permission, which Org Owner, Org Admin and Auditor hold, they read every event in the organization. Elaichi keeps 90 days of audit history. If legal or compliance needs a longer record, forward it to your own log service: logging destinations come with the Black plan, and Datadog is the destination that delivers. Audit log retention at 90 days versus seven years goes through that choice.
What this setup does not do
The restriction governs what Claude can call through Elaichi. It does not govern what a person does in DocuSign's own web app, where their account's permissions are the only limit.
It also does not make the assistant trustworthy with untrusted text. Elaichi's MCP endpoint has no prompt-injection defense of its own; that defense belongs to the client. A contract body a counterparty wrote is untrusted text, and a model reading it can be steered. The defense here is that the change tools are not reachable at all, not that the model will decline to use them.
And there is the case where you do not need any of this. If one person handles DocuSign, has their own account, and nobody else needs the assistant anywhere near it, a per-person connection with no restriction is already the whole answer. Restrictions earn their keep when several people hold the same role and you want one rule instead of a conversation with each of them.
Where to go next
If the question behind this is broader than DocuSign, read-only access to company apps covers the general shape. For the mechanics underneath the rule you just wrote, how restriction enforcement works end to end follows one call through the gates. A service desk team holding Jira to reads solves the same problem in a different app.
For another legal-side rollout with the signing step held back, Ironclad contracts in ChatGPT takes the same approach in a different app. The full connector catalog lists what else your team can connect under the same rules.