confirm argument, and the dry-run preview
shape. For the plain-language safety model, see
Handlinger & guardrails.
Each connector is its own named MCP at
https://mcp.consile.ai/<id>/mcp with
only its own tools. Tool calls go to the connector endpoint: the aggregate
https://mcp.consile.ai/mcp is the Consile Concierge (management tools only),
not where write tools are called. The transport namespaces every tool as
<id>__<tool> (e.g. economic__create_draft_invoice,
shopify__set_product_status, linkedin-ads__set_campaign_status). The AI
invokes these names on your behalf.Which connectors have write tools
The read-only connectors have zero write tools; every tool on those endpoints is a read. (The upcoming CVR and Billy connectors are read-only too.) Everything below applies only to the write-capable connectors.
Meta Ads is live and served on its own endpoint, but shows as coming
soon in the portal until self-serve purchase is provisioned.
The three guardrail rules
Every write tool on the write-capable connectors obeys the same three rules:- New objects are created paused / draft. A new object is never live: Meta ads are created PAUSED; new LinkedIn, Shopify and HubSpot objects are DRAFT; an e-conomic draft invoice is a draft; a new HubSpot marketing email can never send. It spends nothing and does nothing until you explicitly take it live.
- Money / destructive / public actions require
confirm: true. Anything that spends money (setting a campaignACTIVE), changes a budget or bid, changes a price or inventory, publishes to a live website, sends a marketing email, or archives / deletes an object requires an explicitconfirm: trueargument. - Without
confirm, you get a dry-run. A guarded tool called withoutconfirm: truereturns a preview object describing exactly what would happen and calls no upstream API. Nothing changes until you re-issue the call withconfirm: true.
Default status: DRAFT / PAUSED
Creating an object never makes it live:- Meta Ads:
create_campaign,create_ad_setandcreate_adcreate the object with status PAUSED. It exists, but does not deliver and spends nothing. - LinkedIn Ads: the create tools produce the object in DRAFT status.
- Shopify:
create_productcreates the product as DRAFT (not published to any sales channel). - HubSpot CMS: new pages / blog posts are forced to DRAFT on create; HubDB row writes land in the table’s draft.
- HubSpot Marketing Email: new emails are forced to state DRAFT and can never be sent or scheduled by create/update.
- e-conomic:
create_draft_invoicecreates a draft invoice; every write tool is preview-first (see below).
ACTIVE, publishing, sending, or changing price /
inventory) requires the relevant tool and confirm: true, because those steps
spend money or affect the live surface (rule 2).
The confirm argument
Guarded tools accept a boolean confirm argument.
boolean
default:"false"
Set
true to actually execute the mutation upstream. When omitted or false,
the tool performs no upstream call and returns a dry-run preview
instead.confirm: true to execute) when it would:
- spend money: set a campaign’s status to
ACTIVE(go live); - change a budget or bid: e.g.
update_budgeton Meta Ads; - change a price or inventory: e.g. on Shopify;
- publish to a live surface: a live website (HubSpot CMS), a marketing email
(
publish_email), or public organic-social content (LinkedIn); - archive or delete an object.
requiresConfirm() is always true.
The dry-run preview shape
When a guarded tool is called withoutconfirm: true, it returns a structured
preview of the intended change and makes no upstream request. The exact field set
varies by connector, but the shape is consistent:
Dry-run preview (no confirm)
boolean
true whenever this is a dry-run: no upstream API was called.string
The write tool that produced the preview (e.g.
update_status, publish_email).object
The intended mutation: object type, id, and the field deltas that would be
written if confirmed.
boolean
true for money / destructive / public actions; re-issue with confirm: true
to apply.confirm: true:
Confirmed write (executes upstream)
The AI runs these calls for you. It is expected to show you the preview
and get your go-ahead before re-issuing with
confirm: true. Treat the
preview as the moment to review before any spend, publish or send.e-conomic write tools
e-conomic exposes 4 write tools (of 27 total):create_customer,
update_customer, create_draft_invoice, duplicate_invoice.
- All four are preview-first. The first call never hits the e-conomic API; it
returns a dry-run of the exact request (method, path, body). The change is
applied only on a second call with
confirm: true.requiresConfirm()is alwaystrue. - No ledger posting and no deletion. The connector deliberately cannot post a draft to the ledger and has no DELETE method at all. A draft invoice is a real artifact the bookkeeper sees, but it does not affect the accounts until it is posted manually in e-conomic.
update_customeris a full-record PUT (e-conomic has no PATCH): it reads the current customer, merges only the fields you supply, and strips server-owned fields.duplicate_invoicereads the source, strips id / amount / posting fields and creates a fresh draft.
Shopify write tools
Shopify exposes 10 write tools (of 50 total), limited to the three granted write scopes: products, publication to sales channels, and inventory.- Orders, draft orders, customers and discounts are read-only, and
graphql_queryrejects mutations. - New products are created DRAFT. Going live (publishing or status
ACTIVE), archiving, changing a price, changing inventory or deleting requiresconfirm: true; the first call without confirm is a dry-run preview. - Mutation responses are checked for
userErrors, so a rejected write never looks like a success.
HubSpot CMS write tools
HubSpot CMS exposes 9 write tools (of 23 total).- Draft writes run freely:
create_page_draft,update_page_draft,create_blog_post_draft,update_blog_post_draft,upsert_hubdb_row_draft. A draft never touches the live website. - Actions that hit the live site or discard work require
confirm: true:publish_page,publish_blog_post,publish_hubdb_table,reset_hubdb_draft. The first call without confirm returns a structured preview and calls no HubSpot API. - HubDB row writes land in the table’s draft and stay invisible on live pages
until
publish_hubdb_tableruns. No hard deletes in v1.
HubSpot Marketing Email write tools
HubSpot Marketing Email exposes 11 write tools (of 19 total).- Free, reversible draft writes (4):
create_email,update_email_draft,clone_email,create_email_ab_variation. They only work in draft and can never send; new emails are forced to state DRAFT, and create/update never acceptstate,publishDateorsendOnPublish. - Confirm-gated writes (7):
update_email(mutates the live version),publish_email(sends a real email, highest risk),unpublish_email,delete_email,reset_email_draft,restore_email_revision,restore_email_revision_to_draft. Withoutconfirm: truethey return a dry-run preview; the second call withconfirm: trueexecutes. Sending to real recipients is possible only via the explicitly confirmedpublish_email.
Meta Ads write tools
Meta Ads exposes 5 write tools (of 39 total):LinkedIn Ads write tools
LinkedIn Ads exposes 19 write tools (of 64 total): 11 ad-management tools plus 8 organic-social tools.- Ad-management writes follow the standard model: new objects are created in
DRAFT; activation, budget/bid changes, and archive/delete require
confirm: true, otherwise a dry-run preview is returned. (Measurement writes such as creating/updating a conversion rule apply without confirm.) - Organic-social writes publish public content, so they are confirm-gated by the same rules.
Why read-only connectors are different
To restate the boundary precisely: Google Search Console, Uniconta and Dinero ship no write tools at all (and so will the upcoming CVR and Billy connectors). Their safety is structural, not behavioural: there is no mutating handler to gate. For example, the Uniconta balance tooluniconta__get_account_balance only reads a
balance; there is no Uniconta tool that posts an entry or edits a record.
The guardrail machinery on this page exists specifically because the write-capable
connectors can write. For the full plain-language model, see
Handlinger & guardrails.
A failed or rejected upstream write surfaces as a normal tool error (e.g. a
400/403 from the provider, or LinkedIn’s 403 for un-approved
organic-social tools). See Errors & limits.