Agents run your agreements.You keep the final word.

Most document tools bolted a chat box onto a filing cabinet. PlutusDoc was built the other way around. Every action is governed, so Plutus runs it inside the app and your own agents run the same one over MCP.

Start freeConnect your own agent

Seven days of everything, with no card. Cancel by doing nothing.

actions in one shared registry
19actions in one shared registry
OAuth scopes, read only by default
10OAuth scopes, read only by default
actions that stop for your approval
7actions that stop for your approval

Teams running their agreements through PlutusDoc

Logo

Logo

Logo

Logo

Logo

Why this is different

Everyone added an assistant. Almost nobody gave it anything to do.

The signing part of this category has been solved for a decade. What has not been solved is letting software do the work around the document without quietly taking decisions out of your hands. That is the part PlutusDoc is built for.

A chatbot that can only talk

It answers questions about the document and then hands the work back to you. Every real step is still a form you fill in yourself.

In PlutusDoc

Plutus holds the same nineteen actions you do. It drafts, fills, checks readiness, sends, and reminds, as work rather than advice.

AI that stops at the app boundary

The assistant only exists on their tab. Anything you run elsewhere is back to copy, paste, and a browser window you left open.

In PlutusDoc

The workspace speaks MCP. Claude, ChatGPT, Copilot, or the agent you wrote yourself can drive it without anyone opening the app.

Automation you cannot audit

Something happened, a document went out, and the record of who decided it is a chat log nobody can produce six months later.

In PlutusDoc

Every action carries a scope, an approval gate where it matters, and an entry in the same audit trail your signatures land in.

Plutus, the agent inside

It acts, then it asks.

Plutus sees your documents, recipients, activity, contacts, teams, and calendar the way you do, and it can act on all of them. Ask in plain language and it assembles the whole thing, then holds at the point where judgement starts.

  • Drafts from a sentence, a template, or a file you hand it
  • Fills placeholders, adds recipients, and checks whether a document is actually ready to send
  • Reads the activity behind a quiet deal and tells you where it stopped moving
  • Creating, editing, and sending each wait for an explicit approval from you

Things people actually ask it

Draft a mutual NDA for Acme and put our standard confidentiality clause in it

Which contracts went out last month and never got opened

Is the Riverside lease ready to send, and what is missing if it is not

Remind everyone who has not signed the Q3 renewal

Bring your own agent

Your workspace already speaks MCP.

PlutusDoc runs its own Model Context Protocol server with a full OAuth 2.1 authorization server behind it. Point any MCP client at it and your documents become something that agent can work, from wherever it already runs. No plugin to publish, no key to paste into a config file you will forget about.

Works with the clients you already use

ClaudeChatGPTCopilotGeminiCursorYour own agent

OAuth 2.1, not a pasted API key

A client registers, you approve it on a consent screen, and the token it gets is bound to your account and revocable from settings.

Least privilege by default

A new connection is handed read scopes only. Write access is requested when an action actually needs it, and you decide then.

Same trail as everything else

An action run by an agent from the outside lands in the same audit record as one you ran with your own mouse.

Connect a clientMCP
{
  "mcpServers": {
    "plutusdoc": {
      "type": "http",
      "url": "https://app.plutusdoc.com/api/mcp"
    }
  }
}

The client discovers the authorization server on its own, sends you to a consent screen, and comes back holding a token scoped to exactly what you agreed to.

One action layer

Nineteen actions. Three ways in. No second implementation.

Plutus, your MCP clients, and your own code all reach the same registry. When an action gains an approval gate or a new scope, it gains it everywhere at once, because there is only one of it. That is the difference between a product built for agents and a product with an agent stapled to the side.

Plutus, in the app

The panel beside your document, holding the same tools and the same limits as everything else on this list.

Your agents, over MCP

Any MCP client, authorized through OAuth and scoped to the parts of the workspace you agreed to hand over.

Your systems, over REST

Scoped API keys, idempotent writes, and webhooks for the whole document lifecycle when you would rather write the code yourself.

What an agent can actually do here

See the full reference

Documents

  • List documents
  • Read a document
  • Create a draft
  • Send a document
  • Check send readiness
  • List placeholders

Reminders

  • Read reminder settings
  • Send a reminder

Analytics

  • Summarize activity
  • Explain a stalled document

Contacts and teams

  • Search contacts
  • List workspaces
  • Read team state

Calendar

  • Read availability
  • Manage scheduled meetings
  • Send a reschedule

Every one of them is documented with its parameters, its scope, its rate limit weight, and a worked example, in the developer console inside your account.

The human path

You can still do all of it yourself, and the app tells you where you are.

Nothing here depends on the agent. A checklist sits beside the page and reads the document itself rather than a saved setting, so it can never claim you are ready when you are not.

01

Start the document

Open a blank page, upload a PDF, pick one of forty templates, or just describe it and let Plutus write the first draft.

02

Fill in the details

Names, dates, and amounts are placeholders. Fill each one once, by hand or by agent, and it lands everywhere it appears.

03

Add signers and fields

Invite the people who need to sign, then drop a signature, initials, date, or amount field wherever it belongs on the page.

04

Send and track

Everyone gets their own link. From there the workspace watches the document and nudges anyone who goes quiet.

The editor

Put the signature exactly where it belongs.

Drag a field onto the page and hand it to a role. Signature, initials, name, job title, company, date, a number, an amount, a checkbox. Give yourself fields too and sign your side without leaving the page.

  • Fields stay put in the finished PDF, flattened into the page rather than floating above it
  • Placeholders pull from the recipient, so one draft serves every deal you send
  • Uploaded PDFs can be drawn on, rotated, and saved as a copy or over the original

Send and track

The activity an agent needs, and you wanted anyway.

Every recipient gets a private link of their own, and everything they do with it lands on one screen. That record is also what Plutus reads when you ask why a contract has gone quiet, which is why the answer is specific instead of a guess.

  • See who opened the document, how long they stayed, and what they downloaded
  • Reminders go out on the schedule you set, or on request, by you or by the agent
  • Void, resend, or hand a document to a different signer without starting again

Templates and clauses

Forty agreements nobody has to write.

Offer letters, mutual NDAs, service agreements, invoices, leases, and the rest, grouped by the kind of work they belong to. Your own wording lives in the clause library, and Plutus pulls from the same shelf you do when it drafts something new.

Human resourcesLegalSales and businessFinanceReal estateFreelance and creativePersonal
Browse the library

The rest of it

Everything else the work needs, in the same place.

No second tool for the address book, no third one for the reminder emails, and one less integration for your agent to learn.

Folders

Organize files the way you already think about them, and share a whole folder in one move.

Teams

Invite people by email, set their role, and keep personal work separate from the team side.

Contacts

Keep recipients on file so a name and an email are never typed twice, or import them from Google.

Saved signatures

Draw it, type it, or upload it once. Then reuse it on everything you sign.

Your branding

Your logo and your colors on the documents and emails your recipients actually see.

Email templates

Rewrite the invite, the reminder, and the confirmation so they sound like you.

Booking pages

Publish your availability and let a client pick a time. Plutus can move the meeting later.

Deleted files

Anything removed stays recoverable in the bin until you decide to clear it out.

Governance

Autonomy is only worth having if you can prove what it did.

Handing work to software is easy. Being able to answer, months later, who decided what and on whose authority is the hard part, and it is the part that decides whether any of this is usable at work.

Approval gates on the actions that matter

Seven of the nineteen actions cannot complete on their own. Creating, sending, and reminding all stop and put the decision in front of you.

Scopes on every token and every key

Ten scopes, granted one at a time. A connection starts with read access and asks for more only when an action genuinely needs it.

A timestamped trail on every document

Each view, download, signature, and agent action is recorded with the time, the IP address, and the device behind it.

One private link per recipient

Nobody shares an access route with anyone else, and any link can be pulled back the moment it should not work.

Signatures fixed into the page

The finished PDF is flattened, so what was signed is what stays signed. No layer left over for anyone to nudge afterwards.

Roles that mean something

Workspace permissions decide who can open, edit, and send, and they apply to an agent exactly as they apply to a person.

Developers

When you would rather write the code yourself.

The same actions are behind a plain REST API. Create documents, send them, and hear back when something happens, straight from the systems you already run. Keys are scoped, writes are idempotent, and embedded signing sessions let you put the signing experience inside your own product.

Scopes on every key

workspaces:readdocuments:readdocuments:writedocuments:sendwebhooks:readwebhooks:writesigning_sessions:write

Webhooks for the whole lifecycle

document.createddocument.sentdocument.vieweddocument.signeddocument.completeddocument.declineddocument.voided
Create a documentREST
POST /api/v1/documents
Authorization: Bearer pk_live_...
X-Plutus-Workspace-Id: <workspace id>
Idempotency-Key: <uuid>

{
  "title": "Acme service agreement",
  "variables": {
    "client_name": "Acme Inc.",
    "total": "12,000"
  }
}

Pricing

Pick a plan after you have used it, not before.

Priced on documents sent, not on who or what sent them. Plutus, your own agents, and the API all run against the same plan. Every new account gets seven days of Professional with no card asked for up front.

Free

$0forever

For the occasional agreement and for seeing how the workflow feels.

  • 10 sent documents a month
  • Unlimited drafts
  • Signing, reminders, and tracking
  • Plutus, MCP, and the API included
Create an account

Professional

Most teams pick this
$20per month

For the teams sending agreements most weeks of the year.

  • 249 sent documents a month
  • Unlimited drafts
  • Signing, reminders, and tracking
  • Plutus, MCP, and the API included
  • Team workspaces and shared folders
Start the 7 day trial

Enterprise

$100per month

For high volume document work that should never hit a ceiling.

  • Unlimited sent documents
  • Unlimited drafts
  • Signing, reminders, and tracking
  • Plutus, MCP, and the API included
  • Team workspaces and shared folders
Start the 7 day trial

Extra seats for teammates and additional Plutus credits are billed separately, only when you add them.

Questions

Things people ask before signing up.

If yours is not here, start the trial and find out. It costs nothing and takes about a minute.

The order it was built in. The nineteen actions came first, and the interfaces came after, so Plutus is not asking a separate service to do things on your behalf. It holds the same tools you do, under the same scopes and the same approval gates. That is also why your own agents can pick them up over MCP without us shipping anything new.

Give your agent something worth doing.

Sign up, ask Plutus for a draft, and connect your own client in the same sitting. The trial covers all of it, and there is nothing to cancel if you decide it is not for you.

Start freeSign in

Seven days of Professional, no card, no cancellation to remember