Every tool the 1099Policy MCP server offers, with what it takes, what it returns, and the REST endpoint behind it. For connecting and approving an assistant, see MCP server; for what to do when something does not work, see troubleshooting.

How answers are built

The tools are written so that an assistant cannot easily mislead you about insurance. These behaviours are worth knowing:

• A page is not the account. Every list returns complete. When it is false the assistant is holding one page and must fetch more before answering a count or an absence; a contractor missing from one page is not a contractor without coverage.
• Whole-account questions have their own tool. Who has no coverage? is answered by findCoverageGaps, which sweeps every contractor, policy, and quote and matches them itself, rather than by comparing two lists by hand. It counts 1099Policy policies: a contractor insured through their own approved certificate is listed as having no policy — ask about that person and the assistant reads the certificate.
• Coverage is traced policy → quote → contractor. A policy does not name its contractor directly; the quote it was bound from does. Assignments are a different relationship and are not used to decide who is covered.
• Active follows 1099Policy, not the calendar. A policy is active until it is cancelled. The expiration date on a policy is shown for reference and is never used to decide whether coverage is current.
• Dates are given to you readable. Every date field comes with a *Readable twin (expirationDateReadable: "2027-07-10"), so nothing has to convert a timestamp in its head.
• A quote is a price in dollars. getQuote returns the premium owed for the job, taxes and fees included, with the wage it is based on; the assistant says it as "$X in premium based on $Y in wages" and does not quote rates. When the premium cannot be worked out yet, it says so instead of estimating. For an hourly job the wage is one hour's pay, so the premium shown prices that hour; the premium follows the hours billed each pay period.
• A write is done when the API says so. bindAssignment returns bound, cancelAssignment returns cancelled; when either is false the record was created but coverage was not bound or not ended, and the note says why.
• Binding attaches, it does not buy. A contractor with an active policy is bound with bindAssignment; a contractor with none is sent an application with createApplySession, enrols, and only then can be bound.
• Ambiguity is a question, not a guess. Two contractors with the same name, a missing date, a category code the account has not configured — the assistant tells you what is missing rather than inventing it.

Tool reference

Thirty-five tools, one per action. Read tools run without confirmation. Write tools are served only to connections approved for Make changes (or to an API key with write permission) and are annotated so the client confirms before running them.

Each tool is a thin wrapper over one or two REST endpoints, listed under Backed by; paths are relative to https://api.1099policy.com/api/v1. The API reference is the source of truth for each endpoint's full parameters, response shape, and errors. The inputs below are the tool's own schema — the same text the assistant reads.

The server also tells every client, at connect time, how to use the tools without misleading you — the rules in How answers are built — and publishes seven ready-made prompts (coverage gaps, applications to chase, a contractor against an entity's requirements, a quote, a certificate review, a certificate the user attached, a contract the user attached) that clients supporting MCP prompts list alongside the tools.

Coverage

checkCoverage — Check contractor coverage

Verify whether a contractor (or the account) has active insurance coverage, and of which types.

• Access: Read
• Backed by: GET /contractors/{id}/policies when a contractor is given, otherwise GET /policies; coverage types are read from each policy's quote.
• Inputs:
  • contractor — Contractor public id (cn_…). Omit to check the whole account.
  • coverageType — Only report policies that include this coverage type. One of: workers-comp, general, professional, media, cyber.
  • activeOnly — When true (default), drop inactive (cancelled) policies from the result. Default true.
  • limit — Maximum number of policies to return (1-100). Default 25.
• Returns: hasActiveCoverage, count, and policies[] — each with its coverage types and effective/expiration dates (with *Readable twins). Scoped to one contractor when contractor is given, otherwise the account.

findCoverageGaps — Find contractors without active coverage

Answer "who has no active coverage", "how many of my contractors are covered", or "are there any coverage gaps" for the whole account.

• Access: Read
• Backed by: GET /policies, GET /quotes, GET /contractors — every page of each.
• Inputs:
  • includeCovered — Also list the covered contractors, not just the counts. Default false.
  • maxRecords — Safety bound per collection swept. Default 1000.
• Returns: totalContractors, coveredCount, uncoveredCount, the uncovered[] list (id, name, email), covered[] when asked for, and complete — false only if the safety bound was hit. Counts 1099Policy policies; a contractor insured through their own approved certificate appears in uncovered (see How answers are built).

listActivePolicies — List active policies

List the account's active insurance policies with the contractor each one covers, its coverage types, and effective/expiration dates.

• Access: Read
• Backed by: GET /policies; coverage types are read from each policy's quote.
• Inputs:
  • includeInactive — When true, also include inactive (cancelled) policies. Default false.
  • limit — Max policies to return (1-100). Default 25.
• Returns: count, complete, and policies[] with the contractor each covers, coverage types, and dates.

Certificates

getAssignmentCertificate — Get an assignment's 1099Policy-issued COI

Return the signed PDF download link(s) for the certificate of insurance (COI) that 1099Policy issued when this assignment's coverage was bound.

• Access: Read
• Backed by: GET /assignments/{id} → GET /policies/{id}. There is no issue endpoint: the certificate is produced by binding and this tool reads back the links.
• Inputs:
  • assignment (required) — Assignment public id (an_…) whose COI you want.
• Returns: ready, coiPdfUrl (the signed download link) and coiUrls per coverage type, or a note when the certificate is not yet issued.

getCertificate — Get an uploaded certificate and its review

Fetch one contractor-uploaded certificate of insurance by id, with its review status and results.

• Access: Read
• Backed by: GET /files/certificates/{id}?expand[]=review_results
• Inputs:
  • certificate (required) — Certificate public id (ci_…) from listCertificates.
• Returns: status, settled, source, pdfUrl (null when the certificate was filed from a chat), summary (how many rules passed and failed) and failed[] — each failed rule with its reason. A note says when the review has not finished, and when no file is on record.

listCertificates — List submitted certificates (with review)

List contractor-provided COIs with their review status and how many requirement rules passed and failed; getCertificate gives each failed rule and why.

• Access: Read
• Backed by: GET /files/certificates (expanding review_results)
• Inputs:
  • contractor — Only certificates for this contractor (cn_…).
  • limit — Max certificates to return (1-100). Default 25.
• Returns: count, complete, and certificates[] with status, source, pdfUrl and the passed and failed rule counts (summary).

reviewCertificate — Review a certificate the user shared

Check a certificate of insurance the user attached to the conversation (a PDF or a photo) against the account's insurance requirement, without filing it. The assistant reads the certificate itself and passes the fields it can see; the server runs the same rules a stored review uses and says what the certificate does not show.

• Access: Read
• Backed by: POST /files/certificates/evaluate (stores nothing)
• Inputs:
  • certificate (required) — The fields read off the certificate. Copy what is printed; leave out what is not there.
  • contractor — Optional but recommended: the contractor (cn_…) the certificate belongs to, so the insured name is compared against them.
  • requirement — Review against this insurance requirement (ir_… from listInsuranceRequirements) instead of the account's default one.
  • entity — Review against the requirement tied to this entity (en_…).
• Returns: verdict (approved or flagged as things stand), complete, summary, results[] with each rule's pass or fail and the reason, missing[] — the questions to ask for what the certificate does not show — and the requirement applied. Nothing is stored.

submitCertificate — Submit a certificate for review (writes)

Record a contractor's certificate of insurance from the fields read off it, and have it reviewed against the account's insurance requirement — the same review an uploaded PDF gets, with the same status, webhooks and notifications.

• Access: Write — requires a connection approved for Make changes; the assistant confirms before running it.
• Backed by: POST /files/certificates
• Inputs:
  • contractor (required) — Contractor public id (cn_…) the certificate belongs to.
  • certificate (required) — The fields read off the certificate. Copy what is printed; leave out what is not there.
  • fileName — The name of the file the user shared, e.g. acme_coi.pdf.
  • userProvided — Field paths the user supplied in conversation rather than the certificate showing them, e.g. coverages.workers_compensation.policy_expiration_date.
  • requirement — Review against this insurance requirement (ir_… from listInsuranceRequirements) instead of the account's default one.
  • entity — Review against the requirement tied to this entity (en_…).
• Returns: id, status (pending until the review finishes), source assistant, and a note: the review runs in the background — read the outcome with getCertificate. No file is stored; the certificate's fields are, with who supplied each.

uploadCertificate — Upload a certificate PDF (writes)

Open a drop zone in the conversation where the user drops a contractor's certificate of insurance PDF. The file is uploaded to 1099Policy, stored on the contractor's record and reviewed against the account's insurance requirement — the same as an upload in the dashboard — and the drop zone shows the review when it finishes. In clients that cannot show the drop zone, reviewCertificate reviews the fields read off the certificate instead.

• Access: Write — the drop zone is offered only on connections approved for Make changes, because the dropped file is filed on the contractor's record.
• Backed by: POST /files/certificates (the PDF), then GET /files/certificates/{id} for the review
• Inputs:
  • contractor (required) — Contractor public id (cn_…) the certificate belongs to.
  • contractorName — The contractor's name, shown on the drop zone.
• Returns: the drop zone in the conversation; once the file is uploaded, the review: approved or flagged, how many rules passed, and each failed rule.

listInsuranceRequirements — List insurance requirements

List the account's insurance requirements: the coverage types and limits a certificate must show, the boxes that must be marked, the entities and job categories each is tied to, and which one is the default.

• Access: Read
• Backed by: GET /insurance_requirements
• Inputs: none.
• Returns: count, default, and requirements[], each with its rules[] (path, condition, value).

Contractors

listContractors — List or find contractors

List contractors on the account, or find one by id, email, or name.

• Access: Read
• Backed by: GET /contractors
• Inputs:
  • query — Find contractors by public id (cn_…), email, the person's name, or their business name (case-insensitive; with several words, every word must appear).
  • limit — Max contractors to return when listing (1-100). Default 25.
• Returns: count, complete, and contractors[] (id, name, email, company, state).

createContractor — Create a contractor (writes)

Add a contractor to the account with their contact and address details.

• Access: Write — requires a connection approved for Make changes; the assistant confirms before running it.
• Backed by: POST /contractors
• Inputs:
  • firstName (required) — Contractor's first name.
  • lastName (required) — Contractor's last name.
  • email (required) — Contractor's email address.
  • address (required) — Contractor's residence address: line1, line2 (optional), locality (city), region (state, e.g. CA), postalcode, and country (ISO code, default US).
  • companyName — Business name, if the contractor operates as an entity.
  • middleName — Contractor's middle name.
  • phone (required) — Contractor's phone number.
  • withholdPremium — Whether the platform withholds this contractor's premium from their wages (true) or the contractor pays it by card (false).
• Returns: The new contractor's id, email, and name.

createLoginLink — Create a contractor login link (writes)

Generate a one-time login link so a contractor can access their own portal. The link is returned to you; nothing is sent to the contractor.

• Access: Write — requires a connection approved for Make changes; the assistant confirms before running it.
• Backed by: POST /contractors/{id}/login_link
• Inputs:
  • contractor (required) — Contractor public id (cn_…) to mint a login link for.
  • redirectUrl — URL to send the contractor to after they sign in.
• Returns: The one-time url for that contractor and when it expires (expiresAt, expiresAtReadable).

Jobs

listJobs — List or find jobs

List the account's jobs, or find one by id or name, with its category code and coverage details.

• Access: Read
• Backed by: GET /jobs
• Inputs:
  • query — Match a single job by public id (jb_…) or name (case-insensitive substring).
  • limit — Max jobs to return when listing (1-100). Default 25.
• Returns: count, complete, and jobs[] (id, name, entity, category code, wage, wage type, state).

createJob — Create a job (writes)

Create a job with a work category, entity, wage, and coverage details.

• Access: Write — requires a connection approved for Make changes; the assistant confirms before running it.
• Backed by: POST /jobs
• Inputs:
  • name (required) — Job name / title.
  • description (required) — Description of the work.
  • entity (required) — Entity public id (en_…) the job runs under.
  • categoryCode (required) — Work classification code (see listCategoryCodes).
  • wage (required) — Wage in cents (150000 = $1,500.00), expressed per wageType; from 100 ($1) to 100000000 ($1,000,000).
  • wageType (required) — How the wage is expressed. One of: flatfee, hourly, unit, blended.
  • yearsExperience — Contractor years of experience the job assumes.
  • withholdPremium — Whether the premium is withheld from the contractor's wages (true) or paid by the contractor's card (false).
• Returns: The new job's id, name, entity, and categoryCode.

listCategoryCodes — List work category codes

Look up 1099Policy's approved work classification (category) codes when creating or matching a job.

• Access: Read
• Backed by: GET /category_codes
• Inputs:
  • query — Filter by code or name (case-insensitive substring), e.g. photography or a partial code.
  • limit — Max category codes to return (1-100). Default 50.
• Returns: count and categoryCodes[] (code, name). Empty when the account has none configured yet — a job cannot be created until one is added in the dashboard.

Quotes

getQuote — Quote coverage (no binding)

Price insurance coverage for a contractor on a job and check eligibility, without binding anything.

• Access: Read (creates a quote record; binds nothing)
• Backed by: POST /quotes
• Inputs:
  • job (required) — Job public id (jb_…) the work falls under.
  • contractor (required) — Contractor public id (cn_…) to cover.
  • coverageType (required) — One or more coverage types to price. Each one of: workers-comp, general, professional, media, cyber.
  • effectiveDate — Coverage start as a Unix timestamp (seconds).
  • endDate — Coverage end as a Unix timestamp (seconds).
• Returns: quoteId, eligible, coverageTypes, premiumOwed (what the contractor pays in dollars for the wage shown, taxes and fees included; for an hourly job that is one hour's pay with the fixed fees, not the cost of the whole job; null when it cannot be worked out yet), the wage and wageType it is based on, and a premiumNote. Rates are not returned.

listQuotes — List quotes

List previously generated quotes with their eligibility, coverage types, and effective window. For the premium owed on a job, use getQuote.

• Access: Read
• Backed by: GET /quotes
• Inputs:
  • limit — Max quotes to return (1-100). Default 25.
• Returns: count, complete, and quotes[] with eligibility, coverage types, and window.

Assignments

listAssignments — List assignments

List assignments — each ties a contractor to a job over a coverage window, optionally with a bound policy.

• Access: Read
• Backed by: GET /assignments
• Inputs:
  • limit — Max assignments to return (1-100). Default 25.
• Returns: count, complete, and assignments[] — contractor, job, coverage window, and the bound policy where there is one.

bindAssignment — Bind an assignment (writes coverage)

Place a contractor on a job and bind their insurance coverage.

• Access: Write — requires a connection approved for Make changes; the assistant confirms before running it.
• Backed by: POST /assignments
• Inputs:
  • contractor (required) — Contractor public id (cn_…) to place.
  • job (required) — Job public id (jb_…) the contractor is placed on.
  • coverageType — Coverage types to bind. Omit to use the job's configured coverage. Each one of: workers-comp, general, professional, media, cyber.
  • effectiveDate (required) — Coverage start as a Unix timestamp (seconds).
  • endDate (required) — Coverage end as a Unix timestamp (seconds).
  • bind — When true (default), bind coverage now. Default true.
• Returns: bound — true only when the API bound coverage — plus the assignment and policy ids and a note. When bound is false the note says why: the contractor is already covered, has no policy of ours to attach, or the placement did not fully process.

extendAssignment — Extend an assignment (writes coverage window)

Extend an active assignment's coverage end date.

• Access: Write — requires a connection approved for Make changes; the assistant confirms before running it.
• Backed by: POST /assignments/extend
• Inputs:
  • job (required) — Job public id (jb_…) whose assignment should be extended.
  • endDate (required) — New coverage end date as a Unix timestamp (seconds).
  • sendEmail — Whether to email the contractor about the extension.
• Returns: extended, the assignment id, the new endDate, and status.

cancelAssignment — Cancel an assignment (writes, ends coverage)

Cancel an assignment and end its insurance coverage.

• Access: Write — requires a connection approved for Make changes; the assistant confirms before running it.
• Backed by: POST /assignments/cancel
• Inputs:
  • job (required) — Job public id (jb_…) whose assignment should be cancelled.
  • reason — Human-readable reason for the cancellation.
• Returns: cancelled — true only when the API reports it — with cancelledAt, or a note when coverage may still be active.

Enrollment

listApplySessions — List application sessions (who has not enrolled yet)

List contractors' insurance applications and how far each has got — who was sent a link, who is still outstanding, who has completed and been issued a policy, and how many days each has been waiting.

• Access: Read
• Backed by: GET /apply/sessions
• Inputs:
  • status — Which applications to return. One of: outstanding, completed, expired, all. Default outstanding.
  • contractor — Contractor public id (cn_…) to narrow to one person.
  • limit — Max sessions to return (1-100). Default 50.
• Returns: status filter echoed back, count, complete, and sessions[] — contractor, step, daysSinceSent, url, expired, enrolled, and the policy once one exists.

getApplySession — Get an application session's status

Check where a contractor is in the application flow — the current step (e.g. sent, opened, completed) and whether the session has expired.

• Access: Read
• Backed by: GET /apply/sessions/{id}
• Inputs:
  • session (required) — Application session public id (as_…) to inspect.
• Returns: step, url, expired, enrolled, the quote and (once issued) the policy, and created/createdReadable.

createApplySession — Start an application session (writes)

Start an application (opt-in) session and return the link a contractor uses to complete enrollment.

• Access: Write — requires a connection approved for Make changes; the assistant confirms before running it.
• Backed by: POST /apply/sessions
• Inputs:
  • quote (required) — Quote public id (qt_…) the application is based on.
  • contractor — Contractor public id (cn_…) the session is for.
  • successUrl — URL to redirect the contractor to after they complete.
  • cancelUrl — URL to redirect the contractor to if they cancel.
  • isGeneralOptIn — Whether this is a general opt-in (not tied to one job).
  • generalOptInWorkState — Work state for a general opt-in, e.g. CA.
• Returns: id, the application url to send the contractor, the current step, and expired.

Billing

listInvoices — List invoices

List premium invoices — each states what a contractor owes for a pay cycle, computed from their gross pay, with the pay-cycle window and purchase order number.

• Access: Read
• Backed by: GET /invoices
• Inputs:
  • limit — Max invoices to return (1-100). Default 25.
• Returns: count, complete, and invoices[] — premium due, gross pay, pay-cycle window, and purchase order number, per contractor. These are the contractors' premium invoices, not the account holder's own bill.

Account and team

listEntities — List or find entities

List the business entities on the account (for organizations that run more than one), or find one by id or name.

• Access: Read
• Backed by: GET /entities
• Inputs:
  • query — Match a single entity by public id or name (case-insensitive substring).
  • limit — Max entities to return when listing (1-100). Default 25.
• Returns: count, complete, and entities[] with requiredCoverage, coverageLimit, and state.

listTeamMembers — List team members

List the team members on the account — the dashboard users attached to the active organization, with their role, plus anyone invited who has not accepted yet.

• Access: Read
• Backed by: GET /team-members
• Inputs:
  • query — Match a single member by email or name (case-insensitive substring).
  • includeInvited — Include people invited but not yet accepted (status invited). Default true.
  • limit — Max members to return (1-100). Default 100.
• Returns: count, active, invited, and teamMembers[] (email, name, role, status).

inviteTeamMember — Invite a team member

Send an invitation to join the active organization as a member or owner.

• Access: Write — requires a connection approved for Make changes; the assistant confirms before running it.
• Backed by: POST /team-members
• Inputs:
  • email (required) — The email address to invite.
  • role — Role on the organization. One of: member, owner. Default member.
• Returns: invited, email, role, status, and a note: the invitation email is sent; they become a member when they accept.

removeTeamMember — Remove a team member

Remove a person from the active organization by email.

• Access: Write — requires a connection approved for Make changes; the assistant confirms before running it.
• Backed by: DELETE /team-members
• Inputs:
  • email (required) — The email address to remove.
• Returns: removed, email, and a note saying whether a member was removed or a pending invitation withdrawn. An organization key cannot remove an owner.

getAuditTrail — Get account audit trail

Return recent events from the account's audit trail (policies bound, assignments created, invoices posted, …), newest first.

• Access: Read
• Backed by: GET /events
• Inputs:
  • type — Case-insensitive filter on the event type, e.g. policy, assignment, invoice.
  • limit — Max events to return, newest first (1-100). Default 25.
• Returns: count, complete, and events[] — type, created/createdReadable, and the event's data, with signed download links replaced by a marker (use getAssignmentCertificate for a certificate link). When a type filter is applied to a partial page, filterNote says so.

listAccounts — List connected organizations

List the 1099Policy organizations this connection can act on and show which one is currently active.

• Access: Read
• Backed by: none — reads the connection's own state.
• Inputs: none
• Returns: count, the active organization, and accounts[] (label, live or sandbox, active).

useAccount — Switch to another connected organization

Switch which connected 1099Policy organization the other tools act on.

• Access: Read
• Backed by: none — changes the connection's own state.
• Inputs:
  • account (required) — Which organization to switch to, as its position in listAccounts (1 for the first). Call listAccounts first — positions are only meaningful against that list.
• Returns: switched, the now-active organization, and the list. The switch persists for the connection, including across token refreshes.

Classification

analyzeContract — Analyze a contract for misclassification risk

Judge whether a written work arrangement the user shared (a contract, statement of work, offer letter or email thread) holds up as independent-contractor work under a U.S. state's classification test. The assistant transcribes the document and passes its text; the server applies the state's test factor by factor — California's ABC test, New York's common-law factors, the federal economic-realities test and others — quoting the clause behind each verdict. Nothing is stored. This is an automated heuristic, not legal advice, and the result says so.

• Access: Read
• Backed by: POST /classification/analyses (stores nothing)
• Inputs:
  • contractText (required) — The full text of the agreement from what the user shared (PDF, image or pasted text): every clause, in order, with its heading or number, as plain text rather than a summary.
  • state — The U.S. state whose law applies, as a two-letter code (CA, NY, TX, MA) or FEDERAL for the U.S. Department of Labor test: the one the agreement's governing-law clause names, or where the work is performed. listClassificationStates shows what is available.
  • contractor — The contractor (cn_…) the agreement is with, when they are on the account; their name is passed to the analysis.
  • contractorName — The worker's or their business's name when there is no contractor record.
• Returns: overallRisk (low, medium, high, critical), test, summary, factors[] with verdict (pass, fail, unclear), the evidence quoted from the text, explanation and recommendation, recommendations[], disclaimer, and a nextStep. A factor the text is silent on comes back as a question for the user.

listClassificationStates — List jurisdictions for contract analysis

List the U.S. states (two-letter codes) and FEDERAL whose worker-classification tests analyzeContract can apply.

• Access: Read
• Backed by: GET /classification/states
• Inputs: none.
• Returns: states and the default applied when none is given.

Talking to it

Ask in plain language. The assistant turns the request into a tool call and reports what the tool returned — never more than it returned.

❯

Which organizations am I connected to?

Lists them and says which one is active.

❯

Switch to Northwind, then show me who has no coverage.

Switches the active organization and answers there.

❯

Does the videographer we booked in PA have active WC and GL for Saturday's shoot?

Finds the contractor, checks their active policies for workers' comp and general liability, and answers yes or no — with the policy and its dates.

❯

Who on the account has no active coverage right now?

Sweeps every contractor, policy and quote — every page, not the first — and returns the ones with nothing active, with the count.

❯

Alvarez uploaded his own COI. Did it meet our GL requirements?

Returns the certificate's review: which requirements passed, which failed, and by how much. A contractor whose own certificate was approved is reported as insured, even though no 1099Policy policy is attached.

❯

Here's the COI Alvarez just sent — does it cover us for the Northwind launch? (with the PDF or a photo of it attached)

Reads the certificate, checks it against your insurance requirement, and reports what passes and what falls short, with the amounts. What the certificate does not show — an expiration date, an unclear additional-insured box — comes back as a question to you, not as a guess.

❯

Which freelancers still haven't finished their insurance application, and how long have they been sitting on it?

Lists the outstanding applications with the step each stopped at and the days since the link was sent.

❯

What would it cost to cover Rivera, the freelance set designer, on the Denver install through end of quarter?

Prices the coverage and checks eligibility without binding anything, and reports the premium owed in dollars with the wage it is based on.

❯

Pull the certificate of insurance for Rivera's Denver install.

Returns the signed PDF download links for the COI issued when her coverage was bound.

❯

What premium was invoiced for June?

Lists June's premium invoices — what each contractor owed for the pay cycle. These are the contractors' invoices, not the agency's own bill.

❯

Here's the agreement we're about to send Rivera — will it hold up as a 1099 arrangement in California? (with the contract attached)

Transcribes the agreement, applies California's ABC test clause by clause, and reports the risk: which factors fail and the sentence that makes them fail, what to change, and what the agreement is silent on. It says plainly that this is an automated review, not legal advice.

With a connection you approved for Make changes:

❯

Rivera accepted. Bind her coverage for the Denver install, March 3 through 14.

Confirms the details with you, binds the assignment, and reports what came back — bound, or the reason it was not. Someone who has never enrolled has nothing to attach, so instead of attempting a bind that cannot succeed it offers to send them an application link.

❯

The mural ran long. Extend Chen's coverage through the 15th.

Extends the assignment's coverage window.

❯

The certificate looks right. File it.

Records Alvarez's certificate from the fields as read plus the answers you gave, runs the review, and reports whether it came back approved or flagged. No file is stored; the fields are, with who supplied each.

❯

Put Alvarez's certificate PDF on his record.

Opens a drop zone in the conversation. The PDF dropped on it is stored on his record and reviewed like a dashboard upload, and the card shows the result: approved, or flagged with what is missing. Offered only on connections approved for Make changes.

❯

Send Priya an application link for the copywriting engagement.

Starts an application session and returns the link she completes.

❯

Add dana@studio.example to the team as a member, on every organization I manage.

Invites her to each one, switching organizations as it goes.

Questions

Email integration@1099policy.com.