Formify

View saved version →

---
name: formify-pdf-forms
description: 'Build fillable PDF forms and contract templates with signature fields. Use when creating a form or template, adding fillable fields to an existing PDF, replacing static text with fields, or preparing a document for e-signing. Triggers on "PDF form", "fillable PDF", "add fields to a PDF", "contract template", "skapa PDF-formulär", "PDF-mall", "fyllbart PDF", "formulario PDF". Not for sending a finished document: see formify-send-contract.'
license: MIT
metadata:
  version: "1.6.1"
---

# Build a PDF form

Version 1.6.1. If asked which version you are, quote this line.

## Purpose

Produce a PDF that a person can fill in and sign: clean layout, real AcroForm fields, and —
where the user wants Formify's identity features — the `tink-*` attributes that make a field
scan an ID, verify a company, or collect a one-time code.

This works with or without a Formify account. A form built here is a finished, useful
document on its own. Sending it for signature is a separate step and a separate skill.

## When this applies

- Creating a form, contract template or application from scratch.
- Adding fillable fields to a PDF the user already has.
- Replacing static text — a name, an address, a single blank line — with a real field.
- Preparing a document so it can later be signed.

## When it does not

- **Sending a finished document for signature** → `formify-send-contract`.
- **Choosing how a signer proves who they are** → `formify-verify-identity`, which owns
  BankID, ID scan, face liveness and company verification. Come back here for the fields
  those features need.
- **Chasing an already-sent document** → `formify-track-signatures`.
- **Publishing the finished form as one link anyone can sign** → `formify-share-link`. Build
  the PDF here first; that skill turns it into a link.

## Preconditions

Nothing is required. No account, no network, no local tools.

Two things change the route and are worth establishing early:

1. **Is there an existing PDF, or are we starting from nothing?** Editing an existing
   document must not redesign it.
2. **What document-production capability is available here?** Do not assume; find out, and
   follow the chain in step 5.

## Procedure

### 1. Say what this can do, then offer a starting point

The user does not know what is possible. Before asking anything, state it plainly — two or
three sentences, in their language — and offer concrete openings:

> I can build you a fillable PDF: text fields, checkboxes, dropdowns and signature space.
> If you want, fields can also scan an ID document, verify a company registration number,
> or ask for a one-time code before signing.
>
> Shall we start from a document you already have, or build one from scratch?

### 1b. Ask once, in one message — or not at all

How much to ask is decided by how specific the request was, and there are only two answers.

**The request is already specific** — *"mutual NDA, English, Swedish law, two signers"*. Ask
nothing. Draft it. A confident draft the user corrects beats an interview they have to sit
through.

**The request is generic** — *"make an NDA"*, *"I need a contract"*. Reply with **one message
carrying at most four questions**, answered once, and then draft. Never spread the same
questions over several turns: each round trip is a chance for the user to give up, and four
questions asked one at a time is four chances.

**Four is a ceiling, not a target.** The number is not taste. A set of up to four questions,
each a pick from a small list, is a shape the surface can render as something to click; a
fifth question tips the whole set back into prose the user has to read and answer by typing.
Three well-chosen questions beat five exhaustive ones, and a sixth is a form — nobody fills in
a form to get a form.

**Ask for a choice, not for data.** Each question is a pick from **two to four named options**,
with the usual answer marked as such: *held by the seller* or *by the agency*; *30 / 6

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 7 — file references are metadata, not package contents.

View saved version →

---
name: formify-send-contract
description: 'Send a contract or document for e-signature through Formify. Use when sending something to be signed, from a saved template, an uploaded PDF, or a document drafted in this conversation. Triggers on "send for signature", "send this contract", "e-sign", "signing request", "skicka för signering", "skicka kontrakt", "enviar para firmar". Not for a reusable link anyone can sign (formify-share-link) or checking who signed (formify-track-signatures).'
license: MIT
metadata:
  version: "1.6.1"
---

# Send a document for signature

Version 1.6.1. If asked which version you are, quote this line.

## Purpose

Take a document — a saved Formify template, a PDF the user has, or one drafted here — place
the signature fields, let the user check the result, and send it to the people who must sign.

## When this applies

- Sending anything for signature, from any of those three starting points.
- Collecting signers, choosing how the invitation reaches them, choosing how they sign.
- Previewing where a signature will land before anyone is contacted.

## When it does not

- **Building or editing the PDF itself** → `formify-pdf-forms`.
- **Choosing an identity check** → `formify-verify-identity` decides *what* verification is
  needed; this skill configures it on the signer.
- **Anything after the send** → `formify-track-signatures`.
- **One reusable link that anyone may open and sign** → `formify-share-link`. This skill
  invites named people to one document. That one publishes a link with no recipients, and
  produces a separate document per signer. If the user cannot name who will sign, they want
  the other skill.

## Preconditions

A connected Formify account.

**Call `get_account_capabilities` first, every time.** It decides which delivery channels and
which signing methods you may offer. Offering a feature the account does not have wastes the
user's time and is the fastest way to lose their trust.

## Procedure

### 1. Announce what is possible, then take one starting point

Before asking anything:

> I can send a document for signature. We can use one of your saved templates, a PDF you
> upload, or I can draft one here first. Signers can sign by hand, or with BankID, an ID
> scan or a face check if your plan includes them. I can also send an AI assistant along
> inside the document, so the recipient can ask it questions instead of asking you.
>
> Which would you like to start from?

One question at a time from here on. Never present a form of six questions.

### 2. Get the document in place

**From a template.** List templates and let the user pick by name — never show IDs. Read the
template and its fields. A template carries its own signer count and its own pre-configured
signature settings; **do not override them unless the user explicitly asks.** If the user
wants a different number of signers than the template defines, it is possible, but warn that
signature placement may be wrong.

**From a PDF.** The file must not be password-protected, and must not already carry a
digital signature from another service. Check before uploading; neither can be removed here.

Four upload routes, **exactly one per upload** — a host file reference, a URL, a staged
upload id, or the bytes. Try them in this order and say which one you used:

1. **A file reference the host supplied**, when the user attached the file and this
   environment passes attachments through to tools. Pass it exactly as given; the server
   fetches the bytes itself. Never build one by hand and never put a local path in it.
   If the user did attach a file but no reference arrived, retry the call once before
   falling to another route — the reference sometimes lands on the second attempt.
2. **A public HTTPS URL** — works in every environment. Prefer it whenever a URL exists.
3. **A staged upload**, when shell commands are available: request the upload URL, run 

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.

View saved version →

---
name: formify-share-link
description: 'Publish one reusable signing link anyone can open and sign, with no named recipients. Use when a form, waiver or consent goes to people whose names are unknown, when a link belongs on a website or a QR code, or when reading what a link has collected. Triggers on "public link", "signing link", "link anyone can sign", "share a form", "put it on our website", "signeringslänk", "delningslänk", "enlace público", "enlace para firmar". Not for inviting named signers: see formify-send-contract.'
license: MIT
metadata:
  version: "1.6.1"
---

# Publish a document as one signing link

Version 1.6.1. If asked which version you are, quote this line.

## Purpose

Turn a PDF into a single link that anyone holding it can open, fill in and sign. There are no
recipients and no invitations: the user shares the link themselves, and every person who signs
produces their own separate document.

This is the shape a form takes when the sender does not know who will fill it in — an intake
form on a website, a waiver at a reception desk, a consent behind a QR code, an application
posted in a group chat.

## When this applies

- "I want one link I can put on our website."
- "Send me something I can print as a QR code."
- "Everyone who joins needs to sign this, but I don't know who they are yet."
- "How many people have filled in my form?"
- "Turn that link off."

## When it does not

- **Inviting people you can name** → `formify-send-contract`. One document, its signers
  invited by email, SMS or WhatsApp. If the user can list who signs, they want that skill.
- **One person's private way into a document already sent** → `formify-track-signatures`.
  That link is locked to one person by a one-time code. This one is public by definition.
- **Building or editing the PDF** → `formify-pdf-forms`. Build it there, publish it here.
- **Deciding which identity check is needed** → `formify-verify-identity`. This skill places
  whatever that one chose.

## Preconditions

A connected Formify account, and a PDF already uploaded.

**Call `get_account_capabilities` first, every time.** Three keys decide what is possible:
`publicLinks` to see links at all, `publicLinksCreate` to make one, `accessLevels` for
sharing a link with colleagues. `aiAssistant` and the signature-method keys are checked the
same way as anywhere else. Offering a feature the account does not have is the fastest way to
lose the user's trust.

**A live link is billed, and creating one is not reversible in the way users expect.** On the
credits pricing model every live link is a billed instance, charged pro rata for the rest of
the current period and renewed each period for as long as it stays active.

**The signatures it collects are charged separately, as they happen.** The link is a standing
cost; each person who signs through it is another. Users assume a link is paid for once, and
a busy link can cost far more than the link itself — say both parts whenever cost comes up.
Read the cost section below before creating anything.

## Procedure

### 1. Announce what this is, and check it is what they want

Before asking anything:

> I can publish this as one link that anyone can open and sign. You share the link yourself —
> nobody gets invited — and each person who signs ends up with their own signed copy that you
> can read back. It works on a website, in a QR code or pasted into a chat. Signers can sign
> by hand, or with BankID, an ID scan or a face check if your plan includes them.
>
> Shall I set one up?

Then confirm the shape, because the two products look alike from the outside and cost
differently:

| The user says | What they mean |
|---|---|
| "Send it to Maria and Johan" | Named signers — `formify-send-contract`, not this |
| "Put it on our booking page" | One public link — this skill |
| "Everyone in the club has to sign it" | A link, unless the club roster is short a

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.

View saved version →

---
name: formify-track-signatures
description: 'Track who has signed, remind them, get notified automatically when they do, fix a wrong recipient, or cancel a send. Use after a document went out for signature, when contact details were wrong, or when the signed copy is needed. Triggers on "who has signed", "send a reminder", "notify me when signed", "wrong email address", "cancel the signing", "download the signed copy", "vem har signerat", "påminnelse", "återkalla", "quién ha firmado". Not for sending: see formify-send-contract.'
license: MIT
metadata:
  version: "1.6.1"
---

# After the document was sent

Version 1.6.1. If asked which version you are, quote this line.

## Purpose

Everything that happens between sending a document and having it signed: finding it,
seeing who is still outstanding, reminding only them, repairing a wrong email address,
handing someone a link in person, correcting a value before anyone signs, cancelling, and
retrieving the finished file.

This is the half of the job most agents never learn. Sending is one moment; waiting is the
following week.

## When this applies

- "Has anyone signed this yet?"
- "Remind the ones who haven't."
- "I typed his email wrong."
- "The client is in front of me — can I just give them the link?"
- "The amount is wrong and nobody has signed yet."
- "The deal is off, cancel it."
- "Send me the signed copy."
- "Just tell me when it's signed — I don't want to keep checking."
- "Has anyone filled in the form I shared?"

## When it does not

- **Sending a document in the first place** → `formify-send-contract`.
- **Building or editing the PDF** → `formify-pdf-forms`.
- **Managing the public link itself** — editing it, switching it off, what it costs →
  `formify-share-link`. Reading the documents it produced belongs here.

## Preconditions

A Formify account, connected. Every action here needs one.

**Always read current state before acting.** Call `get_document` before any reminder,
repair, cancellation or deletion. Never act on a status remembered from earlier in the
conversation — someone may have signed in the meantime, and several of these operations are
irreversible.

If the user does not know which document they mean, list recent documents and let them pick
by name. Never show internal IDs; those are for tool calls.

**Every list is paginated, and a short page does not mean the last page.** A listing returns
a `nextOffset`; keep asking with it until it comes back null. A page may hold fewer items than
the limit and still have more behind it — that is normal, not the end. Stopping at the first
short page is how "you have three documents out for signature" gets said to someone who has
eleven, and nothing about the answer looks wrong.

## Procedure

### 1. Read the document and report it in human terms

`get_document` returns the document's status and one entry per signer. Present it the way a
person would ask for it:

> **Rental agreement — Calle Mayor 14**
> Maria Sanchez — signed, yesterday 14:20
> Johan Berg — not yet signed
> Anna Lindqvist — not yet signed

Two different fields, and confusing them is the most common error here: the **document**
has a `status`; each signer has a `signatureStatus`. Read the second one per person.

Document statuses and what they permit:

| Status | Meaning | What is possible |
|---|---|---|
| `processing` | Still being prepared; invitations go out automatically when it finishes | Wait |
| `created` | Prepared, invitations not yet sent | No reminders yet |
| `awaiting_signatures` | Out with at least one person | Remind, repair, cancel |
| `completed` | Everyone signed | Download, delete |
| `revoked` | Cancelled | Delete |

**A document signed through a public link will not be in that list.** The ordinary document
listing holds what the user *sent* to named people. A public link — one reusable link anyone
may open — produces its own document per signer, and those live under the link, not in that
list. So when the user asks "has anyo

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 1 — file references are metadata, not package contents.

View saved version →

---
name: formify-verify-identity
description: 'Verify a signer with BankID, ID scan, face liveness or company lookup. Use when a signature needs proof of who signed, for KYC or anti-money-laundering, when scanning an ID document, or when verifying a company registration number. Triggers on "BankID", "ID scan", "verify identity", "KYC", "AML", "face liveness", "legitimering", "identitetskontroll", "verificar identidad". Not for ordinary signing without identity checks: see formify-send-contract.'
license: MIT
metadata:
  version: "1.6.5"
---

# Verify who is signing

Version 1.6.5. If asked which version you are, quote this line.

## Purpose

Bind a signature to a verified person or company. Formify can check an identity document,
match a live face against it, authenticate through Swedish BankID, look up a company
registration number, or require a one-time code before a document opens — and attach the
result to the signature rather than leaving it as a separate errand.

## When this applies

- A signature needs proof of **who** signed, not just that someone did.
- KYC or anti-money-laundering obligations apply.
- A company must be verified, or its board member or beneficial owner identified.
- An ID document must be scanned, or its data captured without storing the picture.

## When it does not

- **Ordinary signing with no identity requirement** → `formify-send-contract`.
- **Building the PDF fields themselves** → `formify-pdf-forms`. This skill decides *what*
  verification is needed; that one writes the fields it needs.

## Preconditions

**Every feature here is gated on the account, and you must check before offering.** Call
`get_account_capabilities` first. Offering BankID to an account that does not have it wastes
the user's time and ends the conversation badly.

The keys that matter here:

| Key | Unlocks |
|---|---|
| `signatureBankId` | BankID signing |
| `signatureIdScan` | ID-document scan as part of signing |
| `signatureFaceLiveness` | Live face check |
| `verificationEmail` / `verificationPhone` | One-time code before the document opens |
| `verificationToOpen` | Requiring that code to open at all |

If a needed capability is off, say what it would do and what it needs, then offer the
strongest option the account *does* have. Never silently downgrade.

## Two separate layers — do not confuse them

This is the distinction that causes the most expensive mistakes.

| Layer | What it is | Where it is set |
|---|---|---|
| **Signing method** | How the person signs and authenticates | On the signer, when the document is sent |
| **Document fields** | What is collected or verified *inside* the document | `tink-*` attributes in the PDF, built beforehand |

A company check inside a form is a **field**. BankID as the signing method is a **signer
setting**. They are configured in different places, at different times, and one does not
imply the other.

## Procedure

### 1. Ask what the user actually needs to prove

Not which feature they want — what they need to be true. There are four distinct answers,
and they lead to different places:

- *"I need to know this is really them."* → a signing method.
- *"I need their passport details in the document."* → document fields.
- *"I need to check the company is real and who can sign for it."* → company verification
  fields.
- *"I need a record for compliance."* → KYC, which is a specific variant, not a synonym.

One question at a time. If they name a regulation rather than a feature, translate it —
Swedish AML obligations under money-laundering rules usually mean company verification plus
retained identification, not a face check.

### 2. Choose the signing method

Four values. Each is gated as shown above. They differ in what they prove, not in a
ranking Formify publishes — do not tell a user that one satisfies a legal signature
class the others do not.

| Method | What the signer does |
|---|

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.