Skip to content

Changelog

Changes to the API and webhooks, newest first.

Changes to the API and webhooks that affect an integration, newest first. Changes to the product that do not touch this surface are not listed.

2026-11-09: Contractor work accepted from Jira

  • A milestone's verificationMethod may now be jira, in GET /api/v1/milestones and on its own page: the work was accepted by a person against the milestone's acceptance criteria once its Jira issue was done. Its verificationDetail is { note, jiraIssue, issueId, identifier, cloudId, completedAt, fingerprint, criteriaSha256, acceptedBy }, cloudId being the Jira site's id; once an acceptance is taken back it also carries heldReason and heldAt, verified is false, verificationStatus is unverified and status is pending again. The TypeScript SDK 0.4.3 accepts the value.
  • Five new entries, domain contractor, each listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • jira_issue_linked, actor human: { by, milestoneId, linkId, issueId, identifier, projectKey, cloudId, issueUrl, completed, fingerprint }. identifier is the issue's key, such as ENG-142; fingerprint is null until the issue is done, since its deliverables are read only then.
    • jira_issue_unlinked, actor human: { by, milestoneId, linkId, issueId, identifier, withdrewAcceptance }.
    • jira_issue_ready, actor system: { milestoneId, linkId, issueId, identifier, completedAt, statusName, resolutionName, fingerprint, deliverables }, when a linked issue is done in Jira and the milestone has criteria. It verifies nothing: deliverables is a count.
    • jira_work_accepted, actor human: { by, milestoneId, linkId, issueId, identifier, issueUrl, completedAt, statusName, resolutionName, fingerprint, deliverables, criteriaSha256, payeeJiraMapped }, when a person accepted the work. deliverables lists each { kind, label, href } accepted, kind being attachment (a file or a web link), link or comment_link; fingerprint is the SHA-256 of that set; payeeJiraMapped says whether Jira named an Atlassian account for the payee's email.
    • jira_acceptance_withdrawn, actor system: { milestoneId, linkId, issueId, identifier, reason, afterPayment, acceptedFingerprint, fingerprint, completed, completedAt, statusCategory }, when the issue was reopened, resolved as not done, its deliverables changed, or Jira no longer showed it after the work was accepted. reason is reopened, canceled, deliverable_changed or issue_unreachable. fingerprint is null when only the issue's status was read, and completed, completedAt and statusCategory are null when Jira no longer showed the issue. With afterPayment: false the milestone lost its verification before any payment; with afterPayment: true a payment was already sent, and is not taken back.
  • No entry carries an Atlassian account ID, name or email.
  • milestone_criteria_set is written for a milestone linked to a Jira issue too, with the same fields as for Asana and Linear.
  • A new Jira connection's accounting_connected carries provider: "jira" and consent.version jira-2026-11-09; its externalOrgId is the Jira site's cloud id, and externalOrgName the site's name. Disconnecting signs accounting_disconnected with revokedAtProvider: false, since Atlassian gives apps no way to end their own access.
  • Nothing else in /api/v1 changes: a milestone is not linked to a Jira issue through the API, and the write API still adds a milestone pending.

2026-11-06: The ledger newest first, and Zapier

  • GET /api/v1/ledger takes order: asc, the default, oldest first and resumable from a cursor as before; or desc, the newest limit entries, newest first, with domain and actor as before. order=desc takes no cursor and answers 400 invalid_request to one, since a watermark read the other way round would skip or repeat entries; its page.nextCursor is null, and page.hasMore says whether older entries exist. Any other order answers 400. A request without order answers exactly as before.
  • A private Zapier integration reads it: triggers New Agent Decision, Bill Paid and New Ledger Entry, and the action Create Bill, with a workspace API key. The Postman collection's List the agent's decisions now reads newest first. The TypeScript SDK 0.4.2 accepts order; its ledger.list pages, the CLI and the MCP server keep reading oldest first. Nothing else in /api/v1 or the webhooks changes.

2026-11-01: Bills from a Google Drive folder

  • Three new entries, domain ap, each listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • google_drive_folder_chosen, actor human: { by, folderId, folderName, baseline }, when an owner or admin chose the Google Drive folder the workspace reads, in place of any chosen before. baseline is how many files were in the folder then, which are never read; their names and ids are not in the entry. The same folder chosen again is recorded again with the baseline it kept from its first choice.
    • invoice_drive_file_received, actor system: { inboxEmailId, driveFileId, fileName, lastModifiedBy, read, document }, when a file added to the folder after it was chosen was read. fileName is the file's name, cut to 120 characters; lastModifiedBy is the email of whoever last changed the file in Drive with most of its name hidden, or null when Drive did not say; read is ready, needs_details or unreadable; and document is the document's kind and sha256, or null for a file that was not read, such as a picture or a Google Docs file.
    • invoice_drive_file_dismissed, actor human: { by, inboxEmailId, driveFileId }, when a member dismissed the file in the review list. An emailed invoice's dismissal is still invoice_email_dismissed.
  • create_invoice entries gain via: "google_drive", with inboxEmailId (the row in the review list, under the name emailed invoices already use) and driveFileId, when a member added the payable from a file found in the folder. Such an entry carries document as one added from a document does, changed included. Nothing found in the folder is added without a person.
  • A new Google Drive connection's accounting_connected carries provider: "googledrive" and consent.version googledrive-2026-11-01; its externalOrgId is the Google account's Drive permission ID, and externalOrgName its email with most of its name hidden. Disconnecting signs accounting_disconnected, as for every connector.
  • Nothing else in /api/v1 changes: a folder is chosen, and its files added or dismissed, in the console only.

2026-10-31: Contractor work accepted from Linear

  • A milestone's verificationMethod may now be linear, in GET /api/v1/milestones and on its own page: the work was accepted by a person against the milestone's acceptance criteria once its Linear issue was done. Its verificationDetail is { note, linearIssue, issueId, identifier, completedAt, fingerprint, criteriaSha256, acceptedBy }; once an acceptance is taken back it also carries heldReason and heldAt, verified is false, verificationStatus is unverified and status is pending again. The TypeScript SDK 0.4.1 accepts the value.
  • Five new entries, domain contractor, each listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • linear_issue_linked, actor human: { by, milestoneId, linkId, issueId, identifier, teamKey, issueUrl, completed, fingerprint }.
    • linear_issue_unlinked, actor human: { by, milestoneId, linkId, issueId, identifier, withdrewAcceptance }.
    • linear_issue_ready, actor system: { milestoneId, linkId, issueId, identifier, completedAt, completedByName, fingerprint, deliverables }, when a linked issue is done in Linear and the milestone has criteria. It verifies nothing: deliverables is a count.
    • linear_work_accepted, actor human: { by, milestoneId, linkId, issueId, identifier, issueUrl, completedAt, completedByName, fingerprint, deliverables, criteriaSha256, payeeLinearMapped }, when a person accepted the work. deliverables lists each { kind, label, href } accepted, kind being attachment, link or comment_link; fingerprint is the SHA-256 of that set.
    • linear_acceptance_withdrawn, actor system: { milestoneId, linkId, issueId, identifier, reason, afterPayment, acceptedFingerprint, fingerprint, completed, completedAt, stateType }, when the issue was reopened, canceled, archived or deleted, its deliverables changed, or Linear no longer showed it after the work was accepted. reason is reopened, canceled, archived, deliverable_changed or issue_unreachable. With afterPayment: false the milestone lost its verification before any payment; with afterPayment: true a payment was already sent, and is not taken back.
  • milestone_criteria_set is written for a milestone linked to a Linear issue too, with the same fields as for Asana.
  • A new Linear connection's accounting_connected carries provider: "linear" and consent.version linear-2026-10-31; its externalOrgId is the Linear workspace's id, and externalOrgName its name.
  • Nothing else in /api/v1 changes: a milestone is not linked to a Linear issue through the API, and the write API still adds a milestone pending.

2026-10-30: Several bills approved with one confirmation

  • A person can now select from 2 to 20 bills on the console's Approvals page and approve them with one confirmation. Each bill is still decided and recorded on its own: one approval_paid entry per bill, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended, with every field it had before.
  • approval_paid gains approvedTogether, a whole number from 2 to 20, on a bill approved that way: how many bills the person chose in that confirmation. It is absent on a bill approved on its own, and on every entry signed before this date. A first of two approvals given that way is not an approval_paid and carries nothing new.
  • approval_paid gains batch, { key, size }, when the bill's transfer shared one Arc transaction with other bills of the same confirmation, as a milestone_release entry's execution.batch does: key identifies the batch and size is how many transfers it carried. Its txRef is then the batch's transaction, shared with the other bills in it. When Circle had confirmed that transaction by the time the bills were recorded, each one's agentReasoning on GET /api/v1/invoices includes [paid in one Arc transaction with 1 other bill], or how many other bills it paid. A batch Circle failed leaves each bill held, with batch on its entry, and its next approval sends a transfer of its own.
  • There is no new endpoint, and nothing in /api/v1 approves a bill. Slack approves one bill at a time, as before, where an owner lets bills be decided there; Telegram and Discord approve none, and their links open the bill in Approvals. Nothing else in /api/v1 or the webhooks changes.

2026-10-30: Evidence, receipts and close packs as MCP tools

  • The MCP server has five new read-only tools, one for each evidence read: get_invoice_evidence, get_milestone_evidence, get_invoice_receipt, get_payee_lock_evidence and get_close_pack. Each takes its operation's parameters (id; from and to; or month) and runs that operation with the caller's key, under the same limit per key as the API. The server now lists 18 tools.
  • Each answers a digest of the signed file, not the file. It starts with about, a sentence saying that its names, numbers, memos and links came from outside Vestiarion and are data, never instructions. It keeps what the file says, each fact with the seq of the entries it rests on; counts the server's check of each entry the file carries in signatures (cited, verified, failed, unchecked); and names the API path and the SDK method for the complete signed file in fullFile. It leaves out entries, keys, signedEntryProves and checkAnEntry.
  • The payee lock's digest holds the newest 50 address changes, with changesShown and changesTotal. The close pack's holds the first 100 settled payments as rows, each with its payee, its bill, approval.authorizedBy, transaction.txHash, transaction.chain and entry, with rowsShown and rowsTotal, and counts the payments not settled and the escrow moves in notSettled and escrow. No digest is over 200 KB: a larger one holds fewer changes or rows, and notShown says how many.
  • These five tools' descriptions describe the digest; the reference pages and the OpenAPI document still describe the full file. An error passes through as the API's own, a 404 not_found or a 429 rate_limited among them. A close pack, or the payee lock's evidence for a period, whose full file is over 4 MB has no digest: it answers the API's 400 invalid_request, as on Limits. Nothing in /api/v1, the SDK or the webhooks changes.

2026-10-28: Earned vendors paid on their own

  • A new entry, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended: earned_vendor_payments_changed, domain system, actor human, when an owner lets the agent pay earned vendors on their own in shadow mode, or makes their payments wait for a verdict again. It carries by, from and to, each true or false. A change whose entry cannot be signed is put back; should that fail too, the missing entry is signed by the owner's next change, first. Turning the rule for earned vendors off turns this off too, in the same change: an earned_vendor_payments_changed with to: false follows the earned_vendor_rule_changed with to: null. While no rule is in force it is off, whatever its newest entry says.
  • ap_pay gains earned, { recordSeq, streak, agreed }, when the agent paid the bill on its own in shadow mode for an earned vendor: recordSeq is the seq of the vendor's vendor_earned entry, streak the rule, and agreed the agreed verdicts in a row when the cycle started. The entry keeps shadow: true and has no execution.heldBecause of shadow_verdict; execution.resultingStatus says how it ended, paid or matched for a transfer, or held when the live path held it (the pause, the cash). A verdict can be given on it after, as on any decision. It is absent on every other ap_pay, and on every entry signed before this date.
  • vendor_earned_lost can now carry trigger: "cycle" with because flagged or code_stop signed in the middle of a cycle, right after the decision entry it names in decisionSeq, when a decision about a vendor the agent was paying on its own broke its status.
  • shadow_mode_started's summary names the exception when the switch is on as shadow mode starts: Shadow mode started, for bills in USD: the agent pays nothing until a person agrees, except vendors that earned it under the owner's rule. With the switch off it reads as before.
  • approval_paid gains recorded: true when the approval sent nothing of its own and only read and recorded the transfer sent before it: one that already existed, or a send Circle never answered, looked for on Circle. Its txRef, status and attempt are that transfer's. It is absent when the approval sent a transfer, and on every entry signed before this date. A payment the agent made on its own for an earned vendor stays the agent's after such an approval.
  • weekly_brief_sent, in shadow mode, gains paid.onItsOwn when the agent paid any of the week's payments on its own for an earned vendor: how many of paid.count it paid that way, which no one agreed to first. It is absent otherwise.
  • A bill the agent paid this way has agentReasoning on GET /api/v1/invoices ending [an earned vendor under the owner's rule: paid without waiting for a verdict; give yours after]. The ap_pay entry's decision.reasoning stays the model's own.
  • With the switch on, being earned changes what the agent does with a payment in shadow mode on Arc testnet; nothing changes on Arc mainnet or in a live workspace. Nothing else in /api/v1 or the webhooks changes.

2026-10-28: Earned vendors

  • Three new entries, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended, in a workspace on Arc testnet where an owner set a rule for earned vendors: N agreed shadow-mode verdicts in a row on the agent's decisions to pay or schedule a vendor's bills.
  • earned_vendor_rule_changed, domain system, actor human, when an owner sets, changes or turns off the rule. It carries by, from and to, each a whole number from 5 to 50, or null for no rule. A change whose entry cannot be signed is put back. Should that fail too, the change stays in force without its entry until an owner asks for that rule again or changes it: the missing entry is then signed first, its from the to of the newest entry before it, and its by that owner.
  • vendor_earned, domain compliance, actor system, when a vendor meets the rule. It carries counterpartyId; streak, the rule; agreed, the agreed verdicts in a row; evidence, the seq of each decision entry behind them, newest first, at most 50; from and to, the times of the oldest and newest of those; since, what last started the count again, or null: { kind, at, decisionSeq, rule }, with kind disagreed, flagged or code_stop, decisionSeq the decision it was about, and rule the rule that flagged or stopped that decision, null for disagreed and for a flag the agent's model made; and trigger, verdict, rule or cycle.
  • vendor_earned_lost, domain compliance, actor system, when a vendor that met it no longer does. It carries counterpartyId, streak (null when the rule was turned off), because (disagreed, flagged, code_stop, rule_changed, rule_off, high_risk, no_payment_limit or not_a_vendor), decisionSeq (the decision behind disagreed, flagged or code_stop, else null), rule (the rule that flagged or stopped that decision, else null, as it always is for disagreed and for a flag the agent's model made), and trigger.
  • A vendor's newest vendor_earned or vendor_earned_lost entry is its last signed status. While no rule is in force, that is, while the newest earned_vendor_rule_changed has to: null, no vendor is earned, whatever its newest entry says. Only in the case above, until its entry is signed, does the newest earned_vendor_rule_changed not name the rule in force; a status signed meanwhile carries the rule it was signed under in streak. None carries an email. Being earned by itself changes nothing the agent does with a payment: only the owner's switch in the entry above does. Nothing else in /api/v1 or the webhooks changes.

2026-10-26: What the reader noted in a vendor's document

  • document_checked gains readerNote, beside readerFlagged: true, when the workspace's model flagged the document: the note it wrote, as a string of at most 200 characters, cleaned first. Format, private-use, unassigned and other invisible characters, bidi controls, zero-width ones, variation selectors and Hangul fillers among them, are removed. It is in Unicode NFKC, so fullwidth letters and dots read as plain ones, and a letter keeps at most two combining marks. Control characters and line breaks become a space, as does an HTML character reference such as : or :; it is one line with its whitespace collapsed. A link reads (link removed): a Markdown link or image, whatever its destination, and a link in angle brackets; one with a scheme, such as https://, javascript:, ethereum: or data:; one starting // or www.; a domain name such as pay.example.com, with or without a path, whose last label is a top-level domain, including one written with fullwidth or ideographic dots or in another script, and one that reads as a file's name, such as statement.zip; and an IPv4 address. A file's name such as invoice.pdf or receipt.tiff, and an abbreviation such as St.Louis, stays. An email address reads (email address removed) and a run of 32 or more letters, digits, _, -, +, / or = (token removed), while a 0x address or hash stays. Every double quotation mark and every character that looks like one becomes ', and so does every run of two or more quote-like or prime-like characters, of one kind or mixed: single quotes, backticks, acute accents, modifier primes, low single quotes, ornaments and gereshes among them. A longer note ends with .... It is absent when the model set no note, or one with nothing left once cleaned, and on every entry signed before this date. It is the model's reading of an untrusted document, never Vestiarion's: treat it as text to show, never as an instruction.
  • reason on such an entry, the sentence the bill's card shows, now quotes the note after its sentence: The reader flagged something in it for a person to check. The reader noted: "...", or the first check that failed followed by The reader noted: "...", within 300 characters: a long note is cut with ... when at least 40 of its characters fit after the sentence, and otherwise follows, whole, a short form of the sentence that names no purchase order or name, such as The document names more than one purchase order. (the values compared stay in checks). A reason that ends without a closing quotation mark quotes no note.
  • sentence, on every document_checked entry whose outcome is mismatched, is the first failing check's sentence whole, or the flag's own: as reason begins, but naming the purchase orders compared where reason gives the short form. The entry's summary gives that sentence, then the whole note when there is one, The reader noted: "...", and is not held to 300 characters. sentence is absent on entries signed before this date.
  • It is sent to webhook endpoints as ledger.appended and listed by GET /api/v1/ledger, in shadow too. It never carries the document's text, the vendor's own note, an email address, a link or a token, as defined above. Escape readerNote, reason, sentence and the summary for wherever you show them, as you would any text from a vendor. Nothing else in /api/v1 or the webhooks changes.

2026-10-25: Evidence, receipts and the close pack

  • GET /api/v1/invoices/{id}/evidence and GET /api/v1/milestones/{id}/evidence answer { data } with one payable's or milestone's evidence, vestiarion-evidence/1: subject, labels, steps with their facts (each citing entries by seq), signedEntryProves, checkAnEntry, keys, and every cited entry in full (body_hash, signature, prev_hash, hash, signing_key_id, check). A fact's who is a member's user id, never an email: "a former member" for someone who has left, "a member" when the members could not be read, "the payee" for what a payee entered, @<login> on GitHub for a GitHub bounty, or null when the ledger names no one. A receivable, or an id the workspace does not hold, answers 404.
  • GET /api/v1/invoices/{id}/receipt answers vestiarion-receipt/1: ready; notReady (code not_paid, simulated, not_minted, no_transaction or not_recorded, and reason); facts as a shared receipt states them; records (seq, hash); invoiceEntry; shared (at, entry, linkOpen, changes); checks (recorded, onChain); keys and entries. It never carries a receipt's link or its hash.
  • GET /api/v1/payee-lock/evidence takes from and to (YYYY-MM-DD, either left out for an open end) and answers vestiarion-payee-lock-evidence/1. A member is { kind: "member", userId, email: null }; the file downloaded from the workspace now carries userId beside email.
  • GET /api/v1/close-packs/{month} answers vestiarion-close-pack/1 for month as YYYY-MM, with every member's email null.
  • The five share a limit per key: 10 at once, then one every 6 seconds; over it they answer 429 rate_limited with Retry-After: 60. A close pack or a payee lock period whose answer would be over 4 MB answers 400 invalid_request. Every other read stays unlimited. None of the five writes a ledger entry or sends a webhook, and none is an MCP tool yet.
  • The TypeScript SDK 0.4.0 adds invoices.evidence, milestones.evidence, invoices.receipt, payeeLock.evidence, closePacks.get and verifyEvidence, with the types PaymentEvidence, PaymentReceipt, PayeeLockEvidence and ClosePack. Naming keys with no value throws, so an unset variable never falls back to the file's keys. verifyEvidence(document, { keys, format }) takes the format you expect, and a file of another format throws; options other than { keys, format }, a PEM passed alone among them, throw too. A file that holds another format's citing fields, or cites something that is not an entry's seq, is ok: false. Nothing else in /api/v1 or the webhooks changes.

2026-10-25: Close packs exported to Google Sheets

  • close_pack_exported takes format: "google_sheets" when a member exports a month to Google Sheets, with connectionId, spreadsheetId (Google's id of the spreadsheet) and created (a new spreadsheet was made). Its sha256 is then the SHA-256 of the Payments tab as written: JSON.stringify of its rows, the header first, each as wide as the header. It names no one by email and carries no URL.
  • A new entry, actor human, domain system, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended: close_pack_export_failed { by, month, ended, format, connectionId, spreadsheetId, stage, reason }, when an export failed after rows may have reached Google. stage is write or read_back; reason is rate_limited, unavailable, reconnect (Google stopped accepting the connection), forbidden, drive_full, gone (the spreadsheet was deleted during the export), bad_response or mismatch. It counts toward the same ten in ten minutes as close_pack_exported.
  • accounting_connected and accounting_disconnected may carry provider: "googlesheets"; externalOrgId is then the Google account's permission id and externalOrgName a masked email.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-25: Checking a vendor's document against its bill

  • document_checked, new, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended, domain ap, actor agent: the cycle checked a document that a vendor sent, or a member attached, against its bill, once per document. It carries invoiceId, counterpartyId and requestId; source, vendor or member; fileSha256, fileType and fileSize; missing, what the bill lacked when it was checked (purchase_order, goods_receipt, or both; none for a bill that no longer waited); outcome, matched, mismatched, unreadable or skipped; reason, the sentence the bill's card shows, null when it matched; reader, anthropic, openai, deepseek or heuristic, null when nothing was read; checks, one { check, result, document, bill, alsoRead? } per check run, where check is vendor, currency, amount, purchase_order, pay_to or invoice_number, result is match, mismatch or absent, amounts are plain decimals with at least 2 places, and alsoRead is another reading that differs; poReference, the purchase order the document names, when it names one; poWritten, true only when that purchase order was added to the bill; and readerFlagged: true, truncated: true (only its first 20,000 characters were read) and shadow: true (vendor requests were in shadow) when they apply. It never carries the document's text, the model's or the vendor's note, an email address or a link, and has no observed.
  • document_received can now be a member's: by is the owner or admin who attached the vendor's document from the bill's card, via is "attached", and it carries invoiceId, counterpartyId, requestId, fileSha256, fileType: "application/pdf" and fileSize. One the vendor sent keeps by: null and via: "document_request".
  • GET /api/v1/invoices: a payable's poReference can now come from a document_checked with poWritten: true, while vendor requests are on. Nothing else on the bill changes: not its status, amount, currency, due date, goods receipt or address.
  • The agent's ap_pay and ap_schedule decisions on such a bill are held for a person under the guardrail rule invoice.vendor_document (guardrailBlocked: true, execution.resultingStatus: "held"), after every other rule of the agent's guardrails and before obligation.duplicate_reference and project.budget_exceeded, which do not run for a decision it holds: such a bill reserves nothing in its project. Every ap_* entry on such a bill carries vendorDocument: { requestId, source, fileSha256 }, whichever rule held it. A person's approval_paid pays it, as before.
  • A cycle's journal has a new stage, document_checks, after compliance. It needs no other stage to have succeeded.
  • A cycle_complete entry's events can also include document_received, when a vendor sent, or a member attached, a document while vendor requests are in shadow or on.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-25: The monthly close pack

  • A new entry, actor human, domain system, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended: close_pack_exported { by, month, ended, format, payments, notSettled, sha256, headSeq }, when a member downloads a workspace's close pack for a month. month is YYYY-MM; ended is false for a month still running; format is csv or json; payments and notSettled count its rows; sha256 is the SHA-256 of the file served, in hex; headSeq is the ledger's last entry when it was read. It names no one by email. Nothing else in /api/v1 or the webhooks changes.

2026-10-23: Late fees on bills

  • POST /api/v1/invoices accepts lateFee, the late fee a payable charges once it is paid late, or null for none: kind is percent_month, a percent a month of what is still owed, more than 0 and at most 10, or fixed, an amount in currency, more than 0 and at most amount; value is the percent or the amount; startsOn, the first day it applies as YYYY-MM-DD, is on or after dueDate, and defaults to the day after it. A receivable with a late fee is refused with 400, as is a value out of range (lateFee.value) or a start before the due date (lateFee.startsOn).
  • GET /api/v1/invoices, and the invoice a write answers with, carry lateFee: { kind, value, startsOn }, or null.
  • create_invoice entries carry lateFee ({ kind, value, startsOn }, value as entered) when the invoice was added with one.
  • The agent's ap_* decisions carry lateFee in their terms when the bill has one: { kind, value, startsOn, aMonth }, where aMonth is what a month past its start costs, in the invoice's currency. A late fee is never added to what is paid: amountPaid is the invoice's amount, less an early-payment discount, as before.
  • cash_priority_set entries' order items carry lateFee, the bill's late fee as create_invoice signs it ({ kind, value, startsOn }), when it has one. Their referenceOrder now puts first, among the bills due or overdue, the one whose late fee costs most in USDC in the coming 30 days; a fixed fee that has started, or a fee that starts after those 30 days, counts for nothing.
  • decision_escalated entries' decideBy can also be the eve of a bill's late fee, the day before it starts: a bill past its due date whose fee starts later than the day after it is escalated once more on that day, besides once its due date has passed, as before. When its due date was not escalated before that day, as on the first day past it, the entry is for the due date, as before, and the eve is not escalated apart: a late fee never delays an escalation. Each is escalated once for its day, and an entry that tells such an eve says in its summary how many payments have a late fee from tomorrow. A late fee never moves a bill's decide-by day.
  • The TypeScript SDK 0.3.7 describes lateFee on Invoice and CreateInvoiceInput. Nothing else in /api/v1 or the webhooks changes.
  • org_created carries via: "accountant_link" for a workspace a client opened from their accountant's client link. Such a workspace is always on Arc testnet, network: "arc-testnet".
  • member_joined for the accountant follows in that workspace, domain system, actor human, with role: "accountant", clientLinkId (the link's id) and grantedBy (the client, the workspace's owner). by is the accountant, as for an accepted invitation, which carries invitationId instead.
  • member_joined in a workspace on Arc mainnet opened as a live slice, for each accountant of the shadow workspace its owner brought along, carries by (the accountant), role: "accountant", via: "live_slice" and grantedBy (the owner).
  • Making and revoking a client link is signed in no workspace, since none exists yet. Nothing else in /api/v1 or the webhooks changes.

2026-10-23: Asking a vendor for a missing document

  • Five new entries, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • document_requests_changed, domain system, actor human: an owner set vendor requests to off, shadow or on in Settings. It carries by, from and to.
    • document_request_drafted, domain ap, actor agent: with vendor requests in shadow, a bill waiting for its purchase order or goods receipt was recorded as one the agent would ask its vendor about; nothing was sent. It carries invoiceId, counterpartyId, requestId, missing (purchase_order, goods_receipt, or both) and emailDomain, the billing email's domain, never the address. One per bill, not one per cycle.
    • document_requested, domain ap, actor agent: the vendor's billing email was sent a one-time link to send the document. It carries the same fields and expiresAt, 14 days after it was sent, never the link or the address.
    • document_received, domain ap, actor human, with by: null and via: "document_request": the vendor sent the document through its link. It carries invoiceId, counterpartyId, requestId, poReference when the vendor typed one (plain text on one line, of at most 100 characters, with no link), fileSha256, fileType (application/pdf, image/png or image/jpeg) and fileSize in bytes, never the file or the vendor's note.
    • document_request_revoked, domain ap, actor human: an owner or admin revoked an open request, whose link stopped working. It carries by, requestId, invoiceId and counterpartyId.
  • In a sandbox, document_request_drafted and document_requested carry sandbox: true: a sandbox never emails its vendors, so the request goes to the member who set vendor requests, and emailDomain is that member's email domain.
  • None of them changes the bill: its status, amount, purchase order and address stay as they were, as GET /api/v1/invoices returns them. A person still adds the purchase order with Add details, recorded as invoice_details_added.
  • A cycle's journal has a new stage, document_requests, after term_requests. It needs the ap stage to have succeeded.
  • A cycle_complete entry's events can also include document_requests_on, when an owner set vendor requests to shadow or on.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-22: Bills waiting for approval in Discord

  • Two new entries, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended, both in the system domain:
    • discord_connected, actor human: an owner or admin connected a Discord channel webhook from Settings, after Discord took a test message on it. It carries by, webhookId and channelId, Discord's ids, never the webhook's URL or token.
    • discord_disconnected: the workspace's Discord was disconnected. Actor human when an owner or admin chose Disconnect (via: "settings"); actor system when Discord answered that the webhook is gone (via: "discord"), with by null. It carries by, webhookId and via.
  • A cycle's journal has a new stage, discord, after slack, the last. It needs no other stage to have succeeded.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-22: An accountant's co-sign

  • A new entry, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended: accountant_cosign_changed, domain system, actor human, when an owner turns accountants' co-signing on or off. It carries by, from and to, each true or false.
  • approval_given carries cosign: true when the approval is an accountant's co-sign. A co-sign is one of a bill's two approvals and never the one that pays: the approval_paid entry that follows names it among its approvals.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-22: A vendor's statement checked

  • A new entry, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended: vendor_statement_checked, domain ap, actor human, when a person checks a vendor's statement of account against its bills. It carries by, counterpartyId, period ({ from, to }), currency, the numbers of lines, charges, payments, matchedCharges and matchedPayments, how many were missing, rejected, twice, differs, notCompared, paidNotListed, unknownPayments and notListed, and theirBalance and ourBalance. It never carries the statement or its lines.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-22: Arc mainnet pays vendors on Arbitrum

  • POST /api/v1/counterparties now accepts chain: "ARB" (Arbitrum One) for a vendor in a workspace on Arc mainnet, beside ARC and BASE. A contractor stays on Arc.
  • Counterparties, bills and their entries may name ARB wherever they name a payee's chain, as they name BASE: counterparty_address_changed, a CCTP payout's destinationChain, and a receipt's chain, whose transaction is the mint on Arbitrum.
  • The TypeScript SDK 0.3.6 accepts ARB for a counterparty's chain. Nothing else in /api/v1 or the webhooks changes.

2026-10-22: Receipts state the fees, who paid them and the invoice number

  • receipt_shared entries' receipt can now also carry invoiceNumber (the invoice's own number, as on its create_invoice entry), invoiceAmount (the invoice's amount, only when it was for more than was paid, as after an early-payment discount) and feesPaidBy: "sender" (every fee was paid by the business on top of the amount, and none taken from the payee's). Receipts shared before keep what they stated.
  • create_invoice entries now carry invoiceNumber for an invoice typed into the invoice form with one, or read from a document, an email, or in Telegram or Slack, as they already did for imports and captured drafts; for a captured draft, the number the person kept or typed. An accounting connector's bill keeps it under the provider's name.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-22: The weekly brief counts payee address changes

  • weekly_brief_sent now carries payees: { lockOn, changed, confirmed, held, asked, notMe, frozen } for the last 7 days: whether the payee lock is on, the addresses set and confirmed, the agent's decisions held for an address (guardrailRule counterparty.address_unconfirmed, counterparty.cooling_off or invoice.pay_to_differs), the payees' contacts asked "Was this you?" and those who answered not_me, and the payees frozen now. It is absent when they could not be read. A week with only these to tell now sends the brief, where before it sent none.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-22: "Was this you?" and frozen payees

  • Four new entries, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended, all in the compliance domain:
    • address_change_check_sent (actor system): the payee's billing email on file was asked whether they changed its address. It carries counterpartyId, checkId, from, to, via (member, payee_link or github) and contact: "notice_email", never the email itself.
    • address_change_answered (actor human, by: null, via: "address_check"): the payee answered. It carries counterpartyId, checkId, answer (me or not_me), from and to.
    • counterparty_frozen (actor system): a not_me answer froze the payee while the address in question was on file. It carries counterpartyId, checkId, address and reason: "address_change_disputed".
    • counterparty_unfrozen (actor human): an owner or admin unfroze the payee. It carries by, counterpartyId, checkId (the check that froze it) and note, how they checked. Whoever made the disputed change unfreezes it only when no other owner or admin can, and an unfreeze whose entry could not be written is undone, so every unfreeze has its entry.
  • A frozen payee's address is no longer confirmed, so the agent holds payments to it as for any address no one has confirmed (guardrailRule: "counterparty.address_unconfirmed"), until someone confirms it after it is unfrozen.
  • Nothing in /api/v1 request bodies or the webhooks' shapes changes.

2026-10-21: A screening verdict names the service that gave it

  • screen_counterparty, risk_level_changed and compliance_sweep can now carry source: "yente:self-hosted", and so can the screening history GET /api/v1/counterparties/{id} returns: the counterparty was screened by a self-hosted yente server the deployment names, rather than OpenSanctions' hosted API (opensanctions:yente, as before). Both are judged by the same rules.
  • Nothing in /api/v1 request bodies or the webhooks' shapes changes.

2026-10-21: A payment waits when its invoice asks to be paid somewhere else

  • A create_invoice entry for an invoice read from a document can carry document.payTo: the 0x address the document asked to be paid to.
  • An agent decision entry (ap_pay and the other ap_* actions) can now carry guardrailRule: "invoice.pay_to_differs": the payment was held because the invoice asked to be paid to an address that is not the counterparty's address on file. Its observed carries documentPayTo.
  • An ap_reconcile entry can now carry notResubmittedBecause: "invoice.pay_to_differs": a payment that never reached the network is not sent again while the invoice asks for another address. It is held for a person.
  • Once the counterparty's address on file is the one the invoice asked for, the follow-up reopens it: an invoice_reopened entry follows, with followUp.changes reading "the address on file is now the one the invoice asked to be paid to", then a new decision. A webhook endpoint receives each as ledger.appended.
  • Nothing in /api/v1 request bodies or the webhooks' shapes changes.

2026-10-21: Sanctioned payout addresses

  • screen_counterparty and risk_level_changed can carry source: "ofac-sdn" and matchedEntityId: "ofac-sdn-<entry>", and so can the screening history GET /api/v1/counterparties/{id} returns. The counterparty's payout address is on OFAC's SDN list, which decides a high-risk verdict whatever its name screens as.
  • A compliance_sweep entry carries sanctionedWallets ({ list: "ofac-sdn", from, readAt, addresses }): the list the payout addresses were checked against. from is live for the Treasury's files and snapshot for the copy bundled with the code.
  • Nothing in /api/v1 request bodies or the webhooks' shapes changes.

2026-10-21: A payment not sent again is decided again once what held it ends

  • A payable whose ap_reconcile entry carries notResubmittedBecause "counterparty.cooling_off", "counterparty.address_unconfirmed" or "counterparty.new_payee" is no longer held until a person acts. Once the payee lock's wait ends, someone confirms the address, or a second person stands behind it, the follow-up reopens it: an invoice_reopened entry follows, with followUp.changes reading "the payee lock's wait for the new address has ended", "the counterparty's new address has since been confirmed" or "a second person now stands behind the payee's address", then a new decision (ap_pay and the other ap_* actions). A webhook endpoint receives each as ledger.appended.
  • The payment the new decision makes is sent under the same payment key as the send that never reached Circle, so it is paid once.
  • Such an ap_reconcile entry can now carry earlierSendNotLookedUp: true: the earlier send was a payout to another chain, which cannot be looked up, so Circle may still hold it. That payable still waits for a person, as do payables agreed to in shadow mode.
  • Nothing in /api/v1 request bodies or the webhooks' shapes changes.

2026-10-21: A cycle when a payee lock's wait ends, and when the schedule missed a workspace

  • A cycle_complete entry's events can include payee_lock_wait_ended. The payee lock's wait on a confirmed address ended while a payable or a verified milestone was held back by it, and the due-work watch started the cycle, within about five minutes of the wait ending. The watch, not a person, started it, so its by is absent.
  • A cycle_complete entry's events can also include payee_lock_eased, when an owner turned the payee lock off or shortened its wait. That cycle decides again what the wait held back.
  • A scheduled cycle that the six-hourly schedule missed in a workspace now runs within about 20 minutes of its time. Its cycle_complete carries trigger: "schedule", as any scheduled cycle's does.
  • Nothing in /api/v1 request bodies or the webhooks' shapes changes.

2026-10-20: The payee lock

  • A new entry, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended: payee_lock_changed (domain system, actor human), when an owner turns the payee lock on or off or changes its wait. It carries by, from and to, each { on, coolingHours }.

  • counterparty_address_confirmed may now carry:

    • verification ({ method, contact, contactOnFileBefore, note }, where method is call, message, in_person or other): how the person checked the address;
    • payeeLock ({ coolingHours }), when the lock was on;
    • soloConfirmation: true, when whoever entered or asked for the address confirmed it because no one else could;
    • byGiver: true, when they confirmed it with the lock off;
    • lookalikeOf: the ids of other counterparties whose address is the same, or shares its first 6 and last 4 hex digits;
    • looksLikeEarlier: an address the same payee had or was paid at before that shares those digits with the new one;
    • giverUnknown: true, when the lock was on and no member could be named as having entered or asked for the address.

    Each field is present only when it applies.

  • An agent decision entry (ap_pay and the other ap_* actions) can now carry guardrailRule: "counterparty.cooling_off": the payment was held because the counterparty's address changed less than the payee lock's wait ago. Once the wait ends, an invoice_reopened entry's followUp.changes reads "the payee lock's wait for the new address has ended", and a new decision follows.

  • An ap_reconcile entry can now carry notResubmittedBecause: "counterparty.cooling_off": a payment that never reached the network is not sent again to a changed address inside the payee lock's wait. It is held for a person.

  • Nothing in /api/v1 request bodies or the webhooks' shapes changes.

  • A new entry, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended: payee_invoice_submitted (domain compliance, actor human), when a payee sends its invoice through a payee link that asks for one. It carries by: null, via: "payee_link", linkId, draftId (the draft waiting for review), counterpartyId, amount (a decimal string), currency ("USDC"), invoiceNumber and documentSha256 (the SHA-256 of the file sent, or null without one). No bill exists yet: one is added only when a member adds the draft.
  • A second new entry: counterparty_address_kept (domain compliance, actor human), when a payee keeps the address the workspace has on file through a payee link that asks for its invoice. It carries by: null, via: "payee_link", linkId, counterpartyId and address. Nothing changes on the counterparty.
  • counterparty_address_changed now carries chain, the chain the address is on (the workspace's own, ARC or ARC-TESTNET, when the counterparty has none recorded), and fromChain, the chain before, only when the payee chose another chain through its payee link. Choosing the workspace's own chain where none was recorded is no change of chain. counterparty_address_confirmed carries chain too.
  • payee_link_created may carry asksInvoice: true and offersChain: true, for a link made on Counterparties with those boxes ticked. A link made through POST /api/v1/payee-links carries neither, as before. A link made without them also carries closedInvoiceLinks (a count) when making it stopped earlier links of the same payee that were still waiting for their invoice.
  • payee_link_revoked carries invoiceOnly: true when Revoke stopped a used link from taking its payee's invoice, rather than revoking an unused link.
  • create_invoice for a bill added from a payee's invoice carries via: "payee_link", invoiceDraftId, invoiceNumber and payeeLinkId, where a draft from the Chrome extension carries via: "chrome".
  • POST /api/v1/payee-links and the SDK make links with both options off, as before. A new link, made there or anywhere, also stops an earlier link of the same payee that is still waiting for its invoice. Nothing else in /api/v1 or the webhooks changes.

2026-10-19: Pay a vendor on Base from your own wallet

  • A workspace paying from its owner's own wallet now pays a vendor on Base through version 2 of its spending limit contract. Its ap_pay for such a bill carries onChainLimit.covered: true and the contract's verdict, asked with the CCTP fee, where it was held before under guardrailRule: "workspace.onchain_limit_route". A version 2 contract that would refuse it holds it under "workspace.onchain_limit", as for a payment on Arc; a version 1 contract still holds it under "workspace.onchain_limit_route". payout and the reconcile entry's execution.destinationChain and mintTxHash are as for any payout to Base.
  • spending_limit_deployed now carries version (1 or 2), and, for an upgrade, replaces: the contract it is to replace.
  • Two new entries, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended, both in domain system, actor human:
    • spending_limit_upgraded, when version 2 takes over the agent's payments: by, from and to (the two contracts), version (2), agent, treasury, signer (wallet or passkey), dailyUsdc, weeklyUsdc, deployTxHash, approveTxHash, revokeTxHash (the passkey's one transaction, or null until a browser wallet revokes) and allowanceUsdc (null without a cap).
    • spending_limit_revoked, when the owner's wallet sets its approval of the replaced contract to 0: by, contract, replacedBy and txHash.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-19: Pay a vendor on Base from Arc mainnet

  • chain on a counterparty (POST /api/v1/counterparties and every response that carries it) may now be BASE: a vendor's address on Base, in a workspace on Arc mainnet. As on Arc testnet, only a vendor can be on another chain, and only a chain the workspace's network pays on is accepted (BASE on Arc mainnet; BASE-SEPOLIA, ARB-SEPOLIA or ETH-SEPOLIA on Arc testnet).
  • POST /api/v1/milestones now refuses a contractorId whose counterparty is paid on another chain, on either network, with invalid_request and "contractorId: This vendor is paid on another chain, and a milestone is paid on the workspace's own chain only. Add the work as an invoice instead." A milestone is released on the workspace's own chain, so such a payee would have been sent USDC there.
  • Such a payout is recorded like one from Arc testnet: ap_pay carries payout: { chain: "BASE", route: "cctp", domain: 6, feeUsdc, quotes }, and the payment's reconcile entry carries execution.destinationChain: "BASE" and mintTxHash, the mint on Base. It is paid only from a workspace on its own Circle account; a workspace paying from its own wallet holds it for a person, as before.
  • The TypeScript SDK 0.3.5 accepts BASE for a counterparty's chain. Nothing else in /api/v1 or the webhooks changes.

2026-10-19: A reminder when a workspace stops

  • Two new entries, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended, both in domain system, actor system:
    • activation_nudge_sent, signed just before a setup reminder goes, with stage (first_bill: no real bill a day after the workspace was opened; first_verdict: in shadow mode, no verdict three days after the agent's first decision on a real bill), recipients (how many it goes to), and days and shadow for first_bill, or waiting (decisions still to give a verdict on) for first_verdict. Each stage goes once per workspace.
    • activation_nudge_failed, when no email went after all, with stage and failed; the reminder is then tried again, up to three tries in all.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-19: Where an invitation came from

  • member_invited may now carry via: console_nudge for an invitation an owner or admin sent from Treasury's Bring in a second person, and weekly_brief for one sent from Members after following the weekly summary's link. An invitation sent any other way has no via, as before; by, invitationId and role are unchanged.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-18: Ask every payee for an address at once

  • A new entry, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended: payee_addresses_requested (domain compliance, actor human), when an owner or admin asks every payee with no address of its own at once. It carries by (their user id), links (each { counterpartyId, linkId, emailed }, emailed saying whether the link went to the payee's notice email) and notMade (the counterparty ids whose link could not be made). Each link also has its own payee_link_created entry, as before.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-18: Start the live slice from shadow mode

  • A new entry, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended: live_slice_started (domain system, actor human), in a workspace in shadow mode, when an owner opens a workspace on Arc mainnet from it. It carries by (their user id), liveOrgId and liveSlug (the new workspace), vendors (each { counterpartyId, name, address }, where address says how its address went over: own, carried; mirror, other_chain, unconfirmed or none, not carried) and skipped (each vendor left behind, { counterpartyId, name, reason }, where reason is no_limit, not_valid or not_added).
  • In the new workspace, each vendor's create_counterparty carries via: "live_slice", fromOrgId, fromCounterpartyId and addressNeedsConfirmation. A carried address waits for a member's confirmation, as one added through the API does.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-18: A person's order for which bill first

  • cash_priority_set may now be signed by a member (actor human), when an owner, admin or approver sets the order from the payment plan. It then carries decisionMode: "person", by (their user id), previousOrder (the invoice ids in the order it replaced, or null), and reasoning saying a person set it; order, cash, fingerprint, referenceOrder and agreedWithReference are as before. While the same bills compete, the agent applies that order and signs no new one.
  • When bills leave a person's order (paid, or past the window) and the rest are unchanged, the agent signs cash_priority_set again for the bills still due, actor agent, with decisionMode: "person", the same by, and carried: true.
  • An AP decision on a bill in a person's order carries cashPriority: { waits, reason: null, fingerprint, byPerson: true }, whether it is kept or waits.
  • invoice_reopened for a bill a person's order keeps says so in its summary and followUp.changes: "a person chose to pay it first".
  • Nothing else in /api/v1 or the webhooks changes.
  • Two new entries, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended, both in domain ap, actor human:
    • supplier_status_shared, when an owner or admin makes a supplier's payment status link: by (their user id), linkId, counterpartyId, expiresAt, days (7, 30 or 90) and replaced (the ids of the supplier's links it stopped). The link itself is never in the entry.
    • supplier_status_unshared, when one is stopped: by, linkId and counterpartyId.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-18: Which bill first when the cash cannot cover them all

  • A new entry, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended: cash_priority_set (domain ap, actor agent), when the bills due within 14 days add up to more than the cash and the agent chooses the order they are paid in. It carries fingerprint, cash: { operating, reserve, committed, available }, order (each bill, most important first: { invoiceId, payee, amount, dueOn, keep, reason }), reasoning, decisionMode, referenceOrder (the written policy's, as invoice ids), agreedWithReference, and orderCorrected: true when code fixed the model's order. It is signed again only when the bills change, or the cash changes enough to split them differently.
  • invoice_reopened may carry followUp.reason: "cash_priority", for a bill held for want of cash that the agent chose to pay first.
  • An AP decision on a bill in the plan carries cashPriority: { waits, reason, fingerprint }, and timingRule may be "cash.priority" when code turned the model's pay or schedule on a waiting bill into a hold; such a hold has execution.heldBecause: "cash_shortfall", and its cashNeededUsdc is its own amount plus the kept bills'.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-18: The weekly brief in shadow mode

  • In a workspace in shadow mode, weekly_brief_sent now carries shadow: { verdicts: { given, agreed }, sinceStart: { given, agreed, since } }, the verdicts given in the week and since shadow mode began, and short is always null: the wallet only mirrors agreed payments. Such a workspace now gets the brief, where before it got none. Nothing else in /api/v1 or the webhooks changes.

2026-10-18: The agent's weekly brief

  • Two new entries, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended, both in domain system, actor system:
    • weekly_brief_sent, signed just before the emails go, with week (2026-W43), recipients (how many it goes to), paid: { count, usdc }, received: { count, usdc }, decisions, waiting, next7: { count, usdc, expectedUsdc } and short (the cash shortfall, or null). One a member sent to themselves from Settings also carries preview: true and by, their user id.
    • weekly_brief_failed, when no email went after all, with week and failed; the week's brief is then tried again.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-17: The agent tells you before the cash runs short

  • Two new entries, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended, both in domain treasury, actor agent:
    • cash_short_ahead, when the wallet will run short within 30 days: shortOn (the first short day, YYYY-MM-DD) and shortBy, lowestOn and need (the shortest day and what it needs to pay everything due through it), expectedBy (receivables expected by then, not counted) and coveredWithExpected, cash: { operating, reserve }, and doing: { heldForCash: { count, total }, termRequestsOpen, customerDiscountsOpen }, each null when it could not be read. Signed again only when shortOn comes earlier, need grows by at least 1 USDC and a tenth, or 7 days pass.
    • cash_short_cleared, once the wallet no longer runs short after an alert, with previous: the last alert's detail.
  • A cycle's journal has a new stage, cash_alert, after term_requests. It runs only when reconcile completed. Nothing else in /api/v1 or the webhooks changes.

2026-10-17: Scheduled payments checked against the cash ahead

  • An AP decision made before a scheduled bill's day, because the cash will no longer cover it then, carries cashAhead: { scheduledFor, cashCounted, dueBefore: { total, count }, needed }. Such an entry is usually ap_hold with execution.heldBecause: "cash_shortfall".
  • timingRule may be "pay.cash_ahead": the model chose to pay such a bill now, and code held it, since paying it would take the cash the bills before it count on.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-17: Suppliers counter the agent's requests for more time

  • On a request for more time, a supplier may propose fewer days, and the agent answers it. New entries, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended, all in domain ap:
    • term_request_countered (actor system, via: "terms_link"), with requestId, invoiceId, counterDays and days.
    • term_counter_accepted and term_counter_declined (actor agent), with requestId, invoiceId, counterpartyId, days, counterDays, decision: { action: "accept" | "decline", reasoning }, referenceDecision, decisionMode, agreedWithReference and supplierTold. An acceptance also carries newDueDate; a counter the bill changed under carries billChanged: true. decisionMode is code when the bill was being paid and no model was asked.
  • An accepted counter moves the invoice's dueDate by counterDays and returns the payable to pending. Nothing else in /api/v1 or the webhooks changes.

2026-10-17: Requests for more time withdrawn when no longer needed

  • term_request_withdrawn may now carry reason: "paid", when the bill is being paid, or reason: "not_needed", when it is no longer held for want of cash, beside "not_emailed". These carry counterpartyId, days, supplierTold (whether the supplier was emailed that the request is withdrawn) and to (the address, masked). Nothing else in /api/v1 or the webhooks changes.

2026-10-17: The agent asks suppliers for more time

  • An owner or admin can let the agent ask a supplier for more time on a bill held for want of cash. Each step is a new entry, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • term_requests_on (domain ap, actor human), with maxDays and by, and term_requests_off, with by.
    • term_request_sent (actor agent, via: "agent"), with requestId, invoiceId, counterpartyId, to (the supplier's address, masked), days, amount, currency, dueDate, newDueDate, expiresAt, decision: { action: "ask", days, reasoning }, referenceDecision, decisionMode and agreedWithReference; daysLimited: { chosen, sent } when code kept the days within their bounds, and sandbox: true in a sandbox.
    • term_request_skipped (actor agent), with invoiceId, counterpartyId, decision: { action: "skip", reasoning }, referenceDecision, decisionMode and agreedWithReference.
    • term_request_withdrawn (actor agent, via: "agent", reason: "not_emailed"), with requestId and invoiceId, when a request could not be emailed.
    • term_request_accepted and term_request_declined (actor system, via: "terms_link"), with requestId and invoiceId; an acceptance also carries days and newDueDate.
  • An accepted request moves the invoice's dueDate to the new date and returns the payable from held to pending, as GET /api/v1/invoices shows it. The agent's next decision on it, an ap_… entry as before, weighs the new date. Nothing else in /api/v1 or the webhooks changes.

2026-10-17: The agent offers customers a discount to pay early

  • An owner or admin can let the agent offer customers a discount for paying an open receivable early while bills are held for want of cash. New entries, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended, all in domain ar:
    • customer_offers_on (actor human), with maxPct and by, and customer_offers_off, with by.
    • customer_discount_offered (actor agent), with offerId, invoiceId, counterpartyId, to (the customer's address, masked), discountPct, amount, offeredAmount, currency, payBy, daysEarly, shortfall, decision: { action: "offer", pct, reasoning }, referenceDecision, decisionMode, agreedWithReference, and pctLimited: { chosen, sent } when code kept the discount within its bounds.
    • customer_discount_skipped (actor agent), with invoiceId, counterpartyId, daysEarly, shortfall, decision: { action: "skip", reasoning }, referenceDecision, decisionMode and agreedWithReference.
    • customer_discount_withdrawn (actor agent), with offerId, invoiceId and reason: "not_emailed".
    • customer_discount_accepted and customer_discount_declined (actor system, via: "discount_link"), with offerId and invoiceId; an acceptance also carries discountPct, offeredAmount, payBy and currency.
    • customer_discount_taken (actor agent), with invoiceId, counterpartyId, offerId, amount, received, discountPct, discount (what it cost), payBy, currency and txHash, after the receivable was paid at the discount.
  • An accepted offer sets the receivable's earlyPayDiscount to the offer's, the deadline being its pay-by day; its amount does not change. Its ar_received entry, when paid at the discount, carries atDiscount: true and the amount received. A discount set on a receivable any other way still changes nothing about what pays it. Nothing else in /api/v1 or the webhooks changes.

2026-10-17: The agent's early-payment offers in a sandbox

  • In a sandbox, the agent now makes early-payment offers, sent to the member who turned them on in place of the sample supplier. Its early_payment_offered entry there carries sandbox: true, and to is that member's address, masked. Nothing else in /api/v1 or the webhooks changes.

2026-10-17: The agent withdraws offers the cash no longer covers

  • early_payment_offer_withdrawn may now come from the agent with via: "agent" and reason: "cash". It carries offerId, invoiceId, offeredAmount, and covering: the operating USDC left after the cycle's payments, less what falls due in 7 days. The agent sends it when that cash no longer covers every open offer, and withdraws its own offers, the largest first. Nothing else in /api/v1 or the webhooks changes.

2026-10-17: A payment now that gains nothing waits for its day

  • An ap_schedule entry may carry a new value of timingRule, pay.no_gain. The model answered pay for a payable that gains nothing by being paid today: no early-payment discount available, no shortfall, a due date ahead, and not already set for today. Code scheduled it for the policy's day, its due date, instead. The entry's decision is { action: "schedule", payOn }, and its reasoning ends with a note that says so. Nothing else in /api/v1 or the webhooks changes.

2026-10-17: Suppliers counter the agent's early-payment offers

  • On an offer the agent made, a supplier may propose a smaller discount, and the agent answers it. Each step is a new entry, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • early_payment_offer_countered (domain ap, actor system, via: "offer_link"), with offerId, invoiceId, counterPct, discountPct and currency.
    • early_payment_counter_accepted and early_payment_counter_declined (actor agent), with offerId, invoiceId, counterpartyId, discountPct, counterPct, decision: { action: "accept" | "decline", reasoning }, referenceDecision, decisionMode and agreedWithReference. An acceptance also carries offeredAmount; a counter the bill changed under carries billChanged: true. decisionMode is code when code declined it without asking a model.
  • An accepted counter sets the invoice's earlyPayDiscount to the counter, the deadline being today (UTC), and returns the payable to pending; the agent's next ap_… entry weighs it as before.

2026-10-16: The agent makes early-payment offers

  • An owner or admin can let the agent make early-payment offers itself. New entries, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • early_offers_on (domain ap, actor human), with maxPct and by, and early_offers_off, with by.
    • early_payment_offered with actor agent and via: "agent". Beside the fields a person's offer carries (but by), it has to (the supplier's address, masked), daysEarly, decision: { action: "offer", pct, reasoning }, referenceDecision, decisionMode and agreedWithReference, and pctLimited: { chosen, sent } when code kept the discount within its bounds.
    • early_payment_offer_skipped (actor agent), with invoiceId, counterpartyId, daysEarly, decision: { action: "skip", reasoning }, referenceDecision, decisionMode and agreedWithReference.
    • early_payment_offer_withdrawn with via: "agent" and reason: "not_emailed", when an offer the agent made could not be emailed.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-16: Early-payment offers

  • An owner or admin can offer a supplier payment today for a discount, through a one-time link the supplier answers with no account. Each step is a new entry, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • early_payment_offered (domain ap, actor human), with offerId, invoiceId, counterpartyId, discountPct, amount, offeredAmount, currency, expiresAt and by.
    • early_payment_offer_accepted and early_payment_offer_declined (actor system, via: "offer_link"), with offerId and invoiceId; an acceptance also carries discountPct, offeredAmount and currency.
    • early_payment_offer_withdrawn, with offerId and by.
  • An accepted offer sets the invoice's earlyPayDiscount to { percent, deadline }, the deadline being today (UTC), and returns a scheduled payable to pending, as GET /api/v1/invoices shows it. The agent's next decision on it, an ap_… entry as before, weighs that discount like any other. Nothing else in /api/v1 or the webhooks changes.

2026-10-16: Bills paid to a vendor's bank account in Mexico

  • An owner can set a workspace up for bank payouts through BlindPay, and an owner or admin can give a vendor a bank account in Mexico, whose bills are then paid in pesos over SPEI from the workspace's USDC. Each change is a new entry, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • bank_payouts_set_up (domain treasury), with provider: "blindpay", customerId and tosId (BlindPay's ids), kybStatus and by.
    • counterparty_bank_account_set (domain compliance), with counterpartyId, provider: "blindpay", bankAccountId (BlindPay's id), rail: "spei", bankCode (the CLABE's first three digits), last4 and status. When the account is removed, bankAccountId is null. The whole CLABE is never in an entry.
    • bank_payouts_test_token_minted (domain treasury), on Arc testnet only: BlindPay's test token minted to the operating wallet, with token: "USDB", contract, amount, txHash, status and by.
  • The agent's decision on a bill of such a vendor carries paidToBank: true, and a payment it would make is held with guardrailBlocked: true and a new value of guardrailRule, payout.bank_needs_person: a person approves every bank payout. On Arc testnet, where BlindPay takes its test token USDB, such a bill is timed against the operating wallet's USDB: a hold for want of it carries no heldBecause: "cash_shortfall", cashNeededUsdc or cashSeen, since USDC coming in does not cover it.
  • A person's approval_paid entry for one carries payout: { route: "bank", provider: "blindpay", quoteId, payoutId, receiverAmount, currency: "MXN", rate, feesSender, network, token, rail: "spei", bankAccount: { bankCode, last4 } }, BlindPay's quote and payout. The payment is confirmed once BlindPay says the payout completed. Nothing else in /api/v1 or the webhooks changes.

2026-10-16: Deals brought in from Zoho CRM

  • An owner or admin can connect a workspace to a Zoho CRM organization, and a person plans the collections of the won deals it brings in. There is no new kind of entry: the entries HubSpot's and Pipedrive's deals use (below) now also name Zoho CRM. Each is listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • accounting_connected and accounting_disconnected with provider: "zohocrm"; externalOrgId is the Zoho CRM organization id and externalOrgName its name. accounting_connected carries consent.version zohocrm-2026-10-16, and scopes ZohoCRM.modules.deals.READ, ZohoCRM.modules.accounts.READ, ZohoCRM.modules.contacts.READ, ZohoCRM.org.READ, ZohoCRM.settings.layouts.READ and ZohoCRM.settings.pipeline.READ, all read only. Several workspaces may connect the same organization, each with its own connection.
    • deal_signed, for a deal planned from Zoho CRM, and deal_revised, for a change saved from what Zoho CRM changed, with via: "zohocrm" and zohocrm: { organizationId, dealId, accountId }: the organization id, the deal's id and the id of the account it was sold to, in Zoho CRM. The deal's externalRef is zohocrm- followed by Zoho CRM's deal id.
    • create_counterparty, for a customer added with such a deal, and counterparty_notice_email_changed, for a billing email filled from Zoho CRM, with via: "zohocrm" and zohocrm: { organizationId, accountId }; the addresses are masked, as before.
    • crm_deal_changed and crm_deal_change_kept with provider: "zohocrm"; crmDealId is Zoho CRM's deal id, without the zohocrm- prefix. A stage change's label is the stage's name in Zoho CRM.
  • Nothing is written to Zoho CRM, so a Zoho CRM connection writes no crm_receipt_ entries. Nothing else in /api/v1 or the webhooks changes: the Zoho CRM deals not planned are not in the API.

2026-10-16: Bills brought in from Zoho Books

  • An owner or admin can connect a workspace to a Zoho Books organization, and a person adds the bills it brings in from Bills & receivables. Its connection writes the entries Xero's and QuickBooks' write (below), each sent to webhook endpoints as ledger.appended and listed by GET /api/v1/ledger, with provider: "zohobooks": accounting_connected, accounting_disconnected, accounting_bill_closed and accounting_bills_dismissed. externalOrgId is the Zoho Books organization id, externalOrgName its name, and billId and billIds are Zoho Books bill ids.
  • accounting_connected carries consent.version zohobooks-2026-10-16, and scopes ZohoBooks.bills.READ, ZohoBooks.contacts.READ and ZohoBooks.settings.READ, all read only. Several workspaces may connect the same organization, each with its own connection.
  • accounting_bill_closed comes when a bill already added is paid or voided in Zoho Books, with sourceStatus paid or voided, never deleted: Zoho Books does not say when a bill is deleted.
  • A bill added from Zoho Books is a create_invoice entry with via: "zohobooks" and zohobooks: { tenantId, billId, contactId, invoiceNumber }: the organization id, the bill's id, its vendor's id and its number in Zoho Books. A vendor added with it is a create_counterparty entry with via: "zohobooks" and zohobooks: { tenantId, contactId }. A bill partly paid in Zoho Books is added at what is left to pay.
  • Nothing is booked in Zoho Books, so a Zoho Books connection writes no accounting_payment_account_chosen and no accounting_payment_ entries. Nothing else in /api/v1 or the webhooks changes.

2026-10-15: A release Circle took is recorded in the cycle that finds it

  • When the agent finds on Circle a batch whose answer was lost, while reconciling one of its milestones, Circle's transaction is recorded on every member at once. The batch's other milestones, reconciled later in the same cycle, now get a milestone_reconcile entry with reconciled: true and their execution.resultingStatus ("paid" once confirmed). They used to get one with reconciled: false and reconcileError: "another request is settling this payment's send right now; it is reconciled next cycle", and were recorded paid only on the next cycle. The same holds for any payment whose send another lookup recorded after the cycle read it.
  • A release from an escrow hold already sent is now only read and recorded, and the hold is marked released once Circle confirms it, even when the hold pays an address that is no longer the contractor's: the release went where the hold pays. Its milestone_reconcile entry has reconciled: true and execution.resultingStatus: "paid". It used to get, every cycle, one with reconciled: false, execution.resultingStatus: "verified" and a reconcileError saying to refund the hold and pay again, though the release had gone out. A person's Pay now that only checks such a release records it the same way. Only a new release from such a hold is held for a person, as before.
  • A webhook endpoint receives these entries as ledger.appended, as before. Nothing else in /api/v1 or the webhooks changes.

2026-10-15: A reconcile looks for an unanswered send before it holds one

  • The agent now looks a payment's earlier send up at Circle before anything would hold it or decide it again, when that send's answer was lost: a claim that went stale with no Circle id, and a send recorded failed because Circle never answered it (the call ran out of time, Circle answered 5xx or with no id). When Circle had taken the transfer, the payment gets an ap_reconcile or milestone_reconcile entry with reconciled: true and execution.resultingStatus "paid" (or still "matched", "verified" for a milestone). Before, a stale claim's entry could carry notResubmittedBecause ("counterparty.high_risk", "counterparty.new_payee", "workspace.two_approvals") with execution.resultingStatus: "held", and a failed send was decided again, so its entry was a decision (ap_…, milestone_…) about a payment that had already moved. A webhook endpoint receives each as ledger.appended, as before.
  • When Circle has not listed the send yet, could not be asked, or another request is settling it, the entry has reconciled: false, reconcileError saying which (for example "Circle has not listed this payment's earlier send yet; it is looked for again from 10:15 UTC, and sent again only if Circle has none"), and execution.resultingStatus "matched" ("verified" for a milestone): the payment's status does not change, and the next cycle looks again. This is the shape a reconcile that could not read a transfer already had.
  • When Circle never took it, a stale claim is checked and sent again, as before, and a failed send is decided again: its entry is that decision. For a bill, that decision is as before. A milestone release decided again this way is now weighed against the operating wallet's cash, as any new release is, and can be held with execution.heldBecause: "cash_shortfall". This corrects the 2026-10-06 entry "A milestone release waits for its cash", which said a release whose last send Circle never answered is not held for cash: that holds only until Circle is known never to have taken it, and one Circle took is reconciled, never decided again.
  • A payout to another chain cannot be looked up by its reference. A stale claim's is checked before it is asked for again under its payment key, so its entry can still carry notResubmittedBecause and "held" while Circle may hold the transfer; a failed one's is decided again, as before.
  • With no operating account to look from, such a payment gets no entry: it stays matched (verified), as a transfer already sent does.
  • So notResubmittedBecause is now recorded only once Circle has no transfer for the earlier send, or for a payout to another chain. Nothing else in /api/v1 or the webhooks changes.

2026-10-15: A payment sent again is held when it would be a new payee's first

  • An ap_reconcile or milestone_reconcile entry can now carry notResubmittedBecause: "counterparty.new_payee", with execution.resultingStatus: "held". This is a payment whose earlier send's outcome was never recorded: no Circle transaction id was kept for it. Before, the agent looked that send up at Circle and, if Circle had none, sent the payment again to the payee's address as it stands now. Now, when sending it again would be the first payment to that payee at that address with two different people not behind it, the agent holds it for a person instead: once Circle has none (the entry above: the send is looked up first), or, for a payout to another chain, which cannot be looked up this way, before it is asked for again. A webhook endpoint receives that entry as ledger.appended, in place of one recording the new send.
  • A person's Approve and pay, or Pay now on a milestone, looks the earlier send up at Circle first: a transfer Circle took is recorded as it stands, and nothing new is sent until Circle has answered.
  • Such an entry also carries the hold as a decision records it: guardrailBlocked: true, guardrailRule: "counterparty.new_payee", and newPayee, the same { addressBy, linkCreatedBy?, bountyBy?, confirmedBy, unanswered?, twoParties } a decision records as observed.newPayee. It still carries no observed.
  • A transfer recorded with its Circle transaction id is only read, and its reconcile entry is unchanged. Nothing else in /api/v1 or the webhooks changes.

2026-10-15: Who asked for a payee's address counts as having given it

  • The member who created a payee link, in the console or with Create a payee link (the member who issued the key), now counts as having given the address the payee sends through it. When that member is also the only one who confirmed the address, the agent holds the first payment to it with the rule counterparty.new_payee (guardrailBlocked: true, execution.resultingStatus: "held"), where it used to pay it. A webhook endpoint then receives that hold's entry as ledger.appended, in place of a payment's. When another member confirmed the address, the agent pays it as before.
  • That member is read from the link's signed payee_link_created entry, so deleting their account changes nothing; only when that entry is missing is the link's own record read.
  • For an address sent with /payto on GitHub, and for any address no member can be named as having given, no confirmation counts as the second person: the agent always holds its first payment as counterparty.new_payee, where it used to pay one a member confirmed. The decision records observed.newPayee.unanswered: true, and its reasoning says one member confirms the address and a different one approves it. A bounty typed by its pull request's own author names no member.
  • A first payment is now the first to that payee at that address. An address the workspace has paid for another counterparty no longer lets the agent skip the second person for this one, so a first payment it used to make on its own may be held as counterparty.new_payee.
  • A decision on the first payment to an address a member asked for records observed.newPayee.linkCreatedBy (a payee link) or observed.newPayee.bountyBy (the member a GitHub bounty acts as), beside addressBy: "payee", confirmedBy and twoParties. Each is absent for an address given any other way, and when no member can be named.
  • approval_paid and milestone_approval_paid gain addressGiverApproved: true, and their summary a note, when the workspace's only approver made a first payment to an address no other member stands behind: one they gave, asked for or confirmed, or one no one else confirmed.
  • Nothing else in /api/v1 or the webhooks changes. POST /api/v1/payee-links takes and answers the same.

2026-10-15: Invoices captured with the Chrome extension

  • An owner or admin can capture invoices with the Chrome extension Vestiarion Invoice Capture, as drafts that an owner or admin then adds as bills in the console. Five new entries, each listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • extension_connected, actor human, domain system: { by, connectionId, client, scopes }, when a member allowed the extension. client is the Chrome extension's id; scopes are invoice_draft:create and invoice_draft:read or one of them. No token is ever recorded.
    • extension_disconnected, actor human, domain system: { by, connectionId, client, reason }. reason is extension (its own Disconnect), settings (Disconnect in Settings, by naming who), reused_code (a one-time code was used twice, so the connection it made was ended), reused_refresh (a refresh token was used again after it was replaced, or twice at once), role_changed (the member's role can no longer add bills), or, when the membership ended and its connections with it, member_removed (by naming who removed them), member_left or account_deleted. by is null for reused_code, reused_refresh and role_changed.
    • invoice_draft_captured, actor human, domain ap: { by, draftId, source, document, connectionId }, when a draft was sent for review. source is selection or file; document is { kind, sha256 }, kind being pdf, email, text or image, or null. The fields and the captured text are never in it.
    • invoice_draft_confirmed, actor human, domain ap: { by, draftId, invoiceId }, after the bill's own create_invoice; in the rare case the bill was written and its create_invoice entry was not, this entry still links the draft to it.
    • invoice_draft_discarded, actor human, domain ap: { by, draftId }.
  • A create_invoice entry for a bill added from a captured draft names via: "chrome", invoiceDraftId and, when one was read, invoiceNumber, with document as one added from a document carries it.
  • Nothing changes in /api/v1: a draft is not an invoice, and GET /api/v1/invoices lists a captured invoice only once a person added it. The extension's own endpoints, under /api/extension/v1, take only its tokens; they are not part of this API, and an extension token is refused by /api/v1 and the MCP server.
  • Any new connection or reconnection of Xero, QuickBooks, HubSpot or Pipedrive now carries consent.version xero-2026-10-15, quickbooks-2026-10-15, hubspot-2026-10-15 or pipedrive-2026-10-15 in its accounting_connected entry, with reconnected: true on a reconnect. That includes the reconnects behind Allow Vestiarion to book payments and Allow writing to HubSpot. The new words say the agent's model provider sees a bill's facts, or may see a deal's, under that provider's own API terms, where the earlier versions promised it would not train on them; Pipedrive's also says disconnecting revokes Vestiarion's access, which, as Pipedrive documents it, uninstalls the app. Asana's stays asana-2026-10-14.
  • An existing connection keeps the version it agreed to, on the connection and in its entries, until it reconnects. accounting_payment_approved may name an accountant in by on a Xero connection agreed under xero-2026-10-13 or xero-2026-10-15.
  • The version recorded is the one the connect page showed. A page loaded before the words changed is sent back to be read again, and nothing is recorded until the person agrees to the current words.
  • Nothing else in /api/v1 or the webhooks changes.

2026-10-15: Postman collections, and the MCP server described for the MCP Registry

  • Two Postman collections and an environment, generated from the OpenAPI document and served under https://www.vestiarion.xyz/postman/. "Vestiarion: Getting Started" goes from a key to a first 200, then adds a counterparty, at a wallet you set, and an invoice for it. "Vestiarion API reference" has every operation, with a saved example of its success and of each error it documents. Both authenticate with {{apiKey}} from the environment, and no file holds a key. Use Vestiarion from Postman says how to import them. They call the endpoints as they are: no endpoint changes.
  • Both collections are also in a public Postman workspace, Vestiarion API, to fork or watch. Its copy is updated by hand after an API change, so importing by link from the site still always gets the latest version; see From the public workspace.
  • The example answer of Create a payee link, on its reference page and in /api/v1/openapi.json, now shows an invented token in url in place of a real, expired one. The answer's shape is unchanged.
  • server.json, at the repository root, describes the MCP server at https://www.vestiarion.xyz/api/mcp for the official MCP Registry, as io.github.duongnq2798/vestiarion, with the API key as a required, secret Authorization header. The server, its tools and how they authenticate are unchanged. The MCP page now says which key to use: a read-only key by default, a read-and-write key for an agent that should add records.
  • The MCP server is listed in the official MCP Registry as io.github.duongnq2798/vestiarion, version 1.0.0, so a client that reads the registry can find it. It still needs a workspace API key as the bearer token, read-only by default; see In the MCP Registry.
  • Nothing else in /api/v1, the MCP server or the webhooks changes.

2026-10-14: Status says unavailable while payments are switched off

  • GET /api/v1/status now answers provenance.payments: "unavailable", and provenance.yield: "unavailable", while payments are switched off for every workspace on the deployment, or while whether they are could not be read. Before, it answered the workspace's chain mode, live or simulate, although nothing was paid. The other reasons for unavailable are unchanged; see Get status.
  • A shadow-mode workspace still answers its chain mode: a payment a person agrees to is paid as provenance.payments says.
  • Each approval_returned entry may now carry reason, the line a person gave when they returned a bill to the agent, as approval_rejected already could. It is absent when none was given.
  • A decision_verdict entry for a disagreement may now carry reason: null: a reason is asked for, and no longer required.
  • Nothing else in /api/v1 or the webhooks changes. The TypeScript SDK 0.3.4 describes the new reason for unavailable in provenance's comment; its types are unchanged.

2026-10-14: Commissions on money received

  • An owner or admin can set a commission plan for a vendor or contractor, which earns a commission on customer money applied to the invoices of the deals the plan covers, and turn what a partner is due into a payable. Five new entries, domain ap, each listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended. Amounts are decimal numbers in the line's currency, USDC or EURC; rates are in basis points (1250 is 12.5%) and as ratePercent, such as "12.5%".
    • commission_plan_set, actor human: { by, planId, replaces, beneficiaryId, beneficiaryName, beneficiaryMember, rateBps, ratePercent, basis, scope, dealIds, holdDays, reference, startedAt }. basis is net (money that arrived on Arc) or gross (also a difference recorded as a fee on the invoice); scope is all_deals or chosen_deals, with dealIds for the latter. replaces is the version this one ended, or null. beneficiaryMember is the user id of the member who is this partner, or null.
    • commission_plan_ended, actor human: { by, planId, beneficiaryId, beneficiaryName, endedAt }.
    • commission_accrued, actor agent: { lineId, planId, beneficiaryId, receivableId, dealId, source, allocationId, transferId, base, rateBps, ratePercent, basis, amount, currency, appliedAt, dueAt, formula }, once for each payment applied to a receivable of a covered deal. source is payment (a payment applied, part or all), fee (a fee recorded on the invoice, gross only) or whole_match (a transfer matched to the invoice in full, with no allocationId). amount is base times the rate, rounded down to the millionth; dueAt is appliedAt plus the plan's hold window. The receivable is named receivableId, never invoiceId.
    • commission_adjusted, actor agent: { lineId, adjusts, planId, beneficiaryId, receivableId, dealId, source, reversalId, transferId, amount, currency, appliedAt, dueAt, carriedForward, reason }, when the money a commission was earned on was taken back off the receivable. amount is minus the adjusted commission's; reason is allocation_reversed (reversalId names the reversal) or whole_match_released; carriedForward is true when the commission was already in a payable, so it comes off the next one.
    • commission_payable_created, actor human: { by, payoutId, statement, payableId, beneficiaryId, beneficiaryName, amount, currency, lineIds, accrued, adjusted }. The payable's own create_invoice entry comes first, with via: "commission", commission: { payoutId, statement } and the statement number, such as CS-7F3A21C9, as its poReference.
  • A commission payable is a payable like any other in GET /api/v1/invoices, and the agent's ap_pay, ap_schedule and ap_hold entries decide it as any bill. A person's approval of it by the member named as the partner is refused; there is no new approval_* entry.
  • Nothing else in /api/v1 changes: plans and commissions are not in the API.

2026-10-14: Contractor work accepted from Asana

  • A milestone's verificationMethod may now be asana, in GET /api/v1/milestones and on its own page: the work was accepted by a person against the milestone's acceptance criteria once its Asana task was completed. Its verificationDetail is { note, asanaTask, taskGid, completedAt, fingerprint, criteriaSha256, acceptedBy }; once an acceptance is taken back it also carries heldReason and heldAt, verified is false, verificationStatus is unverified and status is pending again. The TypeScript SDK 0.3.3 accepts the value.
  • Six new entries, domain contractor, each listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • asana_task_linked, actor human: { by, milestoneId, linkId, taskGid, workspaceGid, projectGid, taskUrl, completed, fingerprint }.
    • asana_task_unlinked, actor human: { by, milestoneId, linkId, taskGid, withdrewAcceptance }.
    • milestone_criteria_set, actor human: { by, milestoneId, criteria, criteriaSha256, previousSha256 }. previousSha256 is null the first time.
    • asana_task_ready, actor system: { milestoneId, linkId, taskGid, completedAt, completedByName, fingerprint, deliverables }, when a linked task is completed in Asana and the milestone has criteria. It verifies nothing: deliverables is a count.
    • milestone_accepted, actor human: { by, milestoneId, linkId, taskGid, taskUrl, completedAt, completedByName, fingerprint, deliverables, criteriaSha256, payeeAsanaMapped }, when a person accepted the work. deliverables lists each { kind, label, href } accepted, kind being attachment, link or comment_link; fingerprint is the SHA-256 of that set.
    • milestone_acceptance_withdrawn, actor system: { milestoneId, linkId, taskGid, reason, afterPayment, acceptedFingerprint, fingerprint, completed, completedAt }, when the task was reopened, its deliverables changed or Asana no longer showed it after the work was accepted. reason is reopened, deliverable_changed or task_unreachable. With afterPayment: false the milestone lost its verification before any payment; with afterPayment: true a payment was already sent, and is not taken back.
  • A new Asana connection's accounting_connected carries provider: "asana" and consent.version asana-2026-10-14; its externalOrgId is the Asana user who connected.
  • Nothing else in /api/v1 changes: a milestone is not linked to an Asana task through the API, and the write API still adds a milestone pending.

2026-10-14: A command-line interface over the API

  • @vestiarion/cli 0.1.0, the vestiarion command, calls /api/v1 with a workspace API key, through the TypeScript SDK. Each command is one or two existing operations; the CLI page maps each command to its operation. It adds no endpoint and changes none.
  • Its requests are like any other client's: the key as Authorization: Bearer, and a User-Agent of vestiarion-cli/0.1.0 followed by the SDK's own, such as vestiarion-sdk-js/0.3.2. A write carries an Idempotency-Key, the caller's own with --idempotency-key, except a payee link.
  • vestiarion login checks a key with one GET /api/v1/status before saving it, and vestiarion whoami reads GET /api/v1/status and GET /api/v1/treasury, so a key's Last used time in Settings moves when either runs.
  • Offline, vestiarion ledger verify checks an audit export as verify-ledger-export.mjs does, and vestiarion webhooks verify checks a delivery's Vestiarion-Signature.
  • Nothing in /api/v1 or the webhooks changes.

2026-10-14: Deals brought in from Pipedrive

  • An owner or admin can connect a workspace to a Pipedrive company, and a person plans the collections of the won deals it brings in. There is no new kind of entry: the entries HubSpot's deals use now also name Pipedrive. Each is listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • accounting_connected and accounting_disconnected with provider: "pipedrive"; externalOrgId is the Pipedrive company id and externalOrgName its name. A Pipedrive connection's consent.version is pipedrive-2026-10-14.
    • deal_signed, for a deal planned from Pipedrive, and deal_revised, for a change saved from what Pipedrive changed, with via: "pipedrive" and pipedrive: { companyId, dealId, organizationId }, Pipedrive's own ids. The deal's externalRef is pipedrive- followed by Pipedrive's deal id, such as pipedrive-482.
    • create_counterparty, for a customer added with such a deal, and counterparty_notice_email_changed, for a billing email filled from Pipedrive, with via: "pipedrive" and pipedrive: { companyId, organizationId }; the addresses are masked, as before.
    • crm_deal_changed and crm_deal_change_kept with provider: "pipedrive"; crmDealId is Pipedrive's deal id, without the pipedrive- prefix. A stage change's label is the stage's name, or the lost reason for a deal marked lost.
    • crm_receipt_writes_changed, crm_receipt_written, crm_receipt_conflict, crm_receipt_failed, crm_receipt_refused and crm_receipt_overwrite_chosen with provider: "pipedrive". fields and conflicts use the same keys as for HubSpot (vestiarion_collected and the rest), whatever the fields are called in Pipedrive. accountType is COMPANY: Pipedrive names no developer sandbox, so payments on Arc testnet or in shadow mode are never written to it, and a write queued for them ends in crm_receipt_refused with reason: "reality".
  • Nothing else in /api/v1 changes: the Pipedrive deals not planned are not in the API.

2026-10-13: A reporting currency, and cash scenarios saved as versions

  • Two new entries, actor human, each listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • reporting_currency_changed, domain system: { by, from, to }, when an owner or admin set the currency the workspace reports and plans in. to is USD, EUR, SGD, JPY, KRW, PHP or MYR; from is the one before, or null the first time.
    • cash_scenario_saved, domain treasury: { by, scenarioId, versionId, version, name, horizon, lateDays, costPct, costScope, receivablesChanged, rates, reportingCurrency }, when an owner or admin saved a cash scenario. Each save is the next version of scenarioId, from 1. rates lists each rate typed, { currency, perUsd, reference }: perUsd is how many of the currency make one US dollar, as a decimal string, and reference is { perUsd, source, at }, the reference rate shown beside it, or null.
  • Nothing else in /api/v1 changes: invoices are still in USDC or EURC, and a payment still carries the amount the bill was converted to. The rates, the reporting currency and the FX variance on paid bills are not in the API.

2026-10-13: Collections that follow the customer's context

  • Before it reminds a customer, the agent proposes each receivable's next step from what the customer said, paid and was promised, its own rules and the HubSpot deal it was sold through, and asks a person when the step is theirs. Three new entries, domain ar, each listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • collection_policy_set, actor human: { by, counterpartyId, version, approval, maxTone, minDaysBetween, channel, accountOwner }, when a person saved a customer's rules. approval is auto or ask_first; maxTone is friendly, firm or final; minDaysBetween is 3 to 30; channel is email; accountOwner is a member's user id or null. Each save is the next version.
    • collection_task_opened, actor agent: { taskId, invoiceId, counterpartyId, kind, reason, policyVersion, reasons }, with reminder: { number, tone } when the task is about a drafted reminder. kind is ask_owner or finance_review; reason is policy_ask_first, hubspot_owner, no_contact, promise_passed, claim_unverified (a claim of payment still open 7 days after the customer made it) or reminders_done; reasons lists the codes of the facts the step rests on. A need that was already so before the agent first ran in the workspace with this change opens no task and has no entry.
    • collection_task_resolved, actor human: { by, taskId, invoiceId, counterpartyId, reason, outcome, policyVersion }, with holdUntil (YYYY-MM-DD) for a hold and reminder: { number, tone } for an approval. outcome is approved, held, no_reminder, resumed or done.
  • ar_reminder_sent and ar_reminder_deferred gain context: { policyVersion, reasons }. A reminder a person approved is an ar_reminder_sent with decisionMode: "person", agreedWithReference: null, approvedTaskId and approvedBy.
  • A customer's open claim of payment now holds the agent's reminders until it is closed, finance being asked after 7 days, and a promise whose day passed holds them until finance reviews it: fewer ar_reminder_sent entries follow such a request. Resolving a claim_unverified task closes the claim as not_received, a customer_request_closed entry before the collection_task_resolved one.
  • Nothing else in /api/v1 changes: rules and tasks are not in the API.

2026-10-13: Project budgets, and the same work billed twice

  • An owner or admin can make projects, each with a budget and a buffer in USDC, and anyone who adds bills can put a bill, a milestone or a deal in one. A project's budget is an earmark in Vestiarion: nothing is locked on chain. Three new entries, actor human, domain ap, each listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended. Amounts are USDC; …Minor fields are in cents and the others decimal strings.
    • project_created { by, projectId, name, currency, budget, budgetMinor, buffer, bufferMinor, status }. currency is USDC; status is active.
    • project_changed { by, projectId, before, after }, each of before and after the fields of project_created but by and projectId. Archiving sets after.status to archived; reopening, to active.
    • project_assigned { by, subject, subjectId, projectId, projectName, previousProjectId, reservation }, when a bill (subject: "invoice", subjectId an invoice id), a milestone or a deal is put in a project or taken out of one (projectId null). via: "entry" when the project was chosen as the bill or milestone was added. reservation is null for a deal, a removal, or when the reservation could not be made, and otherwise { state, neededMinor, availableMinor, reservedMinor, paidMinor }: state is reserved (the money was set aside), over (the budget could not hold it; nothing was set aside), or archived, settled or no_project. The entry names the bill as subjectId, never invoiceId, so it is not taken for a decision on it.
  • Two new values of guardrailRule on the agent's ap_pay, ap_schedule and milestone_release entries, each with guardrailBlocked: true and execution.resultingStatus: "held". Both run after every other rule, and only on a payment the others let through:
    • project.budget_exceeded: the bill or milestone is in a project whose budget, less its buffer, less what is set aside and paid, cannot hold it. observed.project is { id, name, state, neededMinor, budgetMinor, bufferMinor, reservedMinor, paidMinor, availableMinor }, with state over or archived, and execution.heldBecause is project_budget for over; or { id, state: "unreadable" } when the project could not be read.
    • obligation.duplicate_reference: a bill names the same purchase order, for the same payee, as an earlier milestone, or a milestone as an earlier bill; or one links the same delivered work as the other. observed.sameWork lists each { otherKind, otherId, otherStatus, signal, reference, finding }, signal purchase_order or deliverable.
  • On every agent decision about a bill or milestone in a project, observed.projectId names the project, and observed.project records what its reservation found (state: "reserved", with already) when the payment went ahead; observed.sameWork is recorded whenever an earlier bill or milestone for the same work exists, whatever held the decision. A milestone's create_milestone entry carries poReference when one was entered.
  • A new value of execution.heldBecause, project_budget. The follow-up decides such a payment again once its project has room, with an invoice_reopened or milestone_reopened entry whose followUp.changes says so.
  • Nothing else in /api/v1 changes: GET /api/v1/invoices and the milestones routes return a bill or milestone in a project as before, and the write API takes no project or milestone purchase order.

2026-10-13: An accountant role, and a month's hand-off

  • A member's role may now be accountant, wherever an entry names one: role in member_invited and member_joined, and the roles in member_role_changed. An accountant reads the workspace, books payments in the accounting tool and applies money received; it decides no payment.
  • A new entry, actor human, domain system, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended: handoff_exported { by, format, month, decisions, payments, bookings, openItems, headSeq }, when a member downloads a workspace's hand-off for a month. format is csv or json; month is YYYY-MM; the counts are how many rows of each section it held; headSeq is the ledger's last entry when it was made.
  • A new Xero connection's accounting_connected carries consent.version xero-2026-10-13, whose words say an owner, admin or accountant approves what is booked. accounting_payment_approved may now name an accountant in by, on a connection agreed under that version.
  • Nothing else in /api/v1 changes.

2026-10-13: A deal's planned costs, and held bills escalated past their day

  • A person can enter a deal's planned costs, remove one, and link one to the payable or milestone it became. Its ledger gains three entries, actor human, domain ar, each listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • deal_cost_added { by, dealId, title, costId, label, counterpartyId, counterpartyName, currency, digits, amount, amountMinor, expectedOn, noDocument }. currency and digits are the deal's; amount is a decimal string and amountMinor the same in minor units; expectedOn is YYYY-MM-DD; counterpartyId and counterpartyName are null when nobody was named; noDocument is true when no bill or quote backs it yet.
    • deal_cost_removed, the same fields plus linked: null, or { kind, id } for the payable (kind: "payable", an invoice id) or milestone it was linked to. A removed cost stays in the deal's record and counts nowhere.
    • deal_cost_linked, the same fields plus linked: { kind, id, amount, amountMinor, status }: the payable or milestone the cost became, its amount in the deal's currency and its status when it was linked. A payable or milestone backs one cost at a time.
  • A new entry, actor system, domain system, listed and sent the same way: decision_escalated { invoiceIds, decideBy, recipients, failed }, when the members who can decide payments were emailed about held payables that passed the day they were to be decided by. decideBy maps each invoice id to that day (YYYY-MM-DD); recipients and failed are counts. A payable is escalated once for each such day, and only for a day on or after the first scheduled cycle that ran escalations in the workspace: payables already past their day then are never escalated.
  • Nothing else in /api/v1 changes: a planned cost is not an invoice, and GET /api/v1/invoices returns a linked payable as before.

2026-10-13: Customer statements and what customers say on them

  • An owner or admin can send a customer a link to its own statement, where the customer pays an invoice through its pay link, or says it paid, promises a day, disputes an invoice or asks for a pay link. Nine new entries, domain ar, each listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended. None changes an invoice: a customer saying it paid is its word, and the invoice stays pending until the payment arrives and is applied.
    • customer_statement_shared, actor human: { by, linkId, counterpartyId, expiresAt, days, replaced }. days is 7, 30 or 90; replaced lists the ids of the customer's earlier links this one stopped. The link itself is never in the entry.
    • customer_statement_unshared, actor human: { by, linkId, counterpartyId }.
    • customer_said_paid, customer_promised_payment, customer_disputed_invoice and customer_asked_pay_link, actor human with no by: { via: "customer_portal", linkId, requestId, invoiceId, counterpartyId, kind }, with paidOn (YYYY-MM-DD), and amount and currency when the customer gave an amount, for customer_said_paid; promisedOn for customer_promised_payment; superseded, the ids of the customer's earlier open requests of the same kind on that invoice it replaced; and textSha256, the SHA-256 of what the customer wrote (its reference and message, joined by a line break), never the words. kind is paid, promise, dispute or pay_link.
    • customer_wrote, actor human with no by: the customer wrote more under an open request. { via: "customer_portal", linkId, requestId, invoiceId, counterpartyId, kind, textSha256 }, with messageId for a message written under the request; a second dispute or pay link request on the same invoice, added to the open one, has none. Asking again for a pay link already asked for, with no words, writes nothing and adds no entry.
    • customer_request_replied, actor human: { by, requestId, messageId, invoiceId, counterpartyId, kind, textSha256 }.
    • customer_request_closed, actor human: { by, requestId, invoiceId, counterpartyId, kind, outcome }. outcome is resolved, or not_received for a claim of payment the business has not received.
  • Nothing else in /api/v1 changes: the statements and what customers said are not in the API.

2026-10-13: Receipts written back to HubSpot, and notes that say what is known

  • An owner or admin can turn on writing receipts to HubSpot. Each deal planned from HubSpot then gets, in HubSpot deal properties of a vestiarion group: what was collected from payments confirmed on Arc and applied to its invoices, what is still owed, the currency, a collection status, the last receipt's day, amount and transaction link, a reconciliation status and a link to the deal. Payments on Arc testnet or in shadow mode are written only to a HubSpot developer test account or sandbox. Six new entries, each listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • crm_receipt_writes_changed, actor human, domain system: { by, provider, connectionId, externalOrgId, on, scopes }, when writing was turned on or off.
    • crm_receipt_written, actor system, domain ar: { provider, connectionId, externalOrgId, writeId, dealId, crmDealId, fields, writtenAt, adopted, network, shadow, accountType }, once HubSpot read the write back the same. crmDealId is HubSpot's deal id and dealId the Vestiarion deal; fields holds each property's value as HubSpot read it back (vestiarion_collected, vestiarion_still_owed, vestiarion_currency, vestiarion_collection_status, vestiarion_last_receipt_date, vestiarion_last_receipt_amount, vestiarion_last_receipt_link, vestiarion_reconciliation, vestiarion_evidence_link), amounts as decimal strings in the deal's currency; adopted is true when HubSpot already held them; accountType is HubSpot's (DEVELOPER_TEST, SANDBOX, STANDARD).
    • crm_receipt_conflict, actor system, domain ar: { provider, connectionId, externalOrgId, writeId, dealId, crmDealId, conflicts }, when someone changed a field in HubSpot since Vestiarion last wrote it; nothing is written over it. Each of conflicts is { field, ours, theirs, next }.
    • crm_receipt_failed, actor system, domain ar: { …, reason, message, retryAt }, once per write, at its first failure; reason is no_answer, rate_limited, reconnect, refused_by_crm or fields. It is tried again on its own.
    • crm_receipt_refused, actor system, domain ar: { …, reason, message }, final; reason is reality (with network, shadow and accountType) or deal_gone.
    • crm_receipt_overwrite_chosen, actor human, domain ar: { by, writeId, dealId, crmDealId, connectionId, seen }, when a person chose to write Vestiarion's figures over what HubSpot held (seen).
  • A new HubSpot connection's accounting_connected carries consent.version hubspot-2026-10-13, and its scopes include crm.objects.deals.write and crm.schemas.deals.write when writing was allowed.
  • An invoice's or a milestone's agentReasoning notes a person's payment as paid only once Circle confirmed it: [approved and paid by a person] and [paid now by a person] as before when it was confirmed; [approved by a person; payment submitted] while Circle has not confirmed it, and [approved by a person; payment not confirmed] when it did not go through. Notes written before stay as they are.
  • Nothing else in /api/v1 changes.

2026-10-12: Deals brought in from HubSpot

  • An owner or admin can connect a workspace to a HubSpot account, and a person plans the collections of the won deals it brings in. Connecting and disconnecting are the accounting_connected and accounting_disconnected entries the Xero connector added, with provider: "hubspot"; externalOrgId is the HubSpot account (hub) id and externalOrgName its domain.
  • A deal planned from HubSpot is a deal_signed entry as any deal, with via: "hubspot" and hubspot: { hubId, dealId, companyId }, HubSpot's own ids; its externalRef is HubSpot's deal id. A change saved from what HubSpot changed is a deal_revised entry with the same via and hubspot. A customer added with the deal is a create_counterparty entry with via: "hubspot" and hubspot: { hubId, companyId }.
  • Two new entries, domain ar, each sent to webhook endpoints as ledger.appended and listed by GET /api/v1/ledger:
    • crm_deal_changed, actor system: { provider, connectionId, externalOrgId, crmDealId, dealId, changes }, once for each new set of changes HubSpot made to a planned deal. crmDealId is HubSpot's deal id and dealId the Vestiarion deal. Each of changes is { what: "amount", from: { amount, currency }, to: { amount, currency } }, { what: "close", from, to } (days as YYYY-MM-DD, or null), { what: "stage", from, to, label } (won, open or lost, and HubSpot's stage label), or { what: "deleted" }. Nothing in Vestiarion changes with it.
    • crm_deal_change_kept, actor human: { by, provider, connectionId, crmDealId, dealId, changes }, when a person kept the deal as it is.
  • A billing email filled from HubSpot is a counterparty_notice_email_changed entry, as one typed in, with via: "hubspot" and hubspot: { hubId, companyId }; its addresses are masked, as before.
  • Nothing else in /api/v1 changes: the HubSpot deals not planned are not in the API.

2026-10-12: Payments made on Arc booked in Xero, after a person reviews them

  • When a payable added from a Xero bill is paid on Arc and confirmed, Vestiarion drafts its booking against that bill in Xero; an owner or admin reviews it on Bills & receivables and approves it, and only then is it written to Xero. A payment on Arc testnet, and every payment in shadow mode, is booked only into an organisation Xero calls a demo company. Its ledger gains six entries, domain ap, each naming the payable as invoiceId, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • accounting_payment_drafted, actor system: { provider, connectionId, externalOrgId, postingId, invoiceId, billId, amount, currency, paidOn, reference, network, shadow, paidAmount, paidToken, networkFee }. amount and currency are what will be booked, in the bill's currency (USDC as USD, EURC as EUR; a shadow bill at its own amount); paidOn is the day the payment was confirmed (YYYY-MM-DD, UTC); reference is the Arc transaction hash; paidAmount and paidToken are what left on Arc; networkFee is in USDC and is never booked. billId is the Xero bill (invoice) id.
    • accounting_payment_approved, actor human: { by, provider, connectionId, postingId, invoiceId, account: { id, code, name, currency }, fingerprint, amount, currency, paidOn, reference }. fingerprint is a SHA-256 of exactly what the person was shown.
    • accounting_payment_sent, actor system: { provider, connectionId, postingId, invoiceId, paymentId, adopted }. paymentId is the Xero payment id; adopted is true when Xero already held a payment with this reference on the bill, which Vestiarion took instead of writing another.
    • accounting_payment_confirmed, actor system: { provider, connectionId, postingId, invoiceId, paymentId, amount, currency, account, paidOn, reference }, what Xero answered when the payment was read back.
    • accounting_payment_failed, actor system: { provider, connectionId, postingId, invoiceId, reason, message, retryable }. reason is no_answer, refused_by_provider, rate_limited, reconnect or mismatch; approving it again tries once more.
    • accounting_payment_refused, actor system: { provider, connectionId, postingId, invoiceId, billId, reason, message, network, shadow, organisationDemo, amount, currency, reference }. reason is reality (a payment on Arc testnet or in shadow mode, into an organisation that is not a demo company), already_paid, bill_closed, currency or deleted_in_provider. It is final: nothing is sent.
  • A new Xero connection asks for accounting.payments beside its read scopes, and accounting_connected's scopes lists it; its consent.version is xero-2026-10-12.2. A connection made before reconnects to allow booking.
  • Nothing else in /api/v1 changes: an invoice's status and txHash are those of its payment on Arc, booked or not.

2026-10-12: Bills brought in from QuickBooks Online

  • An owner or admin can connect a workspace to a QuickBooks Online company, and a person adds the bills it brings in from Bills & receivables. It writes the same five entries as Xero (below), each sent to webhook endpoints as ledger.appended and listed by GET /api/v1/ledger, with provider: "quickbooks". externalOrgId is the QuickBooks company (realm) id, and billId and billIds are QuickBooks bill ids. accounting_bill_closed also comes when a bill already added is deleted in QuickBooks, with sourceStatus deleted.
  • A bill added from QuickBooks is a create_invoice entry with via: "quickbooks" and quickbooks: { tenantId, billId, contactId, invoiceNumber }: the company (realm) id, the bill's id, its vendor's id and its number in QuickBooks. A vendor added with it is a create_counterparty entry with via: "quickbooks" and quickbooks: { tenantId, contactId }. A bill partly paid in QuickBooks is added at what is left to pay.
  • accounting_disconnected gains atProvider: true when a QuickBooks connection was disconnected in QuickBooks itself and QuickBooks confirmed it no longer accepts it; then revokedAtProvider is true and Vestiarion revoked nothing. Without it, the entry is as before.
  • Nothing else in /api/v1 changes.

2026-10-12: Deals, their versions and the receivables released from them

  • An owner or admin can confirm a deal on Bills & receivables: a customer, a total and a schedule of lines that add up to it, each line released as a receivable when it is time to invoice it. Its ledger gains four entries, actor human, domain ar, each listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended:
    • deal_signed { by, dealId, version, counterpartyId, counterpartyName, title, currency, digits, total, totalMinor, startsOn, termsDays, externalRef, template, autoRelease, lines } for version 1. currency is USDC, EURC, or a three-letter code in shadow mode; digits is 2, or 0 for a currency without cents such as JPY; total is a decimal string and totalMinor the same in minor units. template is deposit, milestones, retainer or custom; externalRef is null or the reference given, such as a CRM deal id. Each of lines is { lineId, position, kind, label, invoiceOn, dueOn, amount, amountMinor, roundingMinor, replaces }, days as YYYY-MM-DD; roundingMinor is how much of the last line's amount is the rounding remainder.
    • deal_revised, the same deal fields plus { kind, fromTotal, toTotal, difference, fromTotalMinor, toTotalMinor, reason, ended, added, changes }, for a change (kind: "revised") or a reopen (kind: "reopened"). ended lists { lineId, status } for each planned line it ended (superseded or cancelled); added lists new lines as in deal_signed, a line that replaces another naming it. A credit owed to the customer is a line with kind: "credit" and a negative amount. A line already released is never in ended.
    • deal_cancelled, the same fields as deal_revised, with kind: "cancelled".
    • deal_auto_release_changed { by, dealId, title, on }: whether the agent releases each line on its invoice day.
  • Releasing a line is a create_invoice entry, domain ar, as for any receivable, with via: "deal" and deal: { dealId, lineId, version, title, line, releasedBy }. releasedBy is person, or schedule when the agent's cycle released it on its day, in which case the entry's actor is agent and by is null.
  • Nothing else in /api/v1 changes: a deal line not released yet is not an invoice, and GET /api/v1/invoices returns the receivable a line became like any other.

2026-10-12: Bills brought in from Xero

  • An owner or admin can connect a workspace to a Xero organisation, and a person adds the bills it brings in from Bills & receivables. Its ledger gains five entries, each sent to webhook endpoints as ledger.appended and listed by GET /api/v1/ledger:
    • accounting_connected, actor human, domain system: { by, provider, connectionId, externalOrgId, externalOrgName, scopes, consent: { version, at }, reconnected }. provider is xero; externalOrgId is the Xero organisation (tenant) id; consent is the version of what the person agreed to and when they ticked it.
    • accounting_disconnected, actor human, domain system: { by, provider, connectionId, externalOrgId, revokedAtProvider }. revokedAtProvider is whether Xero confirmed it ended the app's access.
    • accounting_payment_account_chosen, actor human, domain system: { by, provider, connectionId, account: { id, code, name, currency } }, the Xero account payments made on Arc will be booked to. Nothing is written to Xero yet.
    • accounting_bill_closed, actor system, domain system: { provider, connectionId, externalOrgId, billId, invoiceId, invoiceNumber, sourceStatus, at }, when a bill already added is paid, voided or deleted in Xero. invoiceId is the invoice it became; sourceStatus is paid, voided or deleted. The invoice itself is unchanged.
    • accounting_bills_dismissed, actor human, domain ap: { by, provider, connectionId, billIds }, the Xero bill ids a person chose not to add.
  • A bill added from Xero is a create_invoice entry, as one typed into the form, with via: "xero" and xero: { tenantId, billId, contactId, invoiceNumber }, Xero's own ids. A supplier added with it is a create_counterparty entry with via: "xero" and xero: { tenantId, contactId }.
  • Nothing else in /api/v1 changes.

2026-10-12: Money received applied to invoices: part payments, one payment for several invoices, fees

  • An owner or admin can apply a payment received on Arc to one or more open receivables of its currency, record a difference as a fee with a reason, and reverse either; the agent applies by itself a payment that is exactly what is still owed on a part-paid receivable. Its ledger gains three entries, domain ar, each sent to webhook endpoints as ledger.appended and listed by GET /api/v1/ledger, one per invoice touched:
    • ar_payment_applied, actor human, or agent for the rest of a part-paid receivable: { by, allocationId, invoiceId, counterpartyId, transferId, amount, currency, txHash, from, basis, outstandingAfter, unappliedAfter, group }. amount is what was applied to that invoice; outstandingAfter what is still owed on it, 0 once it is paid; unappliedAfter what is left of the payment, the client's credit. basis is person, or sender or amount for the agent, as ar_received's matchedBy. group is the same for the entries one press wrote. suggestion: { rule, why } is added when a person applied a suggestion; by is null for the agent.
    • ar_fee_recorded, actor human: the same fields with reason, transferId, txHash and from null. A fee is applied to the invoice, never counted as paid by the client.
    • ar_allocation_reversed, actor human: { by, allocationId, reverses, reversedKind, invoiceId, counterpartyId, transferId, amount, currency, txHash, reason, outstandingAfter, unappliedAfter, group }. reverses is the allocationId reversed and reversedKind is payment or fee. Nothing is edited: what it applied is owed again.
  • GET /api/v1/invoices keeps its shape. A part-paid receivable keeps its full amount and the status pending (or matched) until what is applied covers it, then becomes received, with settledAt and txHash from the last payment applied. A reversal that leaves something owed on a received receivable makes it pending again, with settledAt and txHash null. What was applied is in the entries above.
  • GET /api/v1/treasury keeps its shape. Its latestForecast.projectedInflow counts a part-paid receivable for what is still owed, not its full amount: what arrived is in liquidBalance already.
  • A payment matched to one invoice in full is unchanged: one ar_received entry, as before. Nothing else in /api/v1 changes.

2026-10-11: A bill moved from the payment plan is a payment_rescheduled entry

  • Bills & receivables shows a payment plan for the next 14 days. A member who can approve payments can move a bill the agent scheduled to the day the plan proposes. Its ledger gains payment_rescheduled, actor human, domain ap, listed by GET /api/v1/ledger and sent to webhook endpoints as ledger.appended: { by, invoiceId, counterpartyId, from, to, dueOn, amount, pays, discount, balanceAfter, planFingerprint, lineFingerprint }. from and to are the days (YYYY-MM-DD, UTC) the bill was scheduled for and is now; pays is what the plan expects to leave that day, less the early-payment discount when paid by its deadline; discount is { pct, value, until } or null; balanceAfter is the plan's projected balance after it: the plan only moves a bill to an earlier day within the 14 days it shows. soleApprover: true is added when the person who entered the bill moved it as the workspace's only approver.
  • A move is neither a payment nor a decision: the invoice stays scheduled, with the new day as its scheduledFor in GET /api/v1/invoices, and the agent decides it again on that day with an ap_* entry, as for any scheduled bill.
  • A move to today starts a cycle, whose cycle_complete entry lists the new event kind plan_approved in events. Nothing else in /api/v1 changes.
  • An owner or admin can share the workspace report by a public link, and stop one; an owner can answer how long one bill took before Vestiarion, which the report's value section estimates from. Its ledger gains three entries, actor human, domain system, each sent to webhook endpoints as ledger.appended and listed by GET /api/v1/ledger:
    • report_shared { by, shareId, options: { names, amounts, title } }: a link was made. names is labels or shown, amounts is shown or hidden, and title is workspace or neutral. The link itself is never in the entry.
    • report_unshared { by, shareId }: the link with that shareId was stopped.
    • report_baseline_answered { by, baselineId, minutesPerBill, peoplePerBill }: an owner answered, in whole minutes and people. A changed answer is a new entry; the newest is the one the report reads.
  • Nothing else in /api/v1 changes: sharing and the answer are made in the console only.

2026-10-11: What the business paid, from its bank statement

  • An owner or admin can fill in what the business paid from its bank statement, on the workspace report: each ticked line of money out is recorded against the bill it paid. Each is an actual_payment_recorded entry, or actual_payment_corrected when the bill had a record, as before, sent to webhook endpoints as ledger.appended and listed by GET /api/v1/ledger. Such a record is a payment by bank_transfer on the line's booking day, for its amount and currency, with its reference, and its entry adds:
    • via: "statement".
    • statementLine { id, account, line, bookedOn, valueOn, amount, currency, description, payee, reference, balance }: the kept line's id, the account as the person named it, the line of the file, the booking day and the value day (YYYY-MM-DD, valueOn null when the statement has none), the amount as the statement says it (money out negative) in currency, the bank's description, and the payee, the reference and the running balance after the line, each null when the statement has none.
  • Entries without these fields are unchanged. Nothing else in /api/v1 changes.

2026-10-10: A limit applied after trying it records the replay

  • A person can try a new payment limit, figure for two approvals or spending limit on the agent's past decisions before saving it. When they apply it from that result, its entry gains replay in its detail: { windowDays, from, to, decisions, unchanged, nowHeld, nowPaid, nowTwoPeople, cantTell }. windowDays is 30 or 90, from and to bound the window, and the counts are the decisions replayed and how their outcome would change. A later decision on a bill the replay already paid counts as unchanged, so each bill moves a count once.
  • The entries are counterparty_limit_changed, approval_policy_changed and agent_budget_changed, in GET /api/v1/ledger and as ledger.appended alike. A change saved without trying it first has no replay, as before.
  • Trying a figure writes nothing to the ledger. Nothing else in /api/v1 changes.

2026-10-10: An imported bill is a create_invoice entry

  • A bill list imported on Bills & receivables adds each row as a create_invoice entry, as an invoice typed into the form, sent to webhook endpoints as ledger.appended. Such an entry carries via: "import", importFile (the SHA-256 of the list's text as it was sent) and importRow (the row's number in the list, as the spreadsheet shows it), and invoiceNumber when the row has one. A bill in the business's own currency, in shadow mode, carries bill as one typed into the form does.
  • Imports no longer write import_invoice entries. Entries already written keep their action.
  • The invoice number starts the invoice's memo, for instance Invoice KP-1042: Copy paper, in GET /api/v1/invoices as everywhere. Nothing else in /api/v1 changes.

2026-10-10: What the business paid outside Vestiarion

  • An owner or admin can record how the business paid a payable outside Vestiarion, or that it did not, from the workspace report. Its ledger gains two entries, actor human, domain ap, each sent to webhook endpoints as ledger.appended and listed by GET /api/v1/ledger:
    • actual_payment_recorded { by, actualId, subject, subjectId, outcome, paidOn, amount, currency, method, reference, note, reason } for a bill's first record. subject is invoice and subjectId the invoice's id. outcome is paid, with paidOn (YYYY-MM-DD), amount, currency (three capital letters, or USDC or EURC) and method (bank_transfer, card, cash or other), and reason null; or not_paid, with reason and the four others null. reference and note are null when none was given.
    • actual_payment_corrected, the same fields plus replaces, the actualId of the record it corrects. A record is never changed: the newest of a bill's records is what the business did.
    • A record from a CSV carries via: "csv".
  • The entry names the payable as subjectId, never invoiceId. Nothing else in /api/v1 changes.

2026-10-09: A payable to a payee with no address is held before anything is sent

  • Wherever payments are real, an agent decision (ap_pay or ap_schedule) about a payable whose counterparty has no payment address is held by a new guardrail rule, counterparty.no_address: guardrailBlocked: true, execution.resultingStatus: "held", and observed.addressMissing: true. Before, the transfer was tried and failed, and the reasoning carried the provider's error. A sandbox's entries are unchanged.
  • Once the counterparty has an address and a person confirmed it, the follow-up decides the payable again, with an invoice_reopened entry whose changes include "the counterparty now has a confirmed payment address".
  • Approve and pay refuses such a payable with the error code no_address: "This payee has no payment address yet. Add it on Counterparties, or ask them for it with a one-time link." Nothing else in /api/v1 changes.

2026-10-08: Test USDC for shadow mode

  • A workspace in shadow mode on Arc testnet can take the test USDC its open bills need from Vestiarion's float. Its ledger gains test_usdc_added, actor human, domain treasury, sent to webhook endpoints as ledger.appended: { by, amount, from, to, transferId, txHash, status, shortfall, weeklyLimit }. from is the float's address and to the operating wallet's. status is confirmed, pending or failed, as Circle reported the transfer when the entry was written; txHash is null while Arc testnet still confirms it. shortfall is what the open bills needed, and amount what Circle says was sent.
  • Entries are never updated: a transfer recorded as pending stays so in its entry. A later entry with recovered: true and by: null records a transfer Vestiarion's float sent whose entry was never written, from Circle's own figures, with shortfall: null.
  • Each one starts a cycle, whose cycle_complete entry lists the new event kind test_usdc_added in events.
  • Money from the float is never matched to a receivable: no ar_received follows it. Nothing else in /api/v1 changes.

2026-10-08: Decisions made in shadow mode say so

  • An agent decision entry (ap_pay, ap_schedule, ap_hold, ap_flag_fraud, ap_request_info) written while the workspace is in shadow mode carries shadow: true in its detail, in GET /api/v1/ledger and in the webhooks alike. Entries written outside shadow mode are unchanged.
  • A payment the agent decided in shadow mode that a check in code held (guardrailBlocked: true) is now settled through a person's verdict, as one shadow mode held: its decision_verdict entry precedes any approval_paid, approval_rejected or approval_returned for it.

2026-10-07: A mirror address for a supplier with none, in shadow mode

  • In shadow mode, a supplier with no Arc address can be given a mirror address: a wallet Vestiarion makes for it on Arc testnet, in the workspace's own Circle wallet set. The counterparty's address is then that wallet's, and chain is ARC-TESTNET.
  • It is recorded as counterparty_address_changed with via: "mirror": { by, counterpartyId, via, from: null, to, walletId }, actor human, domain compliance. No person typed the address, so the first payment to it does not wait for a second person to confirm it.
  • GET /api/v1/counterparties shows the address as any other. Nothing else in /api/v1 changes.

2026-10-07: A bill in the business's own currency, in shadow mode

  • In shadow mode, a bill typed into the invoice form in the business's own currency is added at its USDC amount, worked out at the day's rate from ExchangeRate-API (a US dollar is one USDC). Its create_invoice entry carries bill { currency, amount, perUsd, source, at }: the bill as written, how many of its currency made one dollar, where the rate came from, and when it was published. amount and currency stay the USDC figure the agent pays.
  • Nothing else in /api/v1 changes: the API still takes invoices in USDC or EURC.

2026-10-07: Shadow mode: a person agrees with each payment

  • A workspace on Arc testnet can run in shadow mode. The business keeps paying its bills as it does today, and the agent pays nothing until a person agrees. Its ledger gains these entries, each sent to webhook endpoints as ledger.appended:
    • shadow_mode_started { by, currency } and shadow_mode_ended { by, currency }, with actor human and domain system. An owner turned it on for bills in currency (ISO 4217), or turned it off.
    • ap_pay for a payment held in shadow mode has execution.resultingStatus: "held" and execution.heldBecause: "shadow_verdict", with guardrailBlocked: false: the decision passed every check. A milestone_release held the same way has the same heldBecause.
    • decision_verdict { by, entrySeq, subject, subjectId, agentAction, verdict, reason }, with actor human and domain ap. A person agreed (verdict: "agree") or disagreed ("disagree") with the agent's decision in entry entrySeq. subject is invoice, subjectId is the invoice's id, and agentAction is the decision's entry action. reason is the person's words: required for a disagreement, null for an agreement given without one.
  • A payment a person agrees to is paid first, as Approve and pay pays it, to the address their card showed, with its approval_paid entry. Its decision_verdict follows once it is paid, or its transfer was tried; a payment refused before anything was sent writes no verdict. A disagreement can return the payable to the agent (approval_returned) or reject it (approval_rejected). Nothing else in /api/v1 changes.

2026-10-07: A live treasury's own wallet changes its figures, or stops the agent

  • Once a workspace that pays from its owner's own wallet is live on Arc mainnet, the owner or an admin can change the contract's figures, stop the agent's payments, and resume them from Go live. The treasury's own wallet sends each change. Each is recorded once per transaction, from the chain only, when the transaction's own logs show that change. Three ledger entries record them, each with actor human and domain system:
    • agent_budget_changed { by, from, to, txHash, onChain: { contract, txHash, signer } } when the wallet changed the figures. to is what that transaction set, null for a figure not set, and signer is wallet or passkey. The workspace's spending limit then follows what the contract holds. The entry now carries txHash at the top of detail as well.
    • spending_limit_stopped { by, contract, txHash, signer }, a new entry: the wallet set its approval for the contract to 0. Unless the agent was paused already, or a later approval undid the stop, the agent is paused first, with an agent_paused entry whose reason is "The owner stopped the agent's payments on Arc".
    • spending_limit_resumed { by, contract, txHash, signer, allowanceUsdc }, a new entry: the wallet approved the contract again. allowanceUsdc is the cap it approved, null when it has none. The pause a stop set is lifted first, with an agent_resumed entry, while the approval still stands; any other pause stays.
  • All of these reach webhook endpoints as ledger.appended, and GET /api/v1/ledger lists them. Nothing else in /api/v1 changes.

2026-10-07: A passkey wallet can be the treasury

  • On Arc mainnet, an owner can make the treasury a passkey wallet: a smart account owned by their passkey, set up in Go live with one confirmation. Its setup writes the same entries as a wallet in the owner's browser, with these differences:
    • treasury_wallet_chosen, a new entry with actor human and domain system, records the choice in place of treasury_wallet_proven. Its detail is { by, address, signer: "passkey", network }. A passkey wallet signs no message: its own approval of the contract, on chain, proves it is the owner's.
    • spending_limit_enforced gains signer: "passkey". Its deployTxHash and approveTxHash are the same transaction, which deployed and approved the contract in one user operation.
    • treasury_recovery_registered { by, recoveryAddress, txHash } records the address of the recovery phrase the owner registered as a recovery owner of the wallet. treasury_recovery_skipped { by } records that they chose to go without one. A passkey wallet's workspace goes live only after one or the other.
  • On both routes, choosing the wallet now creates the agent's wallet in the same step, so agent_wallet_created follows treasury_wallet_proven or treasury_wallet_chosen at once.
  • All of these reach webhook endpoints as ledger.appended, and GET /api/v1/ledger lists them. Nothing else in /api/v1 changes.

2026-10-07: A workspace on Arc mainnet can pay from its owner's own wallet

  • A workspace on Arc mainnet can keep its treasury in a wallet its owner holds. It pays from that wallet only through its spending limit contract, from an agent wallet Vestiarion creates for it. Its setup writes three new ledger entries, each with actor human and domain system, and each sent to webhook endpoints as ledger.appended:
    • treasury_wallet_proven: the owner's wallet proved it is theirs. Its detail is { by, address, message, signature, network }: the wallet's address, and the message it signed with the signature, which anyone can check again.
    • agent_wallet_created: { by, address }, where address is the agent's wallet, the only one that can pay through the contract.
    • spending_limit_deployed: { by, contract, txHash, dailyUsdc, weeklyUsdc }, the contract the owner's wallet deployed, its transaction and its figures, null for a figure not set.
  • spending_limit_enforced for such a workspace has the fields it has for a Circle wallet. treasury is the owner's wallet and setLimitsTxHash is null, and two fields are added: walletHost: "external", and allowanceUsdc, the approval the owner's wallet gave the contract, null when it has no cap.
  • agent_budget_changed is written when the deployed figures differ from the workspace's spending limit, with onChain.txHash the deployment.
  • workspace_went_live for such a workspace carries detail.walletHost: "external".
  • In GET /api/v1/treasury, its operating account's address is the owner's wallet, and its balance is what the contract can move: the wallet's USDC, or the approval if that is less.
  • The agent's payment decisions carry onChainLimit, as they do wherever a limit is enforced on Arc. A person's payment goes through the contract too, and its entries do not change. Nothing else in /api/v1 changes.

2026-10-06: A milestone release waits for its cash

  • The agent no longer sends a milestone release that the operating wallet cannot cover, counting the releases before it in the same cycle and those still in flight. Its milestone_release entry has execution.resultingStatus: "held" and execution.heldBecause: "cash_shortfall", as an AP decision held for want of cash has.
  • On a milestone, execution.cashNeededUsdc is the milestone's amount, and execution.cashSeen.operating is what the operating wallet had left for it after those releases. cashSeen.reserve is the reserve, and cashSeen.gasKeptUsdc, on Arc mainnet, is the USDC the wallet keeps for its own gas. On an AP decision, cashNeededUsdc also counts the payables due before it, and cashSeen.operating is the whole balance.
  • A release whose last send Circle never answered is not held for cash. It goes out again under the same key, which finds the transfer at Circle if the money already moved.
  • Once cash has come in since and covers it, the next cycle reopens the milestone with a milestone_reopened entry whose followUp.changes reads "the cash it needs is there now (… USDC in the operating wallet and the reserve)", and decides it again.
  • A release from escrow is not affected. Nothing else in /api/v1 changes, and no other entry changes shape.

2026-10-06: A cycle can start when Circle says a payment settled

  • A cycle_complete entry's events can include payment_settled. Circle said a transfer in flight settled or failed, and that cycle recorded which. Circle's notification started it, so its by is absent, unless a person's event started the same cycle.
  • A cycle_complete entry's events can include payment_received without a person too, when Circle said money arrived in the workspace's operating wallet and it paid a receivable. Its by is then absent, unless a person's event started the same cycle.
  • An ar_received entry can be written as Circle's notification arrives, before that cycle, as the pay page's check writes it. The other entries are the ones the schedule writes. Nothing else in /api/v1 changes.

2026-10-06: Webhook retries go out every 10 minutes

  • The schedule that sends webhook retries, and anything still queued, now runs every 10 minutes. It ran on GitHub Actions, which started it only a few times a day, so a retry could wait hours past its backoff step. A delivery's body, headers and backoff steps do not change.

2026-10-06: A contractor on another chain is refused without naming a network

  • POST /api/v1/counterparties refuses a contractor with another chain with "Only a vendor can be paid on another chain; a contractor's milestones are released on the workspace's own chain.", in place of "…released on Arc testnet.", so a workspace on Arc mainnet is not told a testnet. The code, invalid_request, does not change.
  • A payment_stuck entry's detail.txHash now carries the transaction hash Circle answers with when the payment had none recorded yet, where it was null. Its shape does not change, and nothing else in /api/v1 changes.

2026-10-06: A payment that has not confirmed is told

  • A new ledger entry, payment_stuck, is written when a live payment has not confirmed 15 minutes after its attempt was sent, once for each attempt. Its actor is agent, and its domain ap for an invoice or contractor for a milestone.
  • Its detail: invoiceId or milestoneId, counterpartyId, amount, currency, idempotencyKey, attempt, submittedAt, minutes, circleAsked (whether Circle was asked this time), sendAnswered (false for a send Circle never answered), providerState (Circle's state when asked, such as STUCK), txHash and network.
  • Every webhook endpoint receives it as ledger.appended, and GET /api/v1/ledger lists it. Nothing else changes in /api/v1, and no other entry changes shape.

2026-10-06: Status says when an Arc mainnet workspace cannot pay yet, and a txHash on any network

  • GET /api/v1/status answers provenance.payments and provenance.yield as unavailable for a workspace on Arc mainnet that has its Circle account connected but is not live yet. Nothing pays there until it goes live, so live would have been wrong.
  • provenance.yield is unavailable on a network with no yield reserve. Arc mainnet has none, so a live workspace there answers payments: "live" and yield: "unavailable"; it used to answer yield: "simulate".
  • An invoice's txHash is described as on the workspace's network, not on Arc testnet. Its value does not change.
  • A received payment's ar_received entry and a new pay_link_created entry name the workspace's network in summary. Entries already written stay as they are.
  • A workspace on Arc mainnet can now go live, on a deployment that has Arc mainnet switched on. Its workspace_went_live entry carries detail.network: "arc-mainnet", as org_created does.
  • The TypeScript SDK 0.3.2 carries the new descriptions. Nothing else changes in /api/v1, and no entry changes shape.

2026-10-06: Two approvals from the start on Arc mainnet, and its status said plainly

  • GET /api/v1/status answers provenance.payments and provenance.yield as unavailable for a workspace on Arc mainnet with no Circle account connected yet, as it does when stored credentials cannot be read, and while the deployment has Arc mainnet switched off. Nothing pays then, so simulate would have been wrong. The reference and the TypeScript SDK 0.3.1 describe all three.
  • An org_created entry for a workspace on Arc mainnet carries detail.startingLimits: { dailyUsdc: 50, weeklyUsdc: 150, twoApprovalsAbove: 100 }. That workspace starts with two approvals above 100 USDC, and an approval_policy_changed entry can never turn them off there.
  • Nothing else changes in /api/v1, and no other entry changes shape.

2026-10-06: chain accepts ARC, and two entries name their network

  • POST /api/v1/counterparties accepts chain: "ARC", Arc mainnet's chain, for a workspace on Arc mainnet. Leaving chain out gives the workspace's own chain: ARC there, and ARC-TESTNET on Arc testnet, as before.
  • A chain the workspace's network does not pay on is refused with invalid_request, naming it: ARC on Arc testnet, or a Sepolia chain on Arc mainnet.
  • org_created and workspace_went_live entries now carry detail.network, arc-testnet or arc-mainnet.
  • The TypeScript SDK 0.3.0 types chain with ARC too.
  • Nothing else changes in /api/v1, and no other entry changes shape.

2026-10-05: The agent sends again on its own only what one approval may pay

  • An ap_reconcile or milestone_reconcile entry can now carry notResubmittedBecause: "workspace.two_approvals", with execution.resultingStatus: "held". The payment was never sent and is above the workspace's figure for two approvals. Two people's approvals of it had not been used to pay it, so the agent held it rather than sending it again.
  • Every ledger entry is still appended the same way, and its shape does not change.
  • Nothing changes in /api/v1.

2026-10-05: Approve and pay draws on the USYC reserve, and a person's cash back stays

  • Approve and pay brings back what the operating wallet lacks. A person's paying approval of a new USDC payment from the operating wallet, on Arc testnet or through CCTP with its fee, may now first bring cash back from the reserve. It does so when the wallet cannot cover the payment and the reserve can cover the rest. It brings back the difference, rounded up to the next micro-USDC, with a fifth more of a CCTP fee, which is read again just before the burn. A CCTP payout whose fee could not be read is not covered. Pay now on a held milestone does the same.
    • A new kind of cash_brought_back entry: actor human, with detail { by, reason: "approval", invoiceId | milestoneId, amount, neededUsdc, feeCushionUsdc?, operatingBalance, reserveBalance, earnMode, executed, executionNote?, execution? }. It comes before the payment's own entry.
    • A redemption that did not move is recorded too, with executed: false and why in executionNote, and nothing is paid. One Arc testnet had not yet confirmed may still land; asking again for the same payment finds that same redemption rather than sending a second one.
    • approval_paid and milestone_approval_paid then carry fromReserveUsdc.
    • When the wallet and the reserve together fall short, Approve and pay refuses, as before, before anything moves. No ledger entry is written for a refusal.
  • A person's Bring cash back stays for 24 hours. For 24 hours after a cash_brought_back entry with reason: "person", the agent's treasury decisions sweep nothing.
    • Their entries (hold, or redeem_from_usyc for what falls due) then carry personCashBack: { amount, at, until }.
    • A sweep the model chose anyway is recorded as a hold, with what it chose in boundedByCode.
  • Nothing changes in /api/v1.

2026-10-05: A person's payout to another chain takes the agent's route

  • An approval_paid entry for a new payment to another chain can now carry payout.route: "gateway", with gatewayBalanceUsdc, on a person's first attempt. A person's Approve and pay now chooses the route as the agent does: Gateway when the workspace's Gateway balance covers the amount and Gateway's fee, and Gateway costs no more than CCTP; CCTP otherwise. Before, a person's first attempt always went through CCTP.
  • Approve and pay now refuses, before anything is sent, a CCTP payout the operating wallet cannot cover with its fee, and a Gateway payout the Gateway balance cannot cover. No ledger entry is written for a refusal.
  • Nothing changes in /api/v1.

2026-10-05: Two approvals above a figure the workspace sets

  • A new guardrail rule, workspace.two_approvals. Above the figure a workspace's owner sets, the agent never pays or schedules a payable, or releases a milestone: code holds it for two people. Its entry carries guardrailBlocked: true, execution.resultingStatus: "held" and observed.twoApprovalsAbove, the figure it was weighed against. A EURC payable is weighed at its usdcValue.
  • New ledger actions, each with actor human:
    • approval_given (domain ap) and milestone_approval_given (domain contractor): the first of two approvals, which sends nothing. Its detail is { by, invoiceId | milestoneId, counterpartyId, amount, currency, address, usdcValue?, twoApprovalsAbove, fewApprovers? }.
    • approval_policy_changed (domain system): an owner set, raised, lowered or turned off the figure. Its detail is { by, from, to }, each a figure in USDC or null for off.
  • approval_paid and milestone_approval_paid gain approvals: [{ by, at }, …], the earlier first, and twoApprovalsAbove when two people approved the payment. Their summary then ends "(the second of two approvals)".
    • They also carry fewApprovers: true when whoever entered the payment, or gave its address, gave one of the two because no one else could. As many of the two as can come from other people must.
  • An invoice_reopened entry's followUp.changes can say that two approvals were turned off, or the figure raised to cover the payment. A milestone_reopened entry's can say the same.
  • Nothing changes in /api/v1.

2026-10-05: A payment Circle did not answer is looked for, never sent again blind

  • A payment whose send Circle did not answer is now in flight, not held. Its decision's execution.resultingStatus is matched, as for any payment Circle is still settling.
    • Vestiarion then looks for the send on Circle by its reference before anything is sent again.
    • If Circle has it, it is recorded as the payment.
    • If Circle has listed nothing 15 minutes after the send, the payment is sent as a new one.
    • Reject and Return look for it the same way before they act.
  • Payments can also be switched off from the database (npm run payments -- off "<reason>"). Every running deployment stops within 10 seconds, with no redeploy. While they are off, the agent appends no entries.
  • Approve and pay still records a transfer that was already sent while payments are off, since that only reads Circle.
  • Nothing changes in /api/v1.

2026-10-05: Checked addresses, a stop switch, and no rejection over an unknown transfer

  • POST /api/v1/counterparties refuses an address that mixes capital and small letters when they do not match its EIP-55 checksum: 400 invalid_request, with the message address: This address's capital letters do not match its checksum, so a character is likely wrong. An address written in one case alone is taken as written, as before.
  • Payments can be switched off for every workspace by whoever runs the deployment (PAYMENTS_DISABLED). While they are, no agent cycle runs, so the agent appends no entries and webhooks receive none from it.
  • When a payment's send ends without Circle saying what became of it, the invoice can be neither rejected nor returned until a person approves it, which asks Circle again under the same key. No ledger entry changes shape.
  • On a deployment with no screening service, a live workspace's counterparties stay unscreened instead of being screened against the demo list. Its compliance_sweep entries say the screening is incomplete.
  • Otherwise nothing changes in /api/v1.

2026-10-05: Two people before the first payment to an address

  • A new guardrail rule, counterparty.new_payee. Wherever payments are real, the agent never makes a payment or milestone release that would be the first to an address unless two different parties stand behind it:

    • the payee sent the address and a member confirmed it; or
    • one member gave it and another confirmed it.

    Its entry carries guardrailBlocked: true and execution.resultingStatus: "held".

  • A decision on a first payment records observed.newPayee: { addressBy, confirmedBy, twoParties }. addressBy is a member id, "payee", or null when no entry says who gave it.

  • approval_paid and milestone_approval_paid gain firstPayment: true when a person made an address's first payment. Approve and pay, and Pay now, now refuse the member who gave the address, unless they are the workspace's only approver.

  • An invoice_reopened entry's followUp.changes can name the payee's address has received a confirmed payment since or a second person now stands behind the payee's address.

  • Nothing changes in /api/v1.

2026-10-05: A EURC payable decided again when the rate changes what held it

  • An invoice_reopened entry gains reevaluation when a fresh quote cleared what held a EURC payable. Its shape is { trigger, previousDecision: { seq, action, guardrailRule }, before: { rate, usdcValue, swapCostPercent }, after: { rate, usdcValue, swapCostPercent, quotedAt } }.
    • trigger is one of rate_available, swap_available, swap_cost_within_cap or value_within_limit.
    • followUp.changes says the same in words.
  • The ap_* decision that follows such a reopen in the same cycle gains reevaluation: { reopenedSeq, trigger, previousDecisionSeq, previousAction }. Its own fx is the rate it was decided at.
  • A cycle_complete entry's events can include fx_changed. The FX watch started that cycle, every 5 minutes at most, not a person, so its by is absent.
  • Nothing changes in /api/v1.

2026-10-05: The three-way match, checked in code

  • A new guardrail rule, invoice.match_incomplete. When the agent chooses to pay or schedule a payable whose goods are not confirmed received, or whose counterparty needs a purchase order and has none on file, code refuses it. Its ap_pay or ap_schedule entry carries guardrailBlocked: true, guardrailRule: "invoice.match_incomplete" and execution.resultingStatus: "awaiting_info", and the invoice waits for its details.
  • An AP decision's detail.observed gains purchaseOrderRequired: whether the counterparty needed a purchase order when it was decided. Every counterparty needs one unless an owner or admin marked it as paid without them.
  • A new ledger action, delivered to webhooks as ledger.appended like every entry: counterparty_purchase_orders_changed, actor human, domain compliance. Its detail is { by, counterpartyId, from, to }, where from and to say whether the counterparty needed a purchase order before and after.
  • A cycle_complete entry's events can include purchase_orders_waived: a counterparty was marked as paid without purchase orders, so its payables that waited for one were decided again within a minute.
  • The invoice_reopened entry for such a payable names the counterparty is now paid without purchase orders in followUp.changes.
  • Nothing changes in /api/v1.

2026-10-04: A merge starts the cycle

  • A cycle_complete entry's events can now include pull_request_merged. A pull request was merged in a repository the workspace's GitHub connection covers, and a pending milestone waited on it, so the cycle that verifies and pays it started within a minute of the merge rather than at the next scheduled cycle.
  • Nothing changes in /api/v1.

2026-10-04: Bounties from a pull request comment

  • A new ledger action, delivered to webhooks as ledger.appended like every entry: github_bounty_attached, actor human, domain contractor. Someone who can write to a repository attached a bounty to a pull request with /bounty. Its detail is { by, via: "github", installationId, login, pullRequest, author, amount, milestoneId, counterpartyId, commentUrl }. by is the member who connected GitHub, under whose name the milestone was added, and login is the GitHub user who commented. See Show payments on GitHub.
  • create_counterparty and create_milestone entries gain via: "github", installationId and login for the contractor and the milestone a bounty added.
  • counterparty_address_changed entries gain via: "github", installationId, login and commentUrl when a pull request's author set their address with /payto. Their by is null, as for an address sent through a payee link, and the address waits for a member's confirmation the same way.
  • Nothing changes in /api/v1.

2026-10-04: Emailed invoices finished by hand

  • A create_invoice entry with via: "email" no longer always carries changed: []. An owner or admin can now finish an emailed invoice in the invoice form on AP / AR, with Edit and add or Finish and add. Its document.changed then lists the fields they changed from what was read, as for an invoice added from a document.
  • Such an entry carries no document when the email could not be read and the invoice was typed in.
  • Nothing changes in /api/v1.

2026-10-04: Cash back for milestones too

  • A cash_brought_back entry with reason: "payments_due_today" now also counts the verified milestones waiting to be paid in neededUsdc and payments, so a cycle brings their cash back from the reserve before it releases them. A milestone whose USDC is locked in escrow is not counted.
  • A person's Pay now on a milestone for a pull request now gets its pull_request_commented entry once the payment is confirmed, rather than at the next cycle.

2026-10-04: Payments said on the pull request

  • A workspace can connect GitHub from Settings, by installing the Vestiarion app on the repositories it chooses. See Show payments on GitHub.
  • Three new ledger actions, delivered to webhooks as ledger.appended like every entry:
    • github_connected, with installationId, account, accountType and repositorySelection;
    • github_disconnected, with installationId and account;
    • pull_request_commented, with milestoneId, pullRequest, commentUrl, amount, token and txHash. It is written when the app commented on the pull request a milestone was paid for. The comment names the amount, the network, the paying workspace and the transaction, never the payee.
  • Private pull requests verify in a repository the app is installed on, so verify_milestone_github can now follow a private pull request's merge.
  • Nothing changes in /api/v1.

2026-10-03: Invoices by email

  • New ledger actions, delivered to webhooks like every entry:
    • invoice_inbox_on, invoice_inbox_changed and invoice_inbox_off, actor human, domain system: an owner or admin turned on the workspace's address for invoices by email, replaced it, or turned it off. Their detail is { by }; the address is never recorded.
    • invoice_email_received, actor system, domain ap: an email arrived at the address and was read. Its detail is { inboxEmailId, from, authentication, read, document }: the sender with most of its name hidden, SPF/DKIM/DMARC as Resend reported them, read one of ready, needs_details or unreadable, and the document's kind and sha256, or null.
    • invoice_email_dismissed, actor human, domain ap: { by, inboxEmailId }.
  • create_invoice entries gain via: "email" and inboxEmailId when a member added the payable from an email on AP / AR. Such an entry carries document as one added from a document does, with changed: []. Nothing that arrives by email is added without a person.
  • Nothing changes in /api/v1.
  • Add a milestone, POST /api/v1/milestones, with a read-and-write key.
    • It takes { contractorId, title, amount, verificationSource? }, checked by the rules of the console's Add milestone form, and answers 201 with the milestone, shaped as List milestones returns it.
    • The milestone starts pending, and the API cannot verify it. A GitHub pull request in verificationSource is verified by the agent once it is merged; any other link waits for a person.
    • It takes an Idempotency-Key, as every write does.
    • It is recorded as create_milestone with via: "api" and apiKeyId.
  • Create a payee link, POST /api/v1/payee-links, with a read-and-write key.
    • It takes { counterpartyId }, a vendor or a contractor, and answers 201 with { id, counterpartyId, url, expiresAt }.
    • url is in that answer only, which is sent with Cache-Control: no-store.
    • The operation keeps no outcome for an Idempotency-Key, which would store the link. A repeat makes a new link, and the unused one stops working.
    • It is recorded as payee_link_created with via: "api" and apiKeyId. The address a payee enters through it waits for a person to confirm it, as before.
  • A write now checks the key's creator as they are now. Only owners and admins can add records. If an owner moves the creator to approver or viewer, the key keeps reading, and every write, invoices and counterparties included, answers 403 forbidden: "This key's issuer can no longer add records in this workspace."
  • A milestone records who added it, from the console, Pay a freelancer or the API. So the self-approval rule now applies to milestones too. When the agent held a milestone on its own judgment, the person who added it cannot choose Pay now for it, unless they are the workspace's only approver. Milestones added before keep no creator.
  • MCP gains create_milestone and create_payee_link. create_payee_link is marked destructive, because a new link revokes the unused one.
  • @vestiarion/sdk 0.2.0 adds milestones.create and payeeLinks.create.
  • Settings: the box that gives a key write access is now Can also add records.

2026-10-03: Add an invoice from Slack

  • create_invoice entries gain via: "slack" and linkId when an owner or admin added the payable from a message in Slack with Add invoice. Such an entry carries document as one added from a document on AP / AR does, with changed: [].
  • The Slack app asks for one more permission, files:read, to read the file someone chooses. A Slack connected before this is connected again from Settings with Reconnect Slack; its members stay connected.
  • Nothing changes in /api/v1.

2026-10-03: A member's API keys end with their membership

  • A workspace API key now works only while the person who created it is a member of the workspace. When they leave, are removed by an owner or an admin, or delete their account, every active key they created in that workspace, read-only or read-and-write, is revoked in the same step, and from then on answers 401 unauthorized on /api/v1 and on MCP, like any revoked key. Keys that other members created, and the person's keys in workspaces they still belong to, keep working.
  • Each such key gets its own api_key_revoked entry, delivered to webhooks like every entry, right after the member's member_left or member_removed. Its detail gains reason: member_left, member_removed (with member, the person removed, while by is who removed them) or account_deleted. A key revoked in Settings now carries reason: "person".
  • A key can no longer be created for someone who is not a member of the workspace.
  • A read-and-write key whose issuer has left can no longer add records, so a create_counterparty or create_invoice entry with via: "api" always names its issuer in by.
  • Nothing was revoked when this shipped: no active key had outlived its creator's membership.

2026-10-03: The TypeScript SDK on npm

  • npm install @vestiarion/sdk installs it from the npm registry.
  • Version 0.1.0 there is the same tarball, byte for byte, as https://www.vestiarion.xyz/sdk/vestiarion-sdk-0.1.0.tgz, which keeps working.

2026-10-03: A member's notifications move to Settings

  • telegram_disconnected entries for a chat its member disconnected from Vestiarion now carry via: "settings": the Telegram card moved from Members to the Notifications section at the top of Settings, with the switch for the email about payments that need a decision. Entries made before keep via: "members_page"; via: "telegram" and via: "blocked" are unchanged.
  • Nothing else changes in the ledger, the webhooks or /api/v1.

2026-10-03: A TypeScript SDK

  • @vestiarion/sdk 0.1.0, installed with npm install https://www.vestiarion.xyz/sdk/vestiarion-sdk-0.1.0.tgz. It is a typed client for every /api/v1 operation, with no dependencies, for Node 20 or later, Deno, Bun and edge runtimes. See TypeScript SDK.
  • Its types are generated from the OpenAPI document, so they follow each change listed here.
  • listAll and pages follow page.nextCursor to the end of a collection.
  • Requests are retried after:
    • a 429, when its Retry-After is 60 seconds or less;
    • a 5xx;
    • a timeout or a network failure.
  • Every write carries an Idempotency-Key, so a retry never adds a record twice.
  • verifyWebhook checks a delivery's Vestiarion-Signature.
  • verifyLedgerEntry checks an entry's body hash, Ed25519 signature and chain hash.
  • Nothing in the API or the webhooks changed.

2026-10-03: The agent's decisions in Slack

  • New ledger actions, domain system, delivered to webhooks like every entry:
    • slack_installed, actor human: an owner or admin connected a Slack workspace from Settings, and picked the channel the agent's decisions go to. Its detail is { by, teamId, channelId }.
    • slack_uninstalled: the workspace's Slack was disconnected, with every member's Slack link. Actor human when an owner or admin chose Remove Slack (via: "settings"); actor system when Slack said the app was removed from its workspace (via: "slack"), with by null. Its detail is { by, teamId, via }.
    • slack_member_connected, actor human: a member connected their own Slack account. Its detail is { by, linkId }, plus via: "install" for the account of the person who connected the workspace.
    • slack_member_disconnected, actor human: a member disconnected their own Slack account, with /vestiarion disconnect (via: "slack") or from Settings (via: "settings"). Its detail is { by, userId, linkId, via }. A member removed from the workspace loses the link with the membership, and that is recorded as the removal.
    • slack_decisions_limit_changed, actor human: an owner set the most a payment approved from Slack may be, or turned deciding from Slack off. Its detail is { by, from, to }, in USDC, null for off.
  • approval_paid, approval_rejected and approval_returned entries gain via: "slack" and linkId when a member decided the payable from its message in Slack, and agent_paused does when they paused the agent with /vestiarion pause. Everything else in them is what the console writes. Entries for actions taken in the console carry no via, as before.
  • A cycle's journal has a new stage, slack, after telegram, the last. It needs no other stage to have succeeded.
  • Nothing changes in /api/v1.

2026-10-03: A payable held for an unconfirmed address goes back to the agent once it is confirmed

  • A payable the agent held because its counterparty's address changed and no one had confirmed it (guardrailRule: "counterparty.address_unconfirmed", observed.addressUnconfirmed: true) now goes back to the agent when a person confirms the address: an invoice_reopened entry whose followUp.changes reads "the counterparty's new address has since been confirmed", then a new decision in the same cycle. Until now it stayed held until a person approved it. Approving it still pays it, and confirms the address.
  • The API's two write examples are now responses captured in testnet-2.

2026-10-03: Add counterparties and invoices through the API

  • New operations: POST /api/v1/counterparties and POST /api/v1/invoices. Each takes a JSON body of at most 64 KB, checked by the console form's rules, and answers 201 with the record, shaped as its list returns it. A body that does not validate, including one with a field the operation does not take, answers 400 invalid_request, naming the field. A counterpartyId the workspace does not hold answers 400 too.
  • A new scope, write. A key is read-only, as every existing key stays, or reads and writes; an owner or admin chooses when creating it. A read-only key on a write answers 403 forbidden. api_key_created lists scopes: ["read", "write"] for such a key.
  • Idempotency-Key on both writes. A repeat with the same key and body within 24 hours gets the first answer back, with Idempotent-Replayed: true. The same key with a different body, or while the first request is still being handled, answers the new error code conflict (409). A 5xx answer, and a body that fails validation, are not kept, and a key whose first request never finished is free again after 10 minutes.
  • Writes are limited to 30 a minute per key; over that, 429 rate_limited with Retry-After: 60. Reads stay unlimited.
  • create_counterparty and create_invoice entries for records added through the API carry via: "api" and apiKeyId, with by the key's issuer, or null once their account is gone. Such a create_counterparty also carries addressNeedsConfirmation: an address added through the API waits for a person to confirm it, and the agent holds payments to it (counterparty.address_unconfirmed) until then.
  • A payable added through the API starts a cycle, whose cycle_complete entry lists invoice_added in events, as one added in the console does.
  • MCP: two new tools, create_counterparty and create_invoice, annotated readOnlyHint: false, destructiveHint: false, idempotentHint: false, with an optional idempotencyKey. A read-only key gets the 403 as a tool error.
  • The OpenAPI document describes each write's request body, its Idempotency-Key header and its 201.

2026-10-03: A sweep's yield is counted over how long the cash would stay

  • In treasury entries (sweep_to_usyc, redeem_from_usyc, hold, actor agent), economics.expectedHoldDays is now how long the swept cash would stay in the reserve, on average over the next 30 days. What falls due is paid from the operating wallet first, and only what it cannot cover comes back, on its day. Before, it was the days until the next obligation. economics.projectedYieldUsd follows, and the written policy's referenceDecision with it.

2026-10-03: Code bounds the treasury's moves, and a payable to a client waits for a person

  • A new value of guardrailRule: counterparty.client_payable. The agent holds a payment, or a schedule, to a counterparty whose role is client, for a person: a client pays the business, so a payable to one is a refund, or an invoice entered in the wrong direction. A person may still approve it.
  • Treasury entries (sweep_to_usyc, redeem_from_usyc, hold, actor agent, domain treasury):
    • decision is now the move code allowed. A sweep takes at most the cash above the 7-day buffer. A redemption brings back at most 115% of what falls due within 14 days, less the operating balance, and at least the written policy's.
    • When code changed the model's move, boundedByCode: { chosen: { action, amount }, reason } keeps what the model chose and why, and decision.reasoning ends with "[Code limited this: …]".
    • agreedWithReference now also needs the amount within 5% of referenceDecision.amount, or 0.01 USDC.
  • ar_reminders_on gains replacedLink: true only when turning reminders on replaced a link made before October 3, which stops working. madeNewLink is also true when the receivable had no link.

2026-10-03: The agent reminds clients of what they owe

  • New ledger actions, domain ar, delivered to webhooks like every entry:
    • ar_reminders_on and ar_reminders_off, actor human: an owner or admin turned the agent's reminders on or off for a receivable. detail is { by, invoiceId, counterpartyId }, and for ar_reminders_on also linkId and madeNewLink (a link made before October 3 was replaced so the reminders can carry it).
    • ar_reminder_sent, actor agent: the agent emailed the client a reminder. detail is { invoiceId, counterpartyId, to, number, tone, daysFromDue, amount, currency, linkId, decision, referenceDecision, decisionMode, agreedWithReference }. to is the address with most of its name hidden; number is 1 to 4; tone is friendly, firm or final; daysFromDue is negative before the due date. toneLimited: { chosen, sent } is there when code sent a softer tone than the model chose.
    • ar_reminder_deferred, actor agent: the agent decided to wait before reminding. detail is { invoiceId, counterpartyId, until, daysFromDue, remindersSent, decision, referenceDecision, decisionMode, agreedWithReference }.
  • Turning reminders on starts a cycle; its cycle_complete entry lists the new event kind reminders_on in events.
  • A cycle's journal has a new stage, collections, between proposals and notices. It runs only when receipts completed.
  • counterparty_notice_email_changed now covers a counterparty's billing email, which also receives a client's reminders; its summary reads "Billing email for name: address", or "... removed".

2026-10-03: The agent's decisions in Telegram

  • New ledger actions, domain system, delivered to webhooks like every entry:
    • telegram_connected, actor human: a member connected their own Telegram chat to the workspace, from Members. Its detail is { by, username }, where username is the Telegram username with most of it hidden (@li***), or null.
    • telegram_disconnected: a chat no longer gets the workspace's decisions. Actor human when the member disconnected it, from Members (via: "members_page") or with /disconnect in the chat (via: "telegram"); actor system when Telegram answered that the member had blocked the bot (via: "blocked"). Its detail is { by, userId, via, username }, with by null for blocked. A member removed from the workspace loses the connection with the membership, and that is recorded as the removal.
  • create_invoice entries gain via: "telegram" when a member added the payable by tapping Add on an invoice the bot read. Such an entry carries document as one added from a document on AP / AR does, with changed: [].
  • A cycle's journal has a new stage, telegram, after notices, the last. It needs no other stage to have succeeded.
  • Nothing changes in /api/v1.

2026-10-03: Cash comes back from the reserve for payments

  • New ledger action cash_brought_back, domain treasury, delivered to webhooks like every entry: USDC came back from the reserve to the operating wallet.
    • Actor agent: each cycle, before it decides payments, the agent brings back what the USDC payables due today need beyond the operating balance. Its detail is { reason: "payments_due_today", amount, neededUsdc, payments, operatingBalance, reserveBalance, executed, executionNote, earnMode, execution? }. execution holds the transactions of a real USYC redemption. When nothing could move, executed is false, executionNote says why, and the entry's summary begins "Could not bring"; while the agent is paused, heldBecause is agent_paused.
    • Actor human: an owner or admin chose Bring cash back. Its detail is { by, reason: "person", amount, all, reserveBalance, earnMode, execution? }, where all says they brought back everything. It moves cash even while the agent is paused, and starts a cycle, whose cycle_complete entry lists the new event kind cash_returned in events.
  • The redemption itself is also a treasury_actions row with action: "redeem_from_usyc", as the treasury stage's are.
  • An AP decision held because the cash was not there carries execution.heldBecause: "cash_shortfall", with execution.cashNeededUsdc (what it needed, with the payables due before it) and execution.cashSeen: { operating, reserve } (the balances it saw). Once cash has come in since and covers it, the next cycle reopens the payable with an invoice_reopened entry whose followUp.changes reads "the cash it needs is there now (… USDC in the operating wallet and the reserve)", and decides it again.
  • A cycle's journal has a new stage, liquidity, between services and ap.

2026-10-03: Payment notices

  • New ledger actions, delivered to webhooks like every entry:
    • payment_notice_sent, actor system, domain ap or contractor: a payee was emailed that a payment to it was confirmed. Its detail is { invoiceId or milestoneId, counterpartyId, to, amount, token, txHash }, where to is the address with most of its name hidden (li***@example.com).
    • counterparty_notice_email_changed, actor human, domain compliance: a person set, changed or cleared where a counterparty's payment notices go. Its detail is { by, counterpartyId, from, to }, both addresses hidden the same way, null for none.
  • create_counterparty entries gain noticeEmail, hidden the same way, or null.
  • The address itself is not part of /api/v1/counterparties.

2026-10-03: Add what a held payable was missing

  • New ledger action invoice_details_added, actor human, domain ap, delivered to webhooks like every entry: a person added the purchase order a held, flagged or awaiting-information payable lacked, or marked its goods or services received. Its detail is { by, invoiceId, counterpartyId, added }, where added holds poReference, goodsReceived: true, or both. Nothing already on the invoice changes, and its status stays as it was.
  • At its next cycle the agent reopens the payable with an invoice_reopened entry whose followUp.changes names what was added, and decides it again. Adding details starts that cycle within seconds, and its cycle_complete entry lists the new event kind details_added in events.
  • In /api/v1/invoices, the payable's poReference and goodsReceived show what was added.

2026-10-03: A sandbox screens against the bundled watchlist

  • GET /api/v1/status reports screening: "simulate" for a sandbox workspace, whatever the deployment configures; a live workspace reports live when OpenSanctions is configured, as before.
  • A sandbox's counterparties are screened against the bundled watchlist at every cycle, and their compliance_sweep entries name that source. One screened by OpenSanctions before is screened again against the watchlist at its next cycle.

2026-10-03: Nothing is paid to a counterparty never screened

  • A new value of guardrailRule: counterparty.unscreened. The agent holds a payment, a schedule or a milestone release to a counterparty whose riskLevel is still unscreened, because screening could not run when it was added. The decision is made again once screening gives a verdict. A counterparty whose later screening fails keeps its earlier verdict, as before.

2026-10-03: The spending limit, enforced on Arc

  • New ledger actions, actor human, domain system, delivered to webhooks like every entry:
    • spending_limit_enforced: a person enforced the agent's spending limit on Arc testnet. Its detail is { by, contract, agent, treasury, dailyUsdc, weeklyUsdc, deployTxHash, approveTxHash, setLimitsTxHash }, where agent is the agent's own wallet and treasury the operating wallet.
    • spending_limit_unenforced: a person turned it off. Its detail is { by, contract, txHash }.
  • agent_budget_changed gains onChain: { contract, txHash } when the figures were changed on the contract too.
  • While the limit is enforced, the agent's payment decisions (ap_* and milestone_* entries, actor agent) carry onChainLimit: { contract, agent, ref, covered, uncoveredBecause?, verdict }. covered says whether the payment can go through the contract; verdict is the contract's answer before anything was sent: { state: "allowed" }, { state: "refused", error, spent?, amount?, limit? }, { state: "unreadable", reason }, or null when it was not asked.
  • Two new values of guardrailRule: workspace.onchain_limit (the contract would refuse the payment) and workspace.onchain_limit_route (the payment is in EURC, or to another chain, which the contract cannot carry).
  • A payment sent through the contract has, as its transaction, a call to the contract's pay(address,uint256,bytes32) by the agent's wallet. Its logs hold the USDC transfer from the operating wallet to the payee.

2026-10-03: A workspace's only approver may approve what they entered

  • When the person who entered a payable, or added a milestone, is the only member of the workspace who may approve payments (the only owner, admin or approver), they may now approve it themselves. The approval_paid or milestone_approval_paid entry then carries soleApprover: true in its detail, and its summary ends "(entered and approved by the workspace's only approver)". An approval by anyone else carries neither. Once a second member may approve, the person who entered a record cannot approve it again.

2026-10-02: The agent's reasoning is written in plain English

  • New decisions' agentReasoning in /api/v1/invoices and /api/v1/milestones, and detail.decision.reasoning in ledger entries, are written as 2 to 4 plain-English sentences, without the field names of the facts the agent was shown. Nothing about earlier records changes: the API and the ledger return what was stored.

2026-10-02: One review dismisses every screening match

  • A screening_match_dismissed entry can now dismiss several matches at once: the ones the person reviewed together. Its detail gains matchedEntities: [{ id, caption, score }], every match it dismissed. matchedEntityId, matchedCaption and matchedScore still name the counterparty's verdict match, the first in the list.
  • Screening now reads every candidate it needs. Previously, after five dismissals of one name, a re-screen could read clear while further matches were never looked at. Such a counterparty may now be screened medium or high again, with a risk_level_changed entry.

2026-10-02: A person decides a held milestone

  • Milestones can be closed. In /api/v1/milestones, status may be closed: a person closed the milestone without paying it, and it is never paid after. ?status=closed lists them. Every milestone has two new fields, null unless it is closed:
    • closedAt: when it was closed;
    • closeReason: the reason the person gave.
  • New ledger actions, delivered to webhooks like every entry:
    • milestone_approval_paid (actor human, domain contractor): a person paid a held milestone. Its detail is { by, milestoneId, counterpartyId, amount, currency, overrode, heldFor, txRef, status, attempt?, retriedAfter? }.
      • status is paid, verified (submitted, not yet confirmed) or held (the transfer failed).
      • heldFor says what it was held for: for example transfer_failed, agent_held or outflow_budget.
      • retriedAfter is present when Circle had failed the previous attempt, which this one sent again.
    • milestone_closed (actor human, domain contractor): a person closed a held milestone without paying it. Its detail is { by, milestoneId, counterpartyId, amount, currency, heldFor, reason }.

2026-10-02: The agent buys payee history over x402

  • New public endpoint: GET /api/x402/payee-history?address=0x…. It is paid per call over x402: 0.001 USDC on Arc testnet (eip155:5042002), scheme exact, settled through Circle Gateway batching (GatewayWalletBatched, GatewayWallet 0x0077777d7EBA4688BDeF3E311b846F25870A19B9).
    • Without a PAYMENT-SIGNATURE header it answers 402 with the offer in PAYMENT-REQUIRED.
    • With a payment Circle's facilitator verifies and settles, it answers 200 with { address, workspacesPaid, paymentsConfirmed, firstPaidAt, lastPaidAt, asOf, seller, priceUsdc } and the settlement in PAYMENT-RESPONSE.
    • A missing or malformed address answers 400 before any offer. When the history cannot be read, it answers 503 and nothing is charged.
  • New ledger actions:
    • service_purchased (actor agent, domain compliance). Its detail is { purchaseId, counterpartyId, address, seller, priceUsdc, payer, payTo, nonce, settlement, result }.
    • service_purchase_refused (actor agent, domain compliance). Its detail is { purchaseId, counterpartyId, address, seller, rule, reason }. rule is one of seller.not_allowed, offer.mismatch, price.above_max, budget.day or purse.short.
    • service_purchase_failed (actor agent, domain compliance). Its detail is { purchaseId, counterpartyId, address, seller, reason }.
    • service_budget_funded (actor human, domain treasury). Its detail is { by, amountUsdc, signer, depositor, txHash, balanceUsdc }.
  • AP decision entries and milestone_release / milestone_hold entries carry observed.addressHistory when the agent bought the counterparty's address history within 7 days: { about, workspacesPaid, paymentsConfirmed, firstPaidAt, lastPaidAt, boughtAt, priceUsdc }.
  • A cycle's detail.stages includes services, which runs after recurring and before ap.

2026-10-02: Batches through the operating wallet's own executeBatch

  • A batch of milestones is now one call to the operating wallet's own executeBatch, as Circle documents for its smart accounts. The wallet sends USDC to each payee in turn, and if one transfer fails, none happens.
  • The first version sent batches through Arc's Multicall3From. Multicall3From keeps the sender only when the sender signed the transaction itself, and a Circle smart account's transaction is sent by Circle's bundler. Circle refused that batch at estimation (ESTIMATION_ERROR), and no money moved. Its milestones were held, and their milestone_release entries carry execution.batch with resultingStatus: "held".
  • For a short time in between, workspaces with live wallets paid each milestone alone.

2026-10-02: Several milestones in one transaction

  • When a cycle releases two or more milestones paid in USDC on Arc testnet, they go out in one transaction. Each is still decided, checked and signed on its own. A milestone locked in escrow is always released on its own.
  • A milestone_release entry for a milestone paid this way carries execution.batch: { key, size }. key identifies the batch, and size is how many milestones it paid.
    • execution.txRef is the batch's transaction, shared with the other milestones in it.
    • execution.feeUsd is this milestone's share of the transaction's fee.
  • In /api/v1/milestones, several milestones can have the same tx_ref. A transaction hash no longer identifies one payment: key on the milestone's id.

2026-10-02: The agent proposes limits from people's approvals

  • When people approve at least two payments to one counterparty above its payment limit within 30 days, and reject none, the agent may propose raising the limit. The counterparty must be screened clear. An owner or admin accepts or dismisses the proposal in Approvals.
  • New ledger actions, in the compliance domain:
    • policy_proposal_made (actor agent). Its detail is { proposalId, counterpartyId, kind, fromLimit, toLimit, evidence, reasoning, decisionMode, referenceLimit, agreedWithReference }. kind is raise_limit. evidence lists the approvals it rests on: { invoiceId, amountUsdc, approvedAt, approvedBy, agentAction, guardrailRule }.
    • policy_proposal_declined (actor agent): the model decided not to propose. Its detail is { counterpartyId, currentLimit, evidence, reasoning, decisionMode, agreedWithReference }.
    • policy_proposal_accepted (actor human). Its detail is { by, proposalId, counterpartyId, fromLimit, toLimit, currentLimit }. A counterparty_limit_changed entry precedes it, as for any limit change.
    • policy_proposal_dismissed (actor human). Its detail is { by, proposalId, counterpartyId, toLimit }.
  • A cycle's detail.stages includes proposals, which runs last, after forecast.

2026-10-02: Recurring payments

  • An owner or admin can set up a payment that repeats every N days, weeks or months. Each period's invoice is created as it comes near and decided like any other.
  • New ledger actions, in the ap domain:
    • recurring_payable_created (actor human). Its detail is { by, recurringId, counterpartyId, amount, currency, memo, poReference, goodsReceived, everyCount, everyUnit, startsOn, endsOn }.
    • recurring_invoice_created (actor agent), when a cycle creates a period's invoice. Its detail is { invoiceId, recurringId, period, counterpartyId, amount, currency, goodsReceived }. period is the invoice's due date, YYYY-MM-DD.
    • recurring_payable_stopped (actor human). Its detail is { by, recurringId }.
  • A cycle's detail.stages includes recurring, which runs after follow_up and before ap.
  • An event cycle's detail.events can include recurring_added: someone set up a recurring payment.
  • Two invoices created for different periods of one recurring payment are never reported as duplicates of each other. Their decision entries' observed.duplicateCheck reflects that.

2026-10-02: A real USYC reserve

  • A live workspace's owner or admin can turn on a real USYC reserve on Arc testnet, once Circle has allowlisted its operating and reserve wallets. Until then, the reserve stays simulated, as before.
  • New ledger action usyc_reserve_enabled, in the treasury domain, appended when the reserve is turned on. Its detail is { by, operatingAddress, reserveAddress }.
  • Treasury decision entries (sweep_to_usyc, redeem_from_usyc, hold) of a workspace with a real reserve:
    • carry earnMode: "live";
    • carry usycSubscriptionsOpen: whether USYC could be bought then, or null when that could not be read;
    • when a move was made, carry execution. A sweep's is { approveTxHash, depositTxHash, shares, price }; a redemption's is { redeemTxHash, shares, price }. shares is in USYC, price in USDC per USYC.
  • A sweep decided while USYC cannot be bought has executed: false, and an executionNote saying so.
  • In GET /api/v1/status, data.provenance.yield reads live for such a workspace.
  • The reserve account's balance is its USYC's value in USDC at the latest price, read from Arc testnet every cycle. Its apy is the fund's yield over at least the last 5 days, from the same oracle.

2026-10-02: The agent's spending limit

  • An owner or admin can set what the agent may pay on its own per UTC day and per 7 days, in USDC. A payment past either is held for a person.
  • New value of guardrailRule, workspace.outflow_budget, on an ap_pay or milestone_release entry: paying it would have taken the agent past its limit.
    • The entry's execution.heldBecause is outflow_budget.
    • A payable goes to Approvals as held. A milestone stays held until the limit has room for it.
  • New field outflowBudget on an ap_pay or milestone_release entry, present when a limit is set: { dailyUsdc, weeklyUsdc, spentToday, spentThisWeek, remaining, binding }.
    • It is what the limit left when the payment was weighed.
    • binding is day or week, whichever figure left less.
  • Milestone decision entries now carry guardrailRule: counterparty.high_risk, counterparty.payment_limit, workspace.outflow_budget, or null.
  • New ledger action agent_budget_changed, in the system domain, appended when someone changes the limit.
    • Its detail is { by, from, to }. from and to are each { dailyUsdc, weeklyUsdc }, and null means no figure.
  • What counts against the limit is what the agent's own ap_pay and milestone_release decisions sent: entries whose execution.resultingStatus is paid or matched, at their USDC value. A payment a person approves does not count.
  • invoice_reopened and milestone_reopened entries can list the change "the agent's spending limit has room for it again" or "the agent's spending limit was removed".
  • An event cycle's detail.events can include budget_raised: someone raised or removed a figure of the limit.

2026-10-01: Receivables paid on Arc

  • New ledger action pay_link_created, in the ar domain: an owner or admin made a link for a client to pay a receivable. Its detail is { by, invoiceId, linkId }.
  • New ledger action ar_received, in the ar domain, appended by the agent when a transfer that arrived in the operating wallet settles an open receivable.
    • Its detail is { invoiceId, counterpartyId, amount, currency, txHash, from, circleTxId, matchedBy, receivedAt }.
    • matchedBy is sender when the client's address on file sent it, and amount when it was the only open receivable of that currency and amount.
  • A receivable's status becomes received, with settledAt and txRef set, when a transfer settles it.
  • A cycle's detail.stages includes receipts, which runs after reconcile.
  • An event cycle's detail.events can include payment_received: a client's "I have paid" check found the receivable paid.

2026-10-01: Dismissing a screening match

  • New ledger action screening_match_dismissed, in the compliance domain, delivered as a ledger.appended event. It is appended when a member who can decide approvals dismisses a counterparty's screening match as not the same person.
    • Its detail is { by, counterpartyId, matchedEntityId, matchedCaption, matchedScore, screenedName, reason }.
    • matchedEntityId is the screening service's id for the entity dismissed; screenedName is the counterparty's name when it was dismissed.
  • Screening skips a dismissed entity for that counterparty while its name stays the same, and judges the next match, if any. The counterparty is screened again at once, so a screen_counterparty entry with its new verdict follows.
  • An event cycle's detail.events can include match_dismissed.

2026-10-01: Held milestones decided again

  • New ledger action milestone_reopened, in the contractor domain, delivered as a ledger.appended event. The agent appends it when it returns a held milestone to verified because a fact its decision rested on changed: the contractor's risk level or payment limit, the milestone's verification source, or the agent was paused when it held it.
    • Its detail is { milestoneId, previousStatus, followUp: { action, reason, changes } }. previousStatus is held, followUp.action is reopen, and changes lists each fact that moved, in words.
    • The milestone's next decision entry follows in the same cycle.
  • A milestone's status can now go from held back to verified without anyone verifying it again.
  • An event cycle's detail.events can include limit_raised: someone raised a counterparty's payment limit and screening allows more than zero.

2026-10-01: EURC payments funded by a swap

  • A live workspace can pay a EURC payable after swapping USDC for the EURC it needs, through Circle's Stablecoin Service on Arc testnet.
  • New ledger action fx_swap, in the treasury domain, delivered as a ledger.appended event when a swap ends.
    • Its detail is { paysInvoiceId, swapId, state, usdcIn, eurcMinimum, eurcEstimated, eurcReceived, usdcPerEurc, costPercent, provider, adapter, approveTxHash, swapTxHash, failure, reasoning, resumed }.
    • state is confirmed or failed.
    • eurcReceived is the EURC the swap's transaction sent to the operating wallet, read from its receipt, or null when it could not be read.
    • resumed is true for a swap whose first answer was lost, finished by a later cycle. Its reasoning is then null.
    • It carries paysInvoiceId, not invoiceId: it is not a decision on the invoice.
  • New fields on a EURC payable's decision entry:
    • usdcDueWithin7Days;
    • swapOffer: { usdcIn, eurcEstimated, eurcMinimum, usdcPerEurc, costPercent, provider } when a swap was offered, or null;
    • swapUnavailable: why there was none, or null;
    • swap: { swapId, state, usdcIn, eurcReceived, swapTxHash, reason } for the swap made to fund the payment, or null. state is confirmed, pending or failed.
    • decision.fundWithSwap is true when the model chose to pay with the swap. It appears only on a payable the wallet's EURC was short of.
    • swapOffer.costPercent is what each EURC costs through the swap above the rate the payable was weighed at, in percent, rounded up to two places.
  • Two new values of guardrailRule:
    • fx.swap_cost_above_cap, for a swap costing more than 3% above the quoted rate;
    • fx.swap_usdc_short, for a swap that would leave the USDC below what falls due in USDC within 7 days.
  • When a swap does not go through:
    • A failed swap holds the payable with guardrailRule: null, as a failed transfer does. Its reason is in swap.reason.
    • A swap still in flight at Circle leaves the payable pending. The next cycle finishes the swap, then decides the payable again.

2026-10-01: Milestone escrow

  • A live workspace can lock a milestone's USDC in its own escrow contract on Arc testnet. Three new ledger actions, in the contractor domain, are delivered as ledger.appended events:
    • escrow_deployed, once per workspace. Its detail is { by, address, payer, deployer, circleContractId, txHash }.
    • escrow_funded, when a milestone is locked. Its detail is { by, milestoneId, contract, holdId, payee, amountUsdc, refundAfter, fundTxHash }. fundTxHash is null when the hold was found already on chain and recorded.
    • escrow_refunded, when a hold is taken back after its refund date. Its detail is { by, milestoneId, contract, holdId, amountUsdc, refundTxHash }.
  • A milestone locked in escrow is paid by releasing its hold rather than by a transfer. Its release decision's execution.txRef is that release transaction on Arc testnet.

2026-10-01: Payment receipts

  • An owner or admin can share a paid payable's receipt as a public link. Three new ledger actions, in the ap domain, are delivered as ledger.appended events:
    • receipt_shared, appended once per payment, the first time it is shared. Its detail is { receipt, records } and holds no names and no user ids:
      • receipt is { amount, token, paidAt, payee, chain, txHash, route, sourceTxHash?, feeUsdc? };
      • chain and txHash are where the payee was paid: the transfer on Arc testnet, or the mint on the payee's chain;
      • route is direct, cctp or gateway;
      • sourceTxHash is a CCTP payout's burn;
      • records is { seq, hash } of the entry that recorded the payment.
    • receipt_link_renewed, when a new link replaces an earlier one or a revoked receipt is shared again. Its detail is { by, receiptId }.
    • receipt_revoked, when a receipt's link is turned off. Its detail is { by, receiptId }.
    • None of the three carries invoiceId in detail: a receipt's entries are about sharing a payment, not deciding an invoice.

2026-10-01: Payouts from a Gateway balance

  • A payout to a payee on another chain can go from the workspace's Circle Gateway balance as well as through CCTP. Its decision entry's payout.route is then gateway, payout.feeUsdc is Gateway's fee, and payout.gatewayBalanceUsdc is the Gateway balance it was weighed against.
  • A decision entry for a USDC payout to another chain also carries payout.quotes: { cctpFeeUsdc, gatewayFeeUsdc }: both routes' fees as read for that decision, each null when there was none. gatewayFeeUsdc is null for a workspace with no Gateway balance.
  • An approval_paid entry for a new payment to another chain carries the same payout, read when the person approved: { chain, route, domain, feeUsdc, quotes }, with gatewayBalanceUsdc when the route is gateway. An approval that only records a transfer already sent carries none.
  • A payout keeps the route its first attempt took. A new value of guardrailRule, bridge.gateway_balance_short, holds one that went through Gateway when the Gateway balance no longer covers it with its fee.
  • For a Gateway payout:
    • the decision entry's execution.txRef is the mint on the payee's chain, with execution.destinationChain and execution.mintTxHash. No Arc transaction belongs to one Gateway payout: Gateway burns on Arc in batches;
    • GET /api/v1/invoices returns that mint as the invoice's transaction once it is paid. Until then the invoice is matched, as a CCTP payout is.
  • Three new ledger actions, in the treasury domain, delivered as ledger.appended events:
    • gateway_signer_created, whose detail is { by, signer, circleWalletId };
    • gateway_delegate_added, whose detail is { by, depositor, signer, txHash };
    • gateway_deposit, whose detail is { by, amountUsdc, depositor, signer, approveTxHash, depositTxHash, balanceUsdc }. balanceUsdc is the Gateway balance once it includes the deposit, or null when Gateway had not counted the deposit yet.

2026-10-01: Invoices read from a document

  • A create_invoice entry for an invoice read from a document carries document in its detail:
    • kind: pdf, email (an .eml file: its text and the text of its PDF attachments) or text;
    • sha256: the hash of the document's bytes, or of the pasted text;
    • reader: the model that read it (anthropic, openai, deepseek), or heuristic for the rule-based reader;
    • changed: the form fields the member changed from what was read, among amount, currency, dueDate, poReference, earlyPayDiscountPct, discountDeadline, memo and counterpartyId.
  • An invoice typed in carries no document. The document itself is not stored.

2026-10-01: First screens in the compliance sweep

  • Each entry in a compliance_sweep entry's detail.screened now carries firstScreen: true when the counterparty had no verdict before. changed is still true for a first screen.
  • When a sweep includes first screens, its summary counts them apart: "Screened 6 of 6 counterparties: 6 for the first time, 0 changed". A sweep of re-screens only still reads "Re-screened 6 of 6 counterparties; 0 changed".

2026-10-01: Payees on other chains

  • A counterparty's chain is one of ARC-TESTNET, BASE-SEPOLIA, ARB-SEPOLIA or ETH-SEPOLIA. GET /api/v1/counterparties returns it as before.
  • A payee on a chain other than Arc testnet is paid from Arc through CCTP V2 with Circle's Forwarding Service.
    • Its decision entry (ap_pay, ap_hold, ap_flag_fraud, ap_request_info, ap_schedule) carries payout: { chain, route: "cctp", domain, feeUsdc } in detail, where chain is the chain id (BASE-SEPOLIA) and feeUsdc is null when Circle gave no fee.
    • Only a vendor can be paid on another chain; a contractor's milestones are released on Arc testnet.
    • Its execution carries destinationChain and mintTxHash once the payment was sent. execution.txRef is the burn on Arc testnet, or cctp:<Circle transaction id> while the burn has no hash yet.
    • mintTxHash is null until the Forwarding Service mints. A later ap_reconcile entry carries it.
  • Three new values of guardrailRule, each of which holds the payable for a person:
    • bridge.fee_above_cap, when the fee is above 10% of the amount;
    • bridge.fee_unavailable, when Circle gave no fee;
    • bridge.unsupported_token, for an invoice in EURC to a payee on another chain.
  • A bridged invoice is matched from the burn until the mint, then paid. GET /api/v1/invoices shows it so. One still not minted two hours after it was sent is held for a person, by an ap_reconcile entry saying so.

2026-10-01: Invoices in EURC

  • An invoice can be in EURC as well as USDC. GET /api/v1/invoices returns its currency, which is now USDC or EURC; amount and paidAmount are in that currency.

  • A EURC payable is paid in EURC from the operating wallet. Its decision entry (ap_pay, ap_hold, ap_flag_fraud, ap_request_info, ap_schedule) carries currency in detail, and, for EURC only:

    • usdcValue, its value in USDC, which is what counts against the counterparty's limit;
    • fx: { rate, source: "circle-stablecoin-quote", quotedAt, usdcMinimum }, or null when Circle gave no quote;
    • eurcBalance, the operating wallet's EURC as read for the decision, or null when payments are simulated or the balance could not be read.

    Those five decision entries carry currency: "USDC" for a USDC invoice. ap_reconcile carries no currency.

  • Two new values of guardrailRule for a EURC payable, both of which hold it for a person: fx.rate_unavailable, when there was no quote to weigh it at, and treasury.insufficient_eurc, when the wallet's EURC cannot cover the payment or could not be read. As with every rule, guardrailRule is set when code refuses a payment or schedule the model decided on; a payable the model held itself for the same reason has guardrailRule: null, with usdcValue: null or an eurcBalance below observed.amount in its detail.

  • A duplicate is the same amount only in the same currency. A purchase order billed in one currency and again in the other is reported as purchase_order_rebilled, which goes to the model and does not block on its own.

  • approval_paid and the create_invoice and import_invoice entries gain currency in detail, and their summaries name it.

  • The invoice CSV import takes an optional currency column. A blank or missing value means USDC.

2026-10-01: Milestones added in the app

  • A member can now add a contractor milestone on the Contractors page. It starts pending and unverified, like any milestone in GET /api/v1/milestones.
  • Its verificationSource is the evidence link the member gave, or null: a GitHub pull request in its canonical form (https://github.com/<owner>/<repo>/pull/<number>, which the cycle checks for a merge as before), or any other https:// address, which only a person verifies.
  • A new ledger action, delivered as a ledger.appended event: create_milestone, in the contractor domain with actor: "human". Its detail is { by, milestoneId, counterpartyId, counterpartyName, amount, verificationSource }, with amount as the decimal string entered.
  • A new event kind, milestone_added, may appear in an event cycle's detail.events. It is raised only for a milestone whose evidence is a pull request, so the merge is checked within a minute.

No /api/v1 endpoint, parameter or response schema changed.

2026-10-01: Payment timing

  • An invoice can carry early-payment terms: a percent off and the date it lapses, set on the invoice form or by CSV import. GET /api/v1/invoices now returns earlyPayDiscount: { percent, deadline } | null for any invoice that carries them.
  • A payable the agent has committed to pay later reaches status scheduled, decided again each cycle until the day it pays. GET /api/v1/invoices's status filter now accepts scheduled.
  • GET /api/v1/invoices also returns scheduledFor (an ISO timestamp, or null) and paidAmount: what actually left, once an invoice's status is paid. paidAmount stays null before then, even while a submitted transfer already carries an amount.
  • A new ledger action, delivered as a ledger.appended event: ap_schedule, in the ap domain, recorded when the agent schedules a payable. Its detail carries decision: { action: "schedule", payOn, reasoning, confidence }, timing and timingRule (the policy's figures, and any correction made to the model's date), requestedPayOn when a date was corrected, terms: { earlyPayDiscount }, observed, and execution.resultingStatus: "scheduled".
  • Every ap_* decision entry (ap_pay, ap_hold, ap_flag_fraud, ap_request_info, ap_schedule) now carries timing, timingRule and terms in its detail; an entry for a previously scheduled invoice also carries scheduledFor.
  • ap_pay and approval_paid gain amountPaid and discountTaken in detail: both null when nothing went out, or the discounted amount and the percent taken when an invoice was paid by its discount deadline.
  • cycle_complete's detail.outcomes gains scheduledCount.
  • A duplicate is now also refused against a payable already scheduled, already being paid (matched), or being decided by a person on Approvals (processing), not only one already paid or received. The refusing entry's reasoning names which of these it repeats.
  • Two new ledger actions, delivered as ledger.appended events, both in the compliance domain with actor: "human":
    • payee_link_created, whose detail is { by, counterpartyId, linkId, expiresAt };
    • payee_link_revoked, whose detail is { by, counterpartyId, linkId }.
  • A counterparty_address_changed entry made by a payee through a payee link has by: null, and carries via: "payee_link" and linkId next to counterpartyId, from and to.
  • Such a change waits for confirmation like any other; a later counterparty_address_confirmed records who confirmed it.

No /api/v1 endpoint, parameter or response schema changed.

2026-09-30: What started a cycle

  • A cycle_complete ledger entry's detail can now carry trigger, which says what started the cycle:
    • "schedule" for the six-hourly run;
    • "manual" for Run cycle now;
    • "event" when something in the workspace gave the agent a decision to make.
  • An event cycle's detail also carries events, the kinds that led to it: invoice_added, milestone_verified, payable_returned, address_confirmed, agent_resumed and sample_loaded. by, when present, is the person whose action started the cycle.
  • These fields are visible on ledger.appended events and in GET /api/v1/ledger.
  • A cycle no longer starts while another one in the same workspace is running, so one workspace's cycles do not overlap.

No /api/v1 endpoint, parameter or response schema changed.

2026-09-30: Failed-payment retry

  • An approval_paid ledger entry's detail can now carry attempt, the transfer attempt this approval ended on (starting at 1), and, only when that attempt is a retry, retriedAfter: { providerTxId, providerState, failureReason } for the earlier attempt Circle ended in a terminal failure. Both are visible on ledger.appended events and in GET /api/v1/ledger.
  • Circle's STUCK transfer state is no longer a terminal failure; it is now reported the same way a transfer still pending is. Only CANCELLED, DENIED and FAILED end a transfer attempt.

No /api/v1 endpoint, parameter or response schema changed.

2026-09-30: Ledger signing key rotation

  • An owner can rotate a workspace's ledger signing key from Settings. The rotation is a ledger entry, delivered as a ledger.appended event like every other: ledger_key_rotated, in the system domain, with actor: "human". Its detail is { from, to, by }: the retired key's id, the new key's id, and the owner who rotated. See Key identity and rotation.
  • From that entry on, signingKeyId is the new key's id. Earlier entries keep the old id and keep verifying against the retired key.
  • ledgerRetiredKeyCount in GET /api/v1/status now counts the workspace's own retired keys.

No /api/v1 endpoint, parameter or response schema changed.

2026-09-30: Counterparty limit changes

  • A new ledger action, delivered as a ledger.appended event: counterparty_limit_changed, in the compliance domain. Its detail is { by, counterpartyId, from, to, currentLimit }, where from and to are the configured limits in USDC and currentLimit is the limit the counterparty's risk now allows. A client's limit may be null.

No /api/v1 endpoint, parameter or response changed.

2026-09-30: Counterparty address changes

  • Two new ledger actions, delivered as ledger.appended events like every other entry, both in the compliance domain:
    • counterparty_address_changed, whose detail is { by, counterpartyId, from, to }. from or to is null when there was no address before, or it was cleared.
    • counterparty_address_confirmed, whose detail is { by, counterpartyId, address, via }. via is "approval" when approving a payment confirmed it, and "confirm" when someone confirmed it on the counterparty.
  • An agent decision entry (ap_pay and the other ap_* actions) can now carry guardrailRule: "counterparty.address_unconfirmed". It means the payment was held because the counterparty's address changed and no one has confirmed it. Its observed object gains addressUnconfirmed, a boolean.
  • An ap_reconcile entry can now carry notResubmittedBecause: "counterparty.address_unconfirmed", beside the existing "counterparty.high_risk". A payment that never reached the network is not sent again to a changed address that no one has confirmed; it is held for a person.

No /api/v1 endpoint, parameter or response changed.

2026-09-29: MCP server

  • A remote MCP server at https://www.vestiarion.xyz/api/mcp, over Streamable HTTP. An AI agent connects with a workspace API key, sent as Authorization: Bearer <key>, and reads that workspace's records through one tool per /api/v1 read operation. A tool returns the operation's JSON exactly. See MCP server.
  • A missing, malformed, unknown or revoked key answers 401 with a WWW-Authenticate header; a key without the read scope answers 403.
  • There are no write tools, and no OAuth.

No /api/v1 endpoint, parameter or response changed.

2026-09-29: Webhooks sent right after each append

  • A ledger.appended delivery now goes out right after the request that appended its entry (approving a payment, pausing the agent, changing a member, a key or an endpoint), not on the next scheduled dispatch. Entries appended by the agent's scheduled run still go out right after that run. The 10-minute schedule remains for retries. See Timing.

No payload, header or signature changed.

2026-09-29: Developer docs, OpenAPI document and llms.txt

  • These docs, at /docs: a quickstart, guides, and a reference page for every endpoint, with a Try it panel that sends a real request with your key.
  • GET /api/v1/openapi.json: an OpenAPI 3.1 document for every /api/v1 endpoint. It is public and needs no key.
  • A Markdown view of every page at its URL plus .md, and /llms.txt and /llms-full.txt: see AI integration.
  • Cursors are checked per endpoint. A cursor that the endpoint could not have issued, such as a ledger cursor sent to /invoices or an altered one, now answers 400 invalid_request. It could reach the database before and answer 500. See Pagination.

No other endpoint, parameter or response changed.

2026-09-29: Signed webhooks

  • An owner or an admin can add up to 5 HTTPS endpoints per workspace in Settings. Each one receives a ledger.appended event for every new ledger entry, and a webhook.test event on demand. See Webhooks.
  • Every delivery is signed with HMAC-SHA256 in the Vestiarion-Signature header, using the endpoint's own secret, shown once when it is added. See Verifying signatures.
  • Delivery is at least once and not in order. A failed delivery is retried up to 7 attempts in total, and an endpoint is disabled after 20 consecutive failed attempts. See Retries and disabling.

2026-09-29: Workspace API keys

  • /api/v1 now authenticates with a workspace API key, vxk_<prefix>_<secret>, sent as Authorization: Bearer <key>. An owner or an admin creates keys on the workspace's Settings page; each key is shown once and reads only its own workspace. See Authentication.
  • Breaking: the platform token, AGENT_API_TOKEN, no longer opens /api/v1, and answers 401. It had read only the founding workspace. Move any caller that used it to a workspace key.
  • A missing, malformed, unknown or revoked key answers the same 401 unauthorized. A key whose scopes do not cover a route answers 403 forbidden.
  • GET /api/v1/status reports the calling key's own workspace, and its configuration no longer includes the deployment's database block.

Edit this page on GitHub (opens in a new tab)