ESIGN & UETA Compliant

Let your agents kick off signing.
Atlas handles the rest.

With Atlas, your agent sends a contract doc or text and we handle everything: detecting signing fields, delivering links to signers, executing the workflow, and returning it to agent fully signed.

Get API Key Read the docs

Backed by

Full signing lifecycle

# 1. Agent sends contract

POST /api/envelope

"template_id": "tmpl_nda",

"signer_email": "alice@company.com",

"prefill": { "Client Name": "Acme" }

→ { "sign_url": "/sign/3f7a..." }

# 2. Signer opens link, draws signature

[2 minutes later]

# 3. Webhook fires to your endpoint

POST your-app.com/webhook

→ { "event": "envelope.signed",

"envelope_id": "3f7a..." }

# 4. Agent retrieves signed PDF

GET /api/envelope/3f7a.../pdf

→ 200 OK application/pdf

Why Atlas

The first signing infrastructure built for agents.

Every other signing tool was built for humans to operate manually. There was nothing agents could call. Atlas is the first signing infrastructure built to be called by code. Your agent sends a contract and the entire signing workflow runs on its own.

How it works

Three steps. That’s the whole workflow.

Your agent calls Atlas once. Atlas handles everything in between.

Step 1

Send any contract

Pass a saved template, upload a PDF or DOCX, or send raw text. Atlas detects signing fields automatically.

Saved PDF template
PDF or DOCX upload
Raw draft text

Step 2

Signer gets a link

Atlas emails the signer a unique signing link. They open it on any device, review the document, and draw their signature.

Email delivered automatically
Works on mobile and desktop
No account needed to sign

Step 3

Signed doc comes back

Webhook fires to your endpoint the moment signing completes. Retrieve the signed PDF programmatically.

Webhook with retry backoff
Programmatic PDF download
SHA-256 hash and audit trail

How agents use it

One call.
Everything handled.

Your agent sends a single JSON call with the contract and the signer's email. From there Atlas takes over: it detects fields, sends the signing link, waits for completion, and fires your webhook with the signed document. Your agent never has to manage any of it.

Signing fields detected automatically from any document
Signer email delivered with a unique link
Webhook fires the moment signing completes
Signed PDF available programmatically via GET
Agent prefill stamps values before the signer sees the doc

Agent sends one call

curl -X POST https://atlaswork.ai/api/envelope \
  -H "Authorization: Bearer $ATLAS_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "template_id":    "tmpl_nda",
    "signer_email":   "client@company.com",
    "agent_identity": "my-agent/v1",
    "prefill": {
      "Client Name":  "Acme Corp",
      "Deal Amount":  "$240,000"
    }
  }'

Atlas handles everything after this:

→ Fields detected on the PDF

→ Signing link emailed to client

→ Signer completes on any device

→ Webhook fires with signed PDF

The difference

Built for agents, not humans.

Every other signing tool assumes a human is operating it. Atlas assumes a machine is.

The old way

A human must operate it
Someone has to prepare the document, place fields, hit send, and monitor completion manually.
Days to integrate
DocuSign requires accounts, template configuration, webhook setup, and days of work before anything runs.
No concept of agents
No API design for agents. No record of which system sent what. No identity attestation.
Signed docs locked in UI
You download completed documents manually from a dashboard. No programmatic retrieval.
Legal compliance is your problem
You have to handle ESIGN Act, UETA, and audit trail requirements yourself.

With Atlas

Agents operate it
Your agent sends a contract and the entire workflow runs. No human needed in the loop to operate it.
One API key to start
One POST request sends a fully-configured envelope. Live in minutes, not days.
Built for agents natively
Every envelope records which agent sent it, HMAC-attested. Designed for automated pipelines from day one.
Signed docs returned programmatically
GET /api/envelope/:id/pdf returns the signed document to your agent the moment it completes.
ESIGN and UETA built in
Every envelope is legally binding with SHA-256 audit trail, IP capture, and time-on-document. No extra work.

Audit trail

Every envelope is a legal record.

When an agent executes a contract, there needs to be proof. Atlas captures everything automatically.

SHA-256 hash of the signed document
Which agent sent it, HMAC-attested
Signer IP, timestamp, and time spent on document
ESIGN Act and UETA compliant out of the box

Signed envelope

{
  "status":                  "signed",
  "agent_identity":          "contract-ai/v2",
  "agent_identity_attested": true,
  "document_hash":           "sha256:a3f8c2d19e...",
  "signed_at":               "2026-01-15T14:32:00Z",
  "signer_ip":               "203.0.113.45",
  "time_on_document_s":      47,
  "legally_binding":         true
}

Two ways to integrate