> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cfo.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP tools and call shapes

> Reference for agents and developers: the cfo.ai MCP server's address, sign-in, and limits; every published tool and its actions; the one-action-block call shape and its refusals; workspace selection; results; pagination and truncation; and what is not published.

The cfo.ai MCP server publishes 36 tools: Ari's public product tools plus three MCP-only tools, `list_orgs`, `inspect_chats`, and `edit_chats`. This page describes the server, each tool, and the conventions every call follows. To connect a client, follow the [Agent instructions](https://docs.cfo.ai/agent-instructions.md).

## Server

| Fact | Value |
| - | - |
| Address | `https://api.cfo.ai/mcp`. `https://api.cfo.ai/mcp/v2` serves the same tools; use `/mcp` for new connections. |
| Transport | Streamable HTTP, stateless. Each request authenticates and selects its workspace on its own, and the server neither issues nor requires an `Mcp-Session-Id`. |
| Sign-in | OAuth. A person approves the client in a browser, and the client sends the token it receives in the `Authorization` header. The protected resource metadata is at `https://api.cfo.ai/.well-known/oauth-protected-resource/mcp`, and clients register themselves through dynamic client registration or a client ID metadata document. |
| API keys | None. cfo.ai issues no API keys or access tokens to copy; every client signs in as a person and acts as that person. |
| Instructions | The server sends cfo.ai's modeling instructions when a client connects. |
| Tool list | Fixed for each server process. The tool list carries a five-minute private cache hint, and the server advertises `listChanged: false`. When a client's definitions are stale, refresh its tool list or start a new conversation. |
| Request size | A request body holds at most 1 MiB. A larger one is refused with **The MCP request is too large.** |
| Batches | JSON-RPC batch requests are refused with **JSON-RPC batches are not supported.** |
| Rate limit | 60 calls a minute for each tool, per user and workspace; `list_orgs` has no limit. A call past the limit fails with **rate limit exceeded for** followed by the tool name. |

## Published tools

A tool marked read-only never changes saved state. The **Actions or fields** column lists a multi-action tool's blocks; for a single-purpose tool it lists the fields it takes directly.

### Tables, formulas, and mappings

| Tool | What it does | Actions or fields |
| - | - | - |
| `inspect_table_blocks` | Read-only. Lists saved tables, reads cells with their formulas and sources, compares a table with an earlier saved state, and reads Variables, Dimensions, and their items. A `list` reads one Scenario; without `target` or `page` it also carries `other_scenarios`, each other Scenario the user can read that holds saved tables the listed Scenario does not, with `tables_not_in_this_scenario` counting them, or `[]` when none does. `read.rows`, `read.columns`, `compare.rows`, and `compare.columns` accept one selector as a plain string as well as a list. A day or month that matches no column of a coarser table selects the period that contains it, such as Q4 for December, and a note names the requested date, the period returned, and its grain; an exact match wins, and a date two periods contain stays ambiguous. A `read` follows the table's saved choice to hide empty items, and a selector for an item the table hides is refused with the item, its Dimension, and the rule or saved filter that hides it, so a hidden row is not reported as missing. A row or column selector that names a period outside the saved window is refused with the saved window and a pointer to `list`, which reports other tables' windows; the refusal proposes no change to the table. A `period_range` that reaches past the window is not refused: it returns the periods inside the window with a `read_note`, as described under [Results](#results). A `list` entry summarizes the saved table under `summary`: `rows` and `columns` count its top-level entries, `first_rows` names up to five rows, and `window` is its saved window; a table that places a Variable or Dimension you cannot read keeps its summary and carries `layout_problem` **This saved table includes a property you cannot read.** `read.rows` and `read.columns` also take predicates over each item's own value, such as ``Invoice where `Days overdue` > 0`` beside item attributes such as `Employee where Employee.Department = "Engineering"`, for a Variable stored once per item; a Variable whose value varies by month, including through a default formula that reads monthly inputs, or by another Dimension is refused, and a period refusal returns the complete filter with an example month from the table's window, the read's Last close month when it falls inside it. A `next.after` cursor passed back beside the Scenario it was issued for continues even when the two spellings differ, such as `Base` beside a cursor that names `Base#52f`, when both name one Scenario at the read's saved version; a different Scenario is still refused. A `variable` read that names a Dimension, or a `dimension` read that names a Variable, is refused as `invalid` with **\[name] is a \[kind].** and the read that shows it; nearby-name suggestions cover both kinds and hand-added items, naming their Dimensions, and a missing breakdown row names up to three tables that break the Variable down by that Dimension. | `list`, `read`, `compare`, `variable`, `dimension`, `items`, `bounds` |
| `edit_table_blocks` | Creates, updates, reshapes, copies, or deletes saved tables in one atomic change each. A `create` puts the table on an existing Page named by `page`, or on the Page in view; it creates no Page, and a missing one is refused with a pointer to `edit_pages`. A saved table has no row count of its own; one write resolves at most 10,000 operations. Writes to one Page's tables in a Scenario run one at a time, as do all creates and cell writes, and a write not committed by its time limit saves nothing. Table settings cover what a person sets by hand: a `style` with `scale` (thousands, millions, or billions), `negativeNumbers` (`MINUS` shows -1,250 and `PARENTHESES` shows (1,250), in every number format at the cell's decimals and scale; where no scope of the table sets it, the workspace display from `edit_org` `negative_numbers` applies, and without one negatives show `MINUS`), and text `color`, a Dimension's `color`, each column's `width` and `pinned` in `column_updates`, and `formula_width` and `row_header_width`, all widths at least 100 px. `row_totals_at_bottom`, on an `update` or under `settings` in a `reshape` layout, saves where each row group's total shows: `true` shows a label-only heading above each expanded group's details and a Total row below, nested groups included, a collapsed group shows one total row, and Excel exports follow it; `false` keeps totals above details. Reads return it under `presentation.row_totals_at_bottom`. Writes every model formula, and sets time rollups and the Scenario's calendar. A `create` with a `tables` list saves them in one change, and a formula in any table names what any table of the list declares, whatever the order. `remove_items` deletes a member together with its rows on every table and the formulas whose condition selects only it, and the receipt's `members` counts them as `removed_rows` and `removed_rules`. `row_updates` takes `label`: a Dimension mapped from the rows' Dimension and shown as a field column, such as Name beside Employee ID rows, so each row shows its Name while its Employee ID stays its identity; `{"inherit": true}` shows the members again. A Dimension not mapped from the rows' Dimension, or one without a field column on the table, is refused with the candidates, and reads name the saved label; a `label` naming a mapped field whose column the table does not show adds that column in the same write, and a table whose rows hold Variables refuses it, because Variables take one axis. `dimension_display` on an `update` saves **Display as** for each named Dimension on the table, `PILL` or `PLAIN_TEXT`, for every viewer; a Dimension not on the table is refused, and reads return the saved choices under `presentation.dimension_display`. A `delete` of Variables needs no `target`: each Variable uses its own table, or the only readable table that shows it, several matches need `target`, and the receipt names the tables; the whole deletion saves together or not at all, and still needs `force` to confirm. An `add_dimension_items` entry placed `under` a parent with business items stays under that parent, with no model-wide membership; an item added with no such parent is model-wide, an existing model-wide item keeps that scope, and the receipt reports `scope` and `shown_at`, the parent paths the table shows it under. A `members` list or condition on a row or column replaces the whole saved filter, so a condition replaces a fixed list and a list replaces a condition, `[]` clears it, and omission or `null` keeps it. An item name in `members` matches exactly first; when no exact item exists, surrounding spaces are trimmed to find one. A numeric item matches by value, so `96`, `96.0`, and `9.6e1` select the same employee ID in reads, filters, and cell writes, while a text item still needs its exact text; a `create` finds imported and formula-computed numeric items as well as manual ones. A cell value must fit the Variable's type: a number for a number Variable, a string for text, date, and UUID, a boolean or exactly 0 or 1 for a Boolean, and `null` for any; one value of the wrong type refuses the whole write, naming the cells by row and column label and noting that `variables` with `data_type` can change the type in the same write. A read reports mismatches already saved under `literal_type_mismatch`, with a count and up to five samples; a person's edit in the app still saves as typed. A formula save, or a row insert, also warns when a formula on a row reaches the lines under it without reading their Dimension, so each line would show the row's whole amount, such as **In Main, Revenue's rule also reaches the P\&L Account lines under each TEAM; it does not read P\&L Account, so each line shows its TEAM's whole amount.** Copying a `list` result's pins and column widths into an `update` is accepted when they match the saved values and refused when they differ, with `column_updates` as the one writer for them; an explicit `show_empty_members` wins over a copied value. A table with `columns: []` and Variable rows, with or without business breakdowns, needs `window.granularity: NO_GRANULARITY` and shows one **Value** column; `list` returns that layout in a form `create` and `update` accept. In a `create` with a `tables` list, an invalid layout gets one explanation at its own position, such as `/create/tables/1`. A create, reshape, or structural insert that leaves a Variable in two or more rows or columns of the table, where it had fewer, reports it under `duplicate_placements` with `before`, `after`, and each placement's ref, rows and columns inherited from the parent Scenario included; the repeats save as requested, and a rename or formatting write adds no notice. A new numeric currency row takes its currency code from its formula inputs when every Variable input shares one code, else from the table's other money rows when they share one, else from a code at least 90% of the workspace's coded numeric Variables use; a workspace with no saved code keeps the USD display, and any other unresolved case refuses the whole write, listing the workspace's codes and the Variables and inputs without one, and accepts `variables[].currency` with the same new names. Replacing the whole item list of a Dimension that gets its items from imported data is refused with **dimension "\[name]" gets items from imported data; replace\_items is unavailable. add\_items and remove\_items support manually added items**. | `create`, `update`, `reshape`, `copy`, `delete`, `set_time_rollup`, `update_calendar` |
| `inspect_dimension_mappings` | Read-only. Lists the mappings a reporting Dimension owns, or reads one lookup chosen by its exact source keys. `pairs` and a row's `item` hold fixed items only; a row whose mapped value a formula calculates carries `formula` in place of `item`, written with Dimension names, such as `$[Practice = "Group"].Practice`, so a count of the items a Dimension maps to counts real items and a pair copied back into `edit_dimension_mappings` `map` never saves formula text as an item. A lookup whose rows all map to formulas reports `"pairs": {}`. `catch_all` is a fixed item as its item, or a calculated fallback as a formula in Dimension names. A row whose mapped value or condition reads a Variable or Dimension the user cannot read is counted in `unreadable_rows` and not shown, so no name the user cannot read appears; the `edit_dimension_mappings` receipts (`catch_all` and the removed rows) apply the same check. | `target`, `keys`, `limit`, `after`, `scenario`, `as_of_point` |
| `edit_dimension_mappings` | Maps items of source Dimensions to a reporting Dimension's items, sets or clears the catch-all, removes rules or lookups, and combines or splits compatible source Dimensions. A removal that leaves no lookup on the target also removes its catch-all, since a fallback is the item for records no lookup row matches; the receipt lists it under `removed`, reads `catch_all` back as null, and warns once. A removal that leaves another lookup keeps it, and `catch_all` can still set a fallback before the first `map`. `map` takes `replaces_keys`, the source fields of one existing lookup to replace in the same save, so title and department can take over from employee ID without a saved state in which neither lookup exists; the save replaces the lookup's rules together or saves nothing, other lookups and the fallback stay, and `replaces_keys` that names no lookup on the target is refused. | `map`, `unmap`, `catch_all`, `clear_catch_all`, `drop_mapping`, `combine_dimension`, `split_dimension` |

### Pages and Canvas blocks

| Tool | What it does | Actions or fields |
| - | - | - |
| `inspect_pages` | Read-only. Reads the page tree, each Page's blocks in order, saved table settings, and reusable references. Each Table block in a `read` carries its saved `layout` (`rows`, `columns`, and `settings` in the shape `edit_table_blocks` `create` and `reshape` take, with each axis's filters, Date groupings, roles, and children, and the names of the formula ranges `settings.formula_breaks_hidden` hides), its `signature`, and its `presentation`. When the table places a Variable or Dimension you cannot read, all three are left out and `layout_problem` reads **This saved table has structure that cannot be represented safely: it shows a property this read cannot name.** Each Page in a `list` or `read` carries `created_by`, from its first saved change: the workspace member's `display_name` and `kind`, `is_current_actor`, and, when Ari made the Page, `ari_chat` as `this_chat` (this conversation, its task steps and background imports included) or `another_chat`. `kind` is `unknown` when the record names no member, and a Page made before change logs recorded the chat has no `ari_chat`. A `read` with `include_text` returns the Page's own prose as `markdown`, with each live block in place as a marker such as `[TABLE block: Name#a1b]`, and the Page's `document_revision`, which `edit_pages update_text` takes to refuse a stale edit. | `list`, `read` |
| `edit_pages` | Creates, renames, moves, shares, and deletes Pages; sets page icons and date ranges; adds and edits Text blocks; reorders and removes blocks; creates share links. A Page date range sets the window of every table, chart, and Canvas dataset on the Page; a Canvas dataset whose window is `pinned` keeps its own. A `move` renumbers only the sibling Pages the user can edit; a sibling they cannot read, or can read but not edit, keeps its saved place. When two such fixed siblings leave no room for the requested position, or the position would put the Page below a fixed sibling that has no saved position, the move is refused with **the requested position is not available with your page access**. A Page whose read access was removed after the call resolved it is refused with **page \[id] is not available with your page access.** and nothing is renumbered. An `update` that moves a Page under a new parent follows the same rules. A Page whose parent a Scenario deleted, such as a subpage Main added under a Page the Scenario removed, is a top-level Page in that Scenario. `update_text` with a Text block target replaces that block; with a Page reference as `target` it replaces the Page's own prose from `markdown` or `text`, keeping every embedded block marker once, in its saved order and nesting, since `reorder_blocks` and `delete_block` own the blocks. Prose around an unchanged marker can change as much as it likes; the live block stays. A refusal names the first marker that is wrong and lists the markers in their saved order: a marker whose count differs from the saved page, `page Markdown contains 0 occurrences of "[TABLE block: Revenue#a]"; the saved page contains 1; saved marker order: [...]`; one that `appears in the text but not as its own block, so the live block would be lost`, such as a marker inside a sentence or a code block; one that `would repeat the live block`; or one that `is out of order (position 2, saved position 1); page-text edits keep live blocks in their saved order`. A change to how blocks nest is refused with `the page's embedded blocks must keep their saved nesting; page-text edits change prose`. Pass the inspected `document_revision` to have the edit refused when the prose or block membership changed since that read: **The page's prose or block membership changed since the supplied document\_revision was read.** Identical Markdown changes nothing. A `delete` of a Page that holds blocks, sent without `force`, saves nothing and answers with the Page's blocks, the Variables and Dimensions the deletion would remove, and the formulas and blocks elsewhere that would break; a Variable or Dimension still shown on another table survives, and its references are not counted. A completed Page, table, or block deletion labels the references it broke, an empty list meaning the check found none, with unreadable ones as a count and an oversized list cut to an omitted-entry count. Confirmation refusals and completed deletions of Pages, tables, charts, Canvas blocks, Variables, and Dimensions also name the user's own Triggers whose instructions name what is removed, with their owner, under `dependent_schedules`, and `dependent_schedules_omitted` counts the ones a full result left out; only the user's own Triggers are checked, paused ones included, and a Trigger that names the object in plain prose rather than a quoted name or `Name#hex` reference is not listed. | `create`, `update`, `move`, `share`, `create_share_link`, `delete`, `add_text`, `update_text`, `delete_block`, `reorder_blocks` |
| `inspect_canvas_blocks` | Read-only. Reads selected Canvas blocks: saved source and its `source_hash`, dataset layouts and Scenario bindings, display state, position, revision, and references. Each `dataset_layouts` entry is the `edit_canvas_blocks` `datasets` entry that saves it, `{name, scenario, layout, window}`, or carries `layout_problem` when a Canvas write cannot declare the saved layout; see [Read saved Canvas blocks](https://docs.cfo.ai/agents/canvas-blocks.md#read-saved-canvas-blocks). | `target`, `page`, `scenario`, `as_of_point`, `source_offset` |
| `edit_canvas_blocks` | Creates a Canvas block on a Page, or changes one. A whole `source` on an `update` names `based_on`, the `source_hash` of the read or write it was written from, and saves only while the saved source still has that hash; see [Change a saved block](https://docs.cfo.ai/agents/canvas-blocks.md#change-a-saved-block). | `create`, `update` |
| `inspect_canvas_library` | Read-only. Finds Canvas components and templates, and reads their instructions and props. | `list`, `read` |
| `validate_code_blocks` | Read-only. Renders up to 8 saved Canvas blocks in a browser and reports errors, warnings (including **Design:** findings that name an element, what was measured, and the fix; see [What `validate_code_blocks` reports](https://docs.cfo.ai/agents/canvas-blocks#what-validate_code_blocks-reports)), what each chart plotted, guide anchors, and, on request, a screenshot: the full Canvas, a fixed `desktop-opening` or `phone-opening` view with an independent design assessment billed to the workspace, or a measured `viewport`. | `target`, `scenario`, `visual_review` |

[Canvas blocks for agents](https://docs.cfo.ai/agents/canvas-blocks.md) covers these tools in detail.

### Scenarios and history

| Tool | What it does | Actions or fields |
| - | - | - |
| `inspect_scenarios` | Read-only. Reads Scenarios, their owners, Snapshots, and descendant trees. | `list`, `read`, `subtree` |
| `edit_scenarios` | Creates, renames, snapshots, merges, or deletes Scenarios. `create` makes a regular Scenario on Main, or, with `based_on` naming another Scenario, a copy of it: a regular Scenario with the same base that holds that Scenario's own changes, so later changes to the shared base show in both and edits to one stay in it. With `based_on` naming a Snapshot, the copy is an editable Scenario on Main that starts with the Snapshot's pinned state and the edits saved in it since; a Snapshot still cannot be snapshotted again. A Snapshot is a pinned, editable copy: changes flow neither from its source into it nor from it back to the source, so a `snapshot` result names the source, and a Page, Canvas, table, or mapping save into a named or currently viewed Snapshot adds one reminder that the source does not receive the edit. | `create`, `rename`, `snapshot`, `merge`, `delete` |
| `inspect_history` | Read-only. Reads the changelog, the net difference between two points in time, and what a Scenario would merge into its parent. For a Scenario with a parent, `changes_between_points` lists the Scenario's own edits in `changes` and counts the changes it shows only because its parent or an ancestor made them over the same range in `inheritedChanges`, with `parentLayerId`, `count`, and `resources` by resource type; the parent's own diff over the same points lists them. Main's diff has no `inheritedChanges`, and a Scenario's `changelog` still lists the entries it inherited from Main. | `changelog`, `changes_between_points`, `scenario_summary`, `read` |
| `edit_history` | Undoes or redoes changes, or reverts a Scenario to a past changelog entry. Each operation returns its new changelog entry and the action that reverses it. Undo and redo restore only the fields the listed entries changed, so later edits to a record's other fields stay; when a later entry edited one of the same fields, the call answers `error_kind: conflict` with `Nothing changed: reversing changelog entry [N] would replace later edits: changelog entry [M] changed the [fields] of [record].` and saves nothing. | `undo`, `redo`, `revert` |

### Connected data

| Tool | What it does | Actions or fields |
| - | - | - |
| `inspect_integrations` | Read-only. Reads saved connections with their readiness and safe next action, the integration catalog (provider integrations, and under `mcp_servers` and `apis` every hosted MCP server and API cfo.ai connects, each with its `display_name` and a `description` of what it provides; a `query` or `category` read adds each match's category, endpoint or base URL, authentication kind, and documentation link), permitted API endpoints, connection-link progress, ingestion status, sync setups, saved API and MCP settings (admins only), saved queries, and ingestion jobs. `query_results` runs one saved query and returns its rows without adding data to the Model; it runs in Snowflake for every connection, a file upload included, which is where the query's loads run. It reads a `linked` connection, and also a `relink_required` one, whose sign-in lapsed but whose synced tables stay in the warehouse: that read carries `saved_data`, with `connection_status`, `last_synced_at` (when the newest completed sync finished, or `null`), and a `detail` sentence saying the rows are what earlier syncs saved, and the connection row reports `warehouse_readable: true`. A connection in any other status (`pending`, `partially_linked`, `failed`, `disconnected`) answers `ok: false` with `error_kind: blocked`, **\[Connection] is \[status], and a warehouse read accepts a connection that is linked, relink\_required, or COMPLETED.** followed by **No completed sync is recorded for it.** or **Its last completed sync finished at \[time].**, the fields `connection`, `connection_status`, and `last_synced_at`, and a `hint` naming the `edit_integrations` action that accepts the connection: `request` continues a `pending` or `partially_linked` authorization, and `relink` opens a new sign-in for a `failed` or `disconnected` one. While a sync is under way, a read of a whole connection counts the rows its saved queries have already published in the model under `materialized` and `materialized_rows`; a read of one run reports only that run. `outcomes` also lists the user's own recent sign-ins to this MCP server. `sync_setups` for an MCP server carries `sync_page`, which states how one sync page calls the server and its 45-second allowance. `sync_setups` for one source also carries `ingestion_connection`, one sentence that says whether the source already has the ingestion connection its setups load through, or whether its first saved setup creates one, which is exempt from the plan's integration limits, and in that case whether the workspace can add it now or the plan refuses it and why. A QuickBooks Online connection row carries `accounting_basis`, `cash` or `accrual`; a row without it has synced on accrual and reads the company's preference at its next sync. A catalog entry for a Fivetran file store carries `loads`, which says how the store's files reach cfo.ai: Box, Dropbox, and SharePoint copy every file in the chosen folder as it is, for Ari to list and read; OneDrive loads each tabular file, one table per file or worksheet; the bucket, server, and mailbox stores load every file matching the setup's pattern into the connection's one table, archives included; and files in other formats, such as PDF and Word documents, are not synced by a store that loads rows. A completed query job and an ingestion summary carry `conversion_notes` in two cases: when timestamp values lost fractional seconds beyond milliseconds, naming each column and its count, the published precision staying milliseconds; and when a date column holds dates before 1900 or after 2299, which month, quarter, and other period formulas leave out, one note per column with the count, one example (the source text when it is at most 256 bytes, else the date) and that example's 1-based row in the query result: **\[untrusted\_source\_data] Found 1 date in column "Due Date" with unsupported calendar periods, including "10/30/3036" at source result row 7. Formulas that read this column by month, quarter, or another period leave these rows out. Exact-date filters can still match them. The source values were not changed.** A failed import adds no note, and each completed import reports only its own. `jobs` pages one named raw job's tasks with `tasks`, `task_limit`, and `task_after`; a job list and a query job carry no tasks, so `tasks: "none"` is the one `tasks` value they take. `ingestion` marks a saved query `stale` when its SQL reads a warehouse table that a completed sync did not refresh, however recently the query ran: a table counts as stopped from the first completed sync after its last refresh that did not refresh it, including a later sync that did not run it, until a sync refreshes it again. A sync that failed outright stops no table, because the result already reports `latest_raw_sync_failed`. A `query` read of one saved query, or `*` for every query, carries each model property's `value_coverage`: `rows_with_value` out of `total_rows` in the published result, counted before formulas, aggregation, or table filters, where zero and false are values and null and blank text are not; the field is absent for a run published before counting began, and a read scoped to one run leaves it out. `inspect_table_blocks` returns the same `value_coverage` under a sourced Variable's `source`. An `ingestion` read carries `source_read_note` when the source needs explaining, such as a Gmail connection through Fivetran, which reads the synced mailbox only after Fivetran's first mailbox sync and has no live message search. While a saved query of a source is being saved, by Ari or by a person editing its SQL in the app, the source's readiness carries the one blocker `query_save_pending`: its fields are withheld as not yet settled, and an ingestion start or hand-off for it is refused until the save finishes; a save rejected as expired changes nothing. For `connections`, `provider` is an optional filter that matches any part of the source's stored identifier or catalog name, ignoring case, so `quickbooks` finds QuickBooks Online through Merge and `netsuite` finds NetSuite SuiteAnalytics through Fivetran; an exact connecting service or display name also matches, and each row names the service in `provider`, the source in `integration_slug`, and its catalog name in `integration_name` when known. For `sync_setups`, `provider` is the required connection kind, `api` or `mcp`; a named connection of the other kind is still returned with its actual kind when the name identifies one source, and an ambiguous name is refused. A `catalog` search that matches no source and names an AI tool, such as Claude, Anthropic, ChatGPT, OpenAI, Codex, Cursor, Gemini, Copilot, or Windsurf, adds `ai_client_access` with the cfo.ai MCP server address, the browser-approval setup, `api_key_required: false`, and the setup guide, because such a tool works on the Model through this server rather than as a data source. `sync_setups` for an MCP connection also carries each setup's `definition_changes`: the last ten decisions cfo.ai made when the server's tool definition changed, each with its time, `status` (`automatically_repinned`, `suspended`, or `awaiting_classification`), `reason`, whether the saved arguments were checked, and whether the connection's worker was told. With `page` naming one saved MCP setup, the read runs the setup's first request and returns the answer under `page.value`, the value `records_path` and the pagination function read, with `page.rawAnswer` true when the whole answer was kept; it needs an allowed read-only tool, saves no rows, and a worker may read only its own connection. A `queries` read lists each Variable and Dimension a query loads with `creation` (`created` when the query owns the Variable or Dimension, `reused` when an older shared Dimension predates it, absent when a shared Dimension was created later) and, for a created one, up to three older `same_name_properties` (`ref` and `display_name`, oldest first) with `same_name_property_count` in all. An `ingestion` read's `query_complete` is true only when no run is under way and, for each saved query run since the newest sync, or in the requested run, the newest attempt completed; a newest attempt that failed or was cancelled makes the import read `failed` with that query's reason, and a later successful rerun, started separately or not, repairs it. The answer carries `run_id`, the lifecycle it read: a stored ingestion run when known, else the worker session, so a `started_after` poll identifies the run it saw and a completion notice for a run a scheduled report already covered is not delivered again. | `catalog`, `connections`, `outcomes`, `endpoints`, `connect_progress`, `ingestion`, `sync_setups`, `configurations`, `queries`, `query_results`, `jobs`, `query_deletion_preview`, `read` |
| `edit_integrations` | Opens connection setup for the user, connects, re-links, and deletes connections and saved queries, including saved queries whose connection was deleted, edits a saved API or MCP connection's name, address, or authentication, saves queries and sets their column roles, applies query templates, starts and cancels query and raw-sync jobs, starts ingestion, ingests a CSV, saves API and MCP sync setups, chooses synced tables, and sets daily refresh times. A `save_setup` the workspace plan refuses, because the source's first saved setup would create an ingestion connection the plan does not admit, such as in a workspace with no active trial or plan, returns the same structured refusal that connecting an integration returns, opening "The setup was not saved: this source's first saved setup creates its ingestion connection, and …" with the plan's reason and a pointer to Settings → Billing. `save_query` returns the saved query with `other_queries`: the connection's other saved queries in the Scenario that the caller may read, each with `ref`, `display_name`, `source` (`template`, `agent`, or `user`), and `property_count`, sorted by name, so a second query over rows the Model already holds is visible at once. Its `property_plan` names, for each planned column, the existing Variables and Dimensions with the same name under `same_name_properties` (up to three, with `same_name_property_count` in all); a name match says nothing about whether the query will reuse them, which the run's result reports as `creation`. A `save_setup` for an MCP sync takes `records_path`, a JSON pointer to the array of objects in a page's value; when a tool answers with a status line beside its data, as separate text blocks, the whole answer is the value and each JSON text block is parsed beside its text as `json`, so `/content/1/json/result/records` selects the records in the second block, and an empty `records_path` cannot make a whole answer one record. `set_accounting_basis` takes `target` and `basis`, `cash` or `accrual`, for a QuickBooks Online connection: it saves the basis its P\&L and balance sheet sync on, starts an import that requests every month on it, and answers `changed` and whether the `sync` began. `save_query` saves an edit that stops loading a column nothing in the Model uses without `force`; dropping a column with model dependents or custom formulas, including formulas that read the source column directly and formulas in Scenarios that inherit the edit, still needs `force`, and hidden dependents block the save without being named. `request` with an `api` block accepts an OpenAPI 3 or Swagger 2.0 definition, as JSON or YAML, from a `spec_url` that may start with `http://` (fetched at its `https://` address) or inline in `spec_json` of up to 64 KiB; the usable operations import even when others are defective, and the result reports the imported count, the skipped operations with their reasons, operations kept without a response schema, and missing local references, while a definition with no usable operation is refused with the skipped count and the first three reasons. `update` changes a connection's name, address, or authentication; for an API it also takes `spec_json`, an OpenAPI 3 document whose operations and components are added to the saved definition or replace the saved ones at the same path and method or name, on the same connection and key, so an endpoint it leaves unchanged keeps its permission and sync setups and a setup whose operation changes is suspended. `spec_url`, the public HTTPS address of an OpenAPI document, replaces the whole definition instead: operations the document lacks are removed, an operation at a saved path and method keeps its permission, a setup whose operation changed or was removed is suspended and named under `suspended_sync_setups`, the result lists `added`, `removed`, `changed`, and `count`, and the connection records the address as its source. A definition change is the update's only field, and a call with both `spec_json` and `spec_url` is refused. A connection that signs in through the provider with OAuth keeps its sign-in and server address and takes a new name only. A `save_setup` for an API or MCP sync has these limits. The setup's `arguments` and its `pagination_function` or `incremental_function` source have no byte cap; an empty pagination function is refused with **pagination function is empty**, and every call still parses the source within the sandbox's 500 ms. A pagination function's returned `args` may be at most 32,768 bytes of JSON larger than the run's starting arguments (an incremental checkpoint's, larger than the setup's saved arguments), its `state` at most 500,000 bytes of JSON, and the whole returned object the sum of those plus 4,096 bytes; a failure names the part over its limit and, during a fetch, the page: **page 3: pagination state is \[N] bytes of JSON; the limit is 500,000 bytes**. A function that fails names its cause: memory (**ran out of memory; the JavaScript engine has 64 MiB**), time (**ran past its 500 ms execution limit**), a result that is not a synchronous object, an engine fault, or a thrown error with its built-in name and, for `new Error(...)`, its line and column; thrown messages are left out because they can quote response data. Every fetch stops at 10,000 pages; an upsert, append, or incremental sync, which holds its whole result, stops at 16 MiB in all with **fetched result exceeds 16 MiB, the limit for a sync that holds its whole result at once**; an API page stops at 1 MiB and an MCP server page at 2 MiB; and a run stops at 10 minutes with **the sync task reached its 10-minute limit**. `share_link` mints one connect link for someone else who holds the logins: `sources` names up to 10 catalog sources in the order the opener should see them, and `access` is `anyone`, the default, for a link that needs no cfo.ai account, or `members` for a link only a signed-in member of the workspace can open; the result carries the URL, which expires in 7 days, and the links a workspace has sent are read with `inspect_integrations` `connect_progress`. `relink` takes the same `share_link` field to return a forwardable re-sign-in link for a connection instead of re-authenticating in this chat; a scheduled run always gets a `members` link. `start_ingestion` with `user_intent` sends the request to the connection's background ingestion worker; when that worker is already running, the request joins its instructions and the result says whether it starts a turn or is queued, so a busy connection refuses nothing. A request made while the connection is syncing is accepted too: it waits for the sync and for any earlier worker on the connection, then runs, and the asking chat receives the completion report, or one notice when the request could not start within 24 hours. A `save_query` on a connection where a run is choosing its SQL waits for that read, and a run that starts while a save is under way waits for the save and uses the saved SQL; a save that cannot take the connection's turn within 45 seconds answers a conflict with a retry hint. `start_ingestion` with `full_history` re-reads the whole history of a QuickBooks Online or Xero connection through Merge, or of a Plaid, Stripe, or Rillet connection, reruns its saved queries into Main, and notifies the chat that started it when it finishes; every other provider is refused, `full_history` cannot be combined with `user_intent`, a connection another run already owns answers `blocked` with that run's summary, and a repeat from the originating chat returns the existing run. `start_raw_sync` syncs selected tables only: it runs no saved queries, leaves the model unchanged, and sends no completion notice; `history_start_year` exists only there. When the connection already has a sync pending or running, `start_raw_sync` returns that job with `already_active: true` and a receipt that says nothing changed, when the caller may read it; a caller who may not read it gets a blocked result that says a sync is running without naming it. A `delete` of an API connection removes it from the workspace and stops cfo.ai from using its stored credential, which a saved connection keeps even while unused. `ingest_csv` takes `size_bytes` from 1 to 524,288,000 (500 MB) for an uploaded file and `csv_content` of up to 256 KiB inline; an upload keeps one landing query, so the **Uploaded CSV** template is not added beside a query Ari or a person wrote. `request` with an `mcp` block describes an MCP server from its official documentation: `display_name`, a public HTTPS `endpoint`, `auth_type` (`oauth` or `bearer`), `docs_url`, and, for OAuth, an optional `registration_method`: `dcr` (dynamic client registration) or `cimd` (a client ID metadata document). A named method is tried with a fresh client identity and no automatic fallback; with `bearer`, or with any other value, the call is refused with **registration\_method requires OAuth and must be dcr or cimd**. Omitted, the sign-in starts with cfo.ai's configured method, and when the provider answers a dynamic registration with a 4xx status other than 408 or 429 and advertises client ID metadata documents, it is retried once with `cimd`. Credentials go through the secure form the person fills in, an API's endpoints come from its saved OpenAPI definition and an MCP server's tools from the server, and a person sets each one's permission in Settings or with **Always allow** on an approval card. | `request`, `connect`, `relink`, `share_link`, `update`, `delete`, `delete_query`, `apply_query_templates`, `save_query`, `set_query_column_role`, `start_query`, `start_raw_sync`, `cancel_job`, `start_ingestion`, `ingest_csv`, `save_setup`, `delete_setup`, `select_source_tables`, `set_refresh_time`, `clear_refresh_time`, `set_accounting_basis` |
| `call_connected_api` | Calls one endpoint of a connected third-party API. The server supplies the credentials and enforces permissions. A JSON response larger than one result comes back with its largest list cut to the first items that fit and every other field whole, except a value nested too deeply to filter, which is omitted as described below; `message` states the list's path, how many of its items were kept, that a next-page cursor in the body follows every item including those left out, the value of the last kept item's `id` key when that key holds a string or a number, and the endpoint's integer query parameters with the values the request set. The request ran once, so a read is safe to repeat with the endpoint's own pagination or filter parameters. A write to an endpoint whose definition declares an `Idempotency-Key` header is sent with a key derived from the chat, the connection, and the action the request asks for, and the result's `idempotency` field says so: an identical request sent earlier in the same chat carried the same key, so an API that honors the key answers with the earlier result instead of applying the write again, while a different argument, another chat, or a call from outside a chat gets a new key. How long an API keeps a key is up to the API; after its window the same request applies again. When Ari calls this tool, credential values in the response read `[redacted]` before Ari, a sandbox program, or stored history sees it: in a link, each parameter named as a credential, such as a signature, security token, key, or code; elsewhere, fields and text holding passwords, keys, or tokens. In a header list, only an email message's own headers come through with their names and values: `From`, `To`, `Cc`, `Reply-To`, `Subject`, `Date`, `Message-ID`, `In-Reply-To`, and `References`, each as a `{name, value}` object or a `[name, value]` pair whose value is not one run of 40 or more key-like characters and carries no credential. Every other header entry is redacted whole, name and value. The key or token the connection signs in with is redacted wherever it appears in that connection's results and errors. A link's other parameters and a list's next-page cursor stay, the result then carries `credentialsRedacted`, and a link with a redacted parameter no longer opens what it named. A result nested too deeply to filter comes back as `[omitted: nested too deeply to filter]` rather than failing the call. A client of this MCP server receives the response unfiltered. A complete binary response, such as a PDF, ZIP archive, image, or spreadsheet, is saved to the chat as an attachment and comes back as `file` with `attachment_id`, `filename`, `mime_type`, and `size_bytes`; the bytes stay in the chat, where Ari reads them, and a client of this MCP server receives this metadata only. A file is read up to 50 MiB, JSON and text up to 1 MiB, a larger response saves no partial file, and a file that carries one of the connection's own credentials is withheld. An HTTPS redirect to another host is followed with the original headers, cookies, and user info removed and the destination's query parameters kept exactly as sent, so a signed download link works; a destination address that carries a stored credential is refused. `endpoint` also takes `METHOD /path` for a path absent from the connection's definition, relative to its base URL: an unlisted `GET` or `HEAD` runs without approval unless an admin set a listed read to **Ask first** or **Block**; an unlisted `DELETE` is denied; every other unlisted call waits for a person's approval in an open chat, and a scheduled run, a delegated run, or a review creates no approval request and does not run it. An approved held call resumes with its `grantId`, `connection` and `endpoint` null, and the same arguments; **Always allow** on its card covers that concrete path only. A held path is kept as a saved endpoint, so Settings and `endpoints` list it and an admin can set its permission, and saving a new definition retires it. | `connection`, `endpoint`, `grantId`, `pathParams`, `query`, `body` |

### Workspace, people, and automation

| Tool | What it does | Actions or fields |
| - | - | - |
| `list_orgs` | Read-only, MCP only. Lists the user's workspaces with each one's ID, name, slug, and role. | none |
| `inspect_skills` | Read-only. Lists the built-in Skills, the workspace's shared Skills, and the signed-in user's own Skills that apply in the selected workspace, and reads their instructions and supporting files. Each of the user's Skills says where it applies, `all` or `this`. `scope` on `skills` and `instructions` chooses the version: `personal`, or omitted, lists and reads the Skills Ari follows for this user, in which a personal Skill hides a workspace Skill of the same name; `workspace` lists and reads the workspace versions, the hidden ones included. Reading a skill does not run it. | `skills`, `instructions`, `file`, `read` |
| `edit_skills` | Creates, updates, deletes, shares, or promotes Skills. `workspaces` sets where a personal Skill applies: `all`, the default, for every workspace where the user is a member, or `this` for the selected workspace only. `share` copies one of the user's Skills to named current members of the workspace, all of them or none: each copy is independent, limited to this workspace, named with the first free numbered suffix when the name is taken, and counted against the recipient's 100 Skills; `recipients` take exact names or `inspect_team` IDs, or emails when the user may see member emails, and an ambiguous name, a guest, a pending invitation, or the user themself is refused. `promote` makes one of the user's own Skills that applies here a workspace Skill for every member, which needs the admin role every member holds: a personal Skill limited to this workspace moves, and one for all workspaces stays personal beside the copy. `scope` on `update` and `delete` selects the personal or the workspace version; a workspace Skill's `workspaces` cannot change, and a workspace holds at most 100. Built-in skills cannot be edited. | `create`, `update`, `delete`, `share`, `promote`, `workspaces`, `scope` |
| `inspect_triggers` | Read-only. Reads the user's own scheduled Triggers, their schedules, and their last runs. Each schedule reports `cron_spec` or `run_at`, `time_zone`, `next_fire_at_utc`, and `next_fire_at_local`, the same instant with the time zone's offset. A `run_at` Trigger with `enabled` false and no `next_fire_at_utc` queued its one run and is finished. Each Trigger also reports its newest run: `last_run_status` (`finished`, `delivered_with_gaps` for a result delivered with a requested part unavailable, `did_not_complete` for a run that delivered nothing, or `not_reported`), `last_run_reason`, the run's own sentence when it delivered with gaps or did not complete, and `last_run_summary`, the run's recorded report whatever its status, absent when the run recorded none. | `query` |
| `edit_triggers` | Creates, updates, pauses, resumes, runs, or deletes the user's own Triggers. `cron_spec` is a five-field cron read on the clock of `time_zone`, an IANA name such as `Europe/Paris`; the schedule keeps its local time through daylight-saving changes, a time the spring change skips fires at the first minute after the gap, and a time the autumn change repeats fires once. Without `time_zone` a new schedule runs in UTC, and an update that sends only `time_zone` keeps the saved cron. A blank `time_zone` is refused. `run_at`, one future RFC 3339 instant with an offset such as `2027-10-30T09:00:00-07:00`, schedules one run instead; `cron_spec` and `run_at` are mutually exclusive, a `create` needs exactly one, and setting one replaces the other. The scheduler turns a `run_at` Trigger off when its run is queued; enabling it again without a new future `run_at` is refused, and an occurrence that could not be queued retries for 24 hours before the Trigger pauses with `last_dispatch_error`. `run` starts one run now, paused or not, and leaves a pending `run_at` in place. `slack_channel` names the private Slack channel each run posts in instead of the owner's direct messages, for an administrator and a channel Ari is already in. The receipt carries `notification_warning` when the saved prompt asks to notify, alert, or report but names no channel, which means the result reaches the owner in-app. The same field reads `slack_dm` when the prompt names Slack but no Slack workspace is connected. The prompt is always saved as written. On each run, a shortened or bare reference that identifies exactly one object the owner can read, such as `Verify snapshot#e99` for a table since renamed, is expanded in the message the run receives, with the current full reference beside the saved words; bare suffixes such as `#fff` stay literal, and the 10,000-character limit counts the saved text alone. `reference_warnings` lists each `Name#id` reference in the prompt that matched no object or more than one. A run's `trigger` context carries `timeZone`, and its times, such as `scheduledFireAt`, are written on that clock with their offsets. | `create`, `update`, `run`, `delete` |
| `inspect_guides` | Read-only. Reads the workspace's saved Guides. With `include_content`, a step whose target no longer resolves keeps its title and text and returns its anchor as `available: false`; when the same block resolves in Main, the anchor adds `found_in` with that Scenario and block as a repair option, and the saved target stays unavailable. A Guide saved in a Scenario that was since merged reports the Scenario it merged into. `config_available: false` appears only when the saved Guide itself cannot be decoded. | `query`, `include_content` |
| `edit_guides` | Creates, replaces, or deletes saved Guides. `update` replaces the whole Guide, title and steps together; an `available` or `found_in` field echoed from an inspection is refused, so replace an unavailable anchor with a target that resolves or with kind `none` for a narration step. An `update` that names no `scenario` or `layerId` keeps the saved Scenario, resolved to the Scenario it merged into when it was merged, and saves that one. A scripted step's settings that are left out take the app's standard wording and values, so a step saves with its type and target alone; settings that are supplied must still be valid. A refusal lists every invalid step first, then one full settings schema for each step type that had an invalid one, with its nested fields, requirements, limits, and defaults. | `create`, `update`, `delete` |
| `inspect_memory` | Read-only. Searches saved memories: the user's private facts and the workspace's shared facts. Each memory carries the `context` saved with it and `saved_with`, the `edit_memory` action that saved it: `retain` for a fact, `retain_document` for a statement extracted from a document, or `retain and retain_document` for a memory consolidated from both; a memory saved before the action was recorded has no `saved_with`. When the memory service cannot answer, a search with no results returns a refusal with code `memory_service_unavailable`, one plain sentence naming the fault, and `transient`, which says whether waiting helps; a billing limit on cfo.ai's provider account is `transient: false`. | `query`, `scope`, `tags`, `batch`, `include_superseded`, `limit` |
| `edit_memory` | Saves 1 to 12 facts, saves a document, replaces facts, or forgets them. `retain` and `retain_document` take `context`: why the memory was saved, and whose words or request it came from. The memory service reads it while extracting the memory, and recall shows it beside each one. A document's statements are recalled one at a time, apart from the rest of the document, with the document's context. A fact's `scope` is `user` (the default: the current user's own, read only in their chats in this workspace, for how that person works with Ari, including a preference or request about their own work that names something shared, such as a Scenario) or `organization` (read in every member's chats, for facts about the workspace and its business that are true whoever is asking, such as how the company defines bookings); a memory neither grants nor restricts what a member may do, which their workspace role and page access decide; a fact that `supersedes_memory_id` replaces keeps the older fact's scope, and `forget` names the scope of the memory it removes. A save the memory service received without answering, a timeout, a server error, or a cut-off answer, returns `state_changed: "unknown"` with a code naming the cause (`memory_service_timeout`, `memory_service_unavailable`, or `memory_service_failure`) and a message that says a stored write appears in `inspect_memory` search, and that the same text saved again in the same turn, scope, and `supersedes_memory_id`, or with the same `idempotency_key`, replaces that save's document, while reworded text is stored as a separate fact. A replacement whose earlier fact could not be retired is still `updated`, with `earlier_fact` (`active`, `unknown`, or `incomplete`) and an `earlier_fact_not_retired` warning. A recalled memory can be a summary built from several saved facts; `inspect_memory` does not say so, but a `retain` that names such a summary in `supersedes_memory_id` without `supersedes_source_memory_ids` saves nothing and answers with the summary's `source_facts`, each with its `id` and `content`. Name the source facts to replace in `supersedes_source_memory_ids`: only those retire, the summary is rebuilt from the rest, and the receipt's `superseded.source_memory_ids` lists them, with `verified` saying whether the earlier text has already left recall and a `note` when it has not yet. A partial result lists each source fact's status under `earlier_fact.source_facts`. A `supersedes_memory_id` that names a saved item the memory service stored as several facts retires every one of its active facts in the caller's scope and saves one replacement, inheriting their tags; after a partial failure, a retry from the same user message, or with the same `idempotency_key`, finishes the rest, and each receipt lists the facts that call handled. An item with no active fact is refused with **supersedes\_memory\_id "\[id]" is a saved document that holds no active memories in the \[scope] scope**; an ID resolves only in the scope it was saved in. `verified` is reported only when the recall check's query is at most 500 bytes; a longer one omits it, and the retirement still completes. `tags` may carry `kind:working_style`, which marks a `user`-scope preference that applies across chats and reports, such as naming, formatting, communication, or report layout; cfo.ai loads these at the start of every chat. A preference about one Page or report stays untagged, and a team convention goes in `organization` scope without the tag. | `retain`, `retain_document`, `forget` |
| `inspect_team` | Read-only. Reads the people and pending invitations in the workspace. | `query`, `target` |
| `edit_team` | Invites admins, promotes members, removes members, or cancels invitations. Every change needs the user's explicit confirmation. | `invite`, `update_member`, `remove_member`, `cancel_invite` |
| `edit_org` | Renames the workspace, or sets, clears, or copies its brand: the name, colors, heading typeface or font, corner shape, sidebar colors, logo, and whether link previews show it. Colors are saved as given; a brand with hard-to-read color pairs is refused, naming each pair. `negative_numbers` sets how every table shows a number below zero where no scope of the table chooses, with `display` `MINUS` or `PARENTHESES`; the result returns `display` and `previous`, and a table's own `negativeNumbers` style still wins. | `rename`, `brand`, `negative_numbers` |
| `inspect_billing` | Read-only. Reads the plan, AI usage, spending settings, integration allowances, and available plans. It cannot change billing. A workspace an operator exempted from billing answers with `ok: false` and `error_kind: not_found`: **this workspace is exempt from billing: there is no plan to choose or pay for, AI usage is not metered, and connections have no plan limits**. | `read` |
| `inspect_profile` | Read-only. Reads the user's profile, personal theme, and the workspace brand, with `heading_font_url` beside the logo addresses when the brand has its own font. `workspace_negative_numbers` is the workspace's negative number display, `MINUS` or `PARENTHESES`, or `null` when the workspace has not chosen and tables show `MINUS`. | none |
| `edit_profile` | Updates the user's display name, personal theme, or both. Theme colors are saved as given, as hex or `oklch(L C H)`; a theme with hard-to-read color pairs is refused, naming each pair. Sidebar colors come as a pair, `navSurface` and `navInk`. | `name`, `personal_theme` |
| `notify_user` | Emails the user at their verified address, sends them a Slack DM, or, from a scheduled run only, posts a message in the owner's cfo.ai chat with `in_app`: the chat that created the Trigger, or the owner's latest conversation in the workspace when that chat is gone. The message starts no turn. A call from an ordinary chat is refused with `scheduled_run_required`, and an owner with no conversation gets `no_owner_conversation`. A `slack` send may add `thread`: up to 5 replies, each in Slack mrkdwn, posted in order in a thread under the message, so the message itself stays a headline when a report carries tables, long lists, or detail per item. A blank or sixth reply refuses the send before anything posts. Replies go only under the message the same call posts; nothing names an existing thread. A reply that does not go through ends the thread, the send still counts as sent, and a `slack_thread_incomplete` warning says how many replies posted; a reply Slack refuses is not retried, a reply Slack gave no clear answer about is marked `unconfirmed` and is not sent again, since it may be in the thread, and a reply Slack did not take but may take shortly, such as under a rate limit, is tried up to two more times. The thread has 25 seconds, after which `slack_thread_timeout` reports what posted. A scheduled `slack` send with no Slack workspace connected delivers the message and its replies as one text through `in_app` and says so. Email to anyone else waits as a preview until the user presses Send. A Markdown link whose address is a reference to a Page, or to a block, table, row, column, cell, or chart on one, arrives as a cfo.ai web link that opens the Page in its Scenario for a reader who can already see it and grants no access; a reference link to anything else, such as a Variable, shows only its label. | `email`, `slack`, `in_app` |
| `inspect_documentation` | Read-only. Searches the cfo.ai documentation and reads whole pages. | `search`, `read` |

### Ari chats

Two MCP-only tools let a client hand a question to Ari instead of calling tools itself. A chat a client starts is an ordinary Ari chat, with the same agent, billing, memory, and Skills, and the person can open it in the cfo.ai web app, where its entry in the chat list carries an **MCP chat** mark.

| Tool | What it does | Actions or fields |
| - | - | - |
| `inspect_chats` | Read-only, MCP only. `list` returns the user's chats in this workspace, most recently updated first, each with its `ref`, `state` (`running`, `idle`, `needs_response`, or `error`), a busy flag, and its `resource_uri`. `read` returns one bounded page of a chat: the user's messages, Ari's last message in each turn, the questions and plans Ari waits on, cards that only the web app can answer as `waiting_in_app` items, and delivered files. | `list` (`status`, `title_query`, `limit`, `cursor`), `read` (`target`, `after`, `before`, `wait_seconds`, `steps`) |
| `edit_chats` | MCP only. `create` starts a chat with a message in the Scenario `_context.scenario` names. `send` adds a message to a chat, and also answers Ari's questions and approves a plan. `stop` ends the running turn; `drop_waiting` also deletes messages not yet sent. `update` renames, archives, or restores a chat. Turns bill the workspace like chats in the app. | `create` (`message`), `send` (`target`, `message`, `delivery`, `request_id`), `stop` (`target`, `drop_waiting`), `update` (`target`, `title`, `archived`) |

* **Reads are bounded.** `steps` chooses how Ari's tool work shows. `none`, the default, folds each turn's tool steps and the notes between them into one `steps` item with their count. `summary` shows one item per step. `full` adds each step's input and result, cut at 4,000 characters. A page holds at most 40 items and about 48 KB. A read without a cursor keeps the newest items and returns `older` to page back; a read with `after` keeps the oldest and returns `next`.
* **Waiting for Ari.** `create` and `send` return at once with `next`: the exact `inspect_chats` `read` call that waits, up to 50 seconds through `wait_seconds`, while the chat is busy. A read of a chat that is still busy returns another `next`. A client that sends a progress token gets a progress notification each second it waits, naming what Ari is doing. To hear when a turn starts or ends instead of waiting, subscribe to the chat's `resource_uri`, `cfoai://orgs/{org_id}/chats/{chat_id}`, on the MCP 2026-07-28 `subscriptions/listen` stream, and read the chat's newest page with `resources/read`. The older `resources/subscribe` is refused.
* **While Ari works.** `delivery` on `send` is `steer` by default, which ends the running turn after its current step and starts the next turn with the message; the work in progress carries into that turn with its saved progress, and the message is read as an addition to it unless it cancels or replaces it. `queue` waits for the turn to end. `request_id`, a UUID the client makes, makes a repeated `send` a `no_op` that returns the same `message_id`.
* **Limits.** A `create`, or a `send` to a chat that is not busy, is refused when 5 of the user's chats in the workspace are already busy. Only the chat's owner can read or write it. Approval buttons, email **Send** buttons, confirmations, and sign-ins work only in the web app: give the person the `chat_url` the result carries. An MCP read does not mark the chat read in the web app.

## Fields every tool accepts

Every tool except `list_orgs` also accepts these two fields at the root. The server removes them before the tool runs.

| Field | Meaning |
| - | - |
| `org_id` | The workspace, by ID or slug. Optional when the user belongs to one workspace. See [Choose the workspace](#choose-the-workspace). |
| `_context` | What the person is working on, all optional: `scenario` (a Scenario name or reference as `inspect_scenarios` returns it; the Main Scenario when omitted), `page` (a Page reference as `inspect_pages` returns it), `timeZone` (such as `America/New_York`), and `utcOffset` (such as `-04:00`). Names and references only: the tools never return the IDs behind them, so a Page's UUID is read as a Page name and matches nothing. A value that names nothing, or several things, is refused before any tool runs, whether or not that tool reads `_context`; the refusal starts with the field, such as `_context.page:`, keeps any candidates the lookup found, and names the tool that lists valid values. Send `timeZone` or `utcOffset` when relative dates matter. Any other key, including the retired `layerId` and `pageId`, is refused with **\_context must contain only scenario, page, timeZone, and utcOffset**. |

### The Scenario a call uses

Most model tools take `scenario`, by name or returned reference. `"Main"` names the base Scenario whatever name the workspace stores for it, and the id that Page and block links print after `?layer=` is accepted too; a stored name wins, so a Scenario literally named Main keeps its own meaning. When a call omits `scenario`, the tool uses the Scenario in view: the one `_context.scenario` names, or Main when `_context` names none. Pass `scenario` on every write so the target does not depend on context. [Create and update formulas](https://docs.cfo.ai/agents/write-formulas.md#write-in-a-scenario) quotes the sentence a table write adds when `scenario` was omitted.

## Shape each call as one action block

A tool with several actions takes exactly one block named for the action, with that action's fields inside it. There is no flat `action` field.

```json theme={null}
{ "read": { "target": "Operating Plan", "rows": ["Revenue"] }, "scenario": "Main" }
```

* Each tool's input schema says, in its description, which blocks exist and which fields sit beside them: "Fill exactly one action block: list, read. Fields beside the block apply to it: as\_of\_point, scenario."
* An empty block selects an action that needs no fields, such as `{"list": {}}`. A block set to `null` counts as not filled.
* Fields beside the block apply to it: `scenario` on most model tools, `as_of_point` on `inspect_pages` and `inspect_scenarios`, `validate` on `edit_canvas_blocks`, `target` on `edit_dimension_mappings`, and `idempotency_key` on `edit_memory`. A block that takes such a field also accepts it inside; when both places carry it, the two values must match.
* Single-purpose tools take their fields directly at the root, as the table above shows. `notify_user` takes an `email` block, a `slack` block, an `in_app` block, or several of them.
* The schema root is a plain object, so every client can see the blocks. The rule that exactly one block is filled is enforced when the call runs.
* Unknown fields and retired request shapes are refused before anything runs. Nothing is translated from an older shape.

### Refusals for a wrong shape

A refused call changes nothing. Its message names the problem without repeating any value you sent.

| Mistake | Message |
| - | - |
| No block filled | `no action block is filled; the call takes exactly one of [...]` |
| Two blocks filled | `the call takes exactly one action block; [...] are filled` |
| A flat `action` field | `action "read" is the read block; the fields of that action belong inside it: {"read": {"target": ...}}` |
| `action` inside a block | `the read block takes no action field; the block name selects the action` |
| A block that is not an object | `read must be an object holding that action's fields` |
| A root field that is not a block | `<name> is not an action block; the blocks are [...]` |
| A field the block does not take | `<field> is not a field of the <block> block` |
| A beside-field inside a block that does not take it | `<field> belongs beside the <block> block, not inside it` |
| The same field beside and inside, with different values | `<field> is <value> beside the <block> block and <value> inside it; a call carries one <field>, in either place` |
| A value of the wrong type or shape | `<path> received <what>; it accepts <what>`, such as `/sections/0 received a string of 9 characters; it accepts an object whose section is one of …`. At an action's root, the path reads `the input`. |

A shape is described by type: a string by its length, an array by its item count, an object by up to 8 of its key names, and a number, boolean, or null by its type.

The refusal arrives with `isError: true` and this structure:

```json theme={null}
{
  "error": {
    "code": "invalid_input",
    "message": "the call takes exactly one action block; [\"list\" \"read\"] are filled",
    "transient": false,
    "validation": {
      "issues": [{ "path": "", "code": "invalid_value", "message": "..." }],
      "accepted_fields": ["..."],
      "required_fields": ["..."],
      "truncated": false
    }
  },
  "state_changed": "no"
}
```

`validation` lists at most 20 issues; `truncated` is true when there were more. `accepted_fields` lists the chosen block's own fields plus the fields beside it.

## Choose the workspace

`list_orgs` takes no input and returns the workspaces the user can use through MCP:

```json theme={null}
{ "orgs": [{ "org_id": "4127", "name": "Example Co", "slug": "example-co", "role": "admin" }] }
```

Pass a returned ID or slug as `org_id` on later calls. A number, or a string of digits, always names a workspace ID; anything else is read as a slug.

| Situation | Answer |
| - | - |
| `org_id` omitted, one workspace | That workspace is used. |
| `org_id` omitted, several workspaces | `org_id is required: you belong to <n> cfo.ai workspaces — pass one of [<ID> (<name>), …] (or call list_orgs)` |
| `org_id` omitted, no workspace | `no org_id supplied and you are not a member of any cfo.ai workspace` |
| A workspace the user is not a member of, or a slug that matches none | `you do not have access to this workspace`. Unknown and inaccessible workspaces get the same answer. |
| A numeric `org_id` that is not a positive whole ID | `a numeric org_id must be a positive whole cfo.ai workspace ID; pass slugs as strings`, or for zero `org_id must be a positive numeric cfo.ai workspace ID` |
| `org_id` neither a string nor a number | `org_id must be a string or number` |
| A workspace that has not started its free trial or a plan | `Start the free trial in cfo.ai before using its MCP tools`. `list_orgs` leaves such workspaces out, and answers with this message when none remain. |
| A deactivated workspace | `This workspace has been deactivated. Contact help@cfo.ai for assistance.` |
| A workspace paused while cfo.ai investigates an issue | `This workspace is temporarily unavailable while we investigate an issue. We'll report back soon.` |

## References and links

* Selectors accept readable names, returned references, or IDs, unless a field says it takes less. Copy references from inspection results instead of building IDs.
* A returned reference has the form `Name#hex`, such as `Revenue#a1b`. The suffix is a prefix of the object's identity, at least three hex digits, and unique among objects of its kind when the result was written. Later creates can lengthen it; an older reference keeps resolving while it stays unique, and a fresh inspection carries the current form. A reference also keeps resolving after its object is renamed, when exactly one object of its kind carries the suffix and the written name is one that object carried: `Gusto#940` names the connection now called `Acme Payroll#940`, and `Completion and final validation#6ca` names a text block after an `update_text` changed its first line, with or without a page named. A suffix with a name the object never carried is refused as not a reference, with the object's current reference. Scenario and Page references follow the same rule: `Plan#725` names the Scenario since renamed `Plan - No Series A#725`, and `SA26-18a#50c` names a Page after `edit_pages` `update` renamed it, in `edit_pages`, `inspect_pages`, and the `page` a table `create` names. `Main` with the base Scenario's suffix names the base Scenario. A table row or column reference, such as `Acquisition mix · R006-1#6e4`, keeps selecting its coordinate in reads and writes after the Variable it shows is renamed, when the written name is one the Variable carried and the digits select one coordinate; the same digits with a name the Variable never had are refused with `does not match a saved coordinate`.
* Words written in front of a whole reference, such as `Original Headcount#78e`, read the object the reference at the end names, when the longest run of its trailing words that any object under those digits ever carried is that object's own name. A shortened name such as `checks#1d5`, or text with no space before the name, is still refused with the object's reference as the candidate.
* A reference whose name only a hidden object carried, such as a deleted table, a table saved only in another Scenario, or one outside your access, is `not_found` with no candidate, even when one visible object shares its digits: **"Original vendor spend#72f" names no object this lookup can see. The one visible object under its suffix has no record of that name. Under that suffix the name belongs only to objects this lookup cannot see, such as a deleted object, one saved only in another scenario, or one outside this lookup's access.** The visible object's own references, including one issued before a rename, still resolve.
* A suffix with no name before it, such as `#199`, never binds an object. When exactly one live object of the requested kind that you can read carries those digits, the `not_found` answer gives that object's current reference as its one candidate: **"#199" is not a reference: it is a suffix with no name before it, and that suffix belongs to one table\_block. A reference is an object's name and its suffix together.** When the digits belong to no readable object of that kind, or to more than one, the answer offers no candidates: **No table\_block named "#199" was found. "#199" is a suffix with no name before it, and it does not belong to exactly one table\_block this lookup can read.** Tables, charts, Canvas blocks, Pages, saved queries, connections, Variables, and Dimensions answer this way; Scenarios keep the plain not-found answer. A read that names several targets keeps the answer beside the targets it read: `inspect_pages` `read` lists it in `unresolved_answers`, `inspect_pages` `list` in `unresolved_page_answers` next to `unresolved_page_names`, and an `inspect_table_blocks` `list` in its `unresolved` notice under `answers`, each entry with `target` (the token as written), `message`, `candidates`, and the refusal's `hint`; when some answers do not fit one result, the tokens left out are listed in `unresolved_answers_omitted`, `unresolved_page_answers_omitted`, or `answers_omitted`.
* A name that is ambiguous or matches nothing is refused with `error.candidates` when alternatives are known: each with `display_name`, `ref` to pass back, `kind`, and, when ranked, `score` and `match`. A Variable or Dimension edit whose bare name two objects share lists their references, such as `Net Income#abcd1` and `Net Income#abcd2`, when the saved identity proves which object each names; a layout name whose suffix matches current objects, such as `Total OpEx#6c6`, is refused with the current references under that suffix, each labeled variable or dimension, with the requested kind first. A Date candidate's `display_name` carries its grain, such as `2027-01, YEAR grain` beside `2027-01, MONTH grain`, because columns of different grains print the same label. In a table read rolled up to a coarser `grain`, it also names the saved axis the period comes from, such as `2027-01, YEAR grain, from the saved QUARTER axis` beside `2027-01, YEAR grain, from the saved MONTH axis`. When a table saves a year axis beside a month axis and a `YEAR` read shows the same year twice, a period selector such as `2027` or `FY2027` selects the column the table saves at that grain, the one the Page shows; two candidates that differ in Variable, item, or Dimension, or two rolled-up copies with no axis saved at the read's grain, stay ambiguous, and a `#suffix` that matches two columns keeps its refusal.
* A table's saved rows and columns print the same reference in a layout `list`, in a read whose calculation did not finish, and in a calculated `read`, so a reference copied from any table result selects its row or column in the next read.
* A result names each object with `ref`, the selector to pass back, and `url`, the address that opens it in cfo.ai.
* A write also returns a resource link for each thing it created or changed, described "Open in cfo.ai" and meant for the user. End your reply with the link a tool returned, exactly as printed; a link you assemble yourself will not open.

## Results

Every result is JSON text. A result that is a JSON object also arrives as `structuredContent`. A `validate_code_blocks` call with `visual_review` also returns the render as image content.

### Write receipts

A write receipt opens with a shared head. Tool-specific sections sit beside it.

| Field | Values |
| - | - |
| `status` | `applied`: everything asked for is saved. `partially_applied`: some items are saved; `items` says which. `rejected`: nothing is saved because the request or every item was refused. `no_op`: nothing is saved because saved state already matched. `blocked`: nothing is saved because a dependency or a rule refused the write. |
| `state_changed` | `yes`, `no`, or `unknown` |
| `counts` | `requested`, and when nonzero `created`, `reused`, `applied`, `skipped`, `rejected`, `unchanged`, and `unknown` |
| `items[]` | One entry per requested item, in request order: `ref`, `display_name`, `status` (`created`, `reused`, `applied`, `skipped`, `rejected`, `unchanged`, or `unknown`), and `reason` when it did not land |
| `readback` | `status`: `complete`, `partial`, or `unavailable`, with `reason`. A write whose readback is unavailable still saved. A write that read nothing back carries no `readback` at all: a table, Variable, or Dimension delete, a rollup or calendar edit, and other edits of saved state. Those receipts report `coverage.values: "not_evaluated"`, except a rollup or calendar edit that saved nothing because the saved state already matched, which keeps `not_needed`. |
| `warnings[]` | `code`, `message`, and `ref`: things the saved write will not do as asked |
| `error` | Present exactly when `status` is `rejected` or `blocked` |

An item whose status is `unknown` may or may not have landed. Read current state before you repeat it.

### Refusals and failures

* A refusal carries `error` with `code`, `message`, `transient`, and, when known, `candidates` and `hint`, beside `state_changed`. Codes include `ambiguous`, `not_found`, `invalid`, `blocked`, `conflict`, `stale_target`, `selection_too_wide`, `file_too_large`, `result_unavailable`, and `browser_validation_unavailable`.
* `result_unavailable` reads **The call's outcome is unavailable. Read current state before repeating a write; repeating it could apply it again.**
* A `not_found` for a name or `Name#hex` reference that only a removed connection or a deleted table carried says so, with the day in UTC: `"Stripe#aa9" named a connection that was removed from this workspace on 2026-10-05.` or `"Vendor breakdown" named a table that was deleted on 2026-08-12.` The table fact appears only when you could read that table just before it was deleted. A Scenario reference whose suffix belongs to a removed Scenario says `"Disposable#a17" named a scenario that was deleted on 2026-10-19.` or `merged into its parent scenario`, only for a user who could see that Scenario just before it was removed. Any `candidates` are objects that exist now, and the `hint` says each is a different object.
* A table or mapping write that PostgreSQL rolls back for a deadlock is retried once by the server after 50 to 100 milliseconds; a second deadlock returns a `blocked` refusal that says the write saved nothing, with `transient: true`, so the same call can be sent again.
* A result with `ok: false` and an `error_kind` is an answer, not a crash. Use its message and `hint` to choose the next call.
* Refusals and fully rejected writes arrive with `isError: true`. A write that saved some items stays a success, with each item's status.
* `transient: true` means the same call can succeed later without changes. A failure that knows whether it is retryable adds `Transient: true.` or `Transient: false.` to its text and `{"error": {"message", "transient"}}` to its structured content. Apart from the one deadlock retry above, the server never retries for you.

## Pagination and truncation

A list cut short carries `truncation` and, when it can continue, `next`:

* `truncation.by` says what cut it: `response_budget` (the next item did not fit one result), `count_limit` (the page reached the `limit` you set), `row_limit`, or `depth`.
* `truncation.shown` counts what came back, and `truncation.total`, when counted, what the selection matched. No `truncation` means the result is complete.
* `next` holds the values that continue the read. Pass a cursor back unchanged, with the same tool, action, target, filters, and snapshot. An `inspect_table_blocks` cursor passed back beside a Scenario spelled differently from the cursor's own, such as `Base` beside `Base#52f`, still continues when both name one Scenario at the read's saved version.

| Tool and action | Page size | Continue with |
| - | - | - |
| `inspect_pages` `list` | `limit`. Without it, every page summary that fits one result; `truncation.total` counts all pages. | `next.after` as `after`, with the same `scenario` and `target` |
| `inspect_pages` `read` | A page whose block list was cut carries its own `truncation`. | — |
| `inspect_scenarios` `list` | `limit`. Without it, every visible Scenario that fits one result. | `next.after` as `after` |
| `inspect_history` `changelog` | At most 100 entries per read; `limit` takes up to 100. Without it, as many of those as fit one result. | `next.before` as `before` |
| `inspect_history` `changelog` with `search` | Each read searches up to 1,000 entries, newest first, and reports how many it read in `entries_searched`. | The `before` value the result carries |
| `inspect_table_blocks` `list` | `limit` up to 500. Without it, every table that fits one result. | `next.after` as `after` |
| `inspect_table_blocks` `read` and `compare` | `limit` up to 500 grid rows; default 500. Parents and descendants count separately. | `next.after` as `after`; it binds the table, selection, Scenario, and snapshot |
| `inspect_table_blocks` `items` | `limit` up to 500 items; default 500. | The last item's text as `after`, including an empty string |
| `inspect_table_blocks` `variable` and `dimension` | `limit` up to 100 saved formula definitions per page; default 100. | `next.after` as `after`, with the same `target` |
| `inspect_dimension_mappings` | `limit` rows per lookup. Without it, every row of each lookup, or as many per lookup as fit one result. Each lookup's `row_count` is its true total. | That lookup's `next` as `after`, with the same `keys` |
| `inspect_canvas_blocks` | A selection larger than one result is cut short. See [Canvas blocks for agents](https://docs.cfo.ai/agents/canvas-blocks.md#read-saved-canvas-blocks). | `next` holds the arguments that read the rest |
| `inspect_integrations` `query_results` | `limit` up to 100 rows per read; without it, 100. The result holds as many of them as fit one result, with `offset` naming the first row shown. `total_rows` counts every row on the first read only. | `next.offset` as `offset`, with the same `query`. A saved statement whose outermost `SELECT` ends with `ORDER BY` pages in that order. Without one, each page sorts the rows by every output column, nulls last, before it skips to `offset`, so pages neither repeat nor skip rows, though rows equal in every column can trade places. When Snowflake rejects that sort, the read runs once more without it, and `order` says that pages can repeat or skip rows. |

A table `read` that selects rows, columns, or periods, limits `depth`, continues from `after`, or stops early returns `partial: true` at its root. `coverage.delivery` says whether the response reached the end of that selection, and `coverage.calculation` whether its values finished calculating. A `period_range` that reaches past the table's window returns only the periods inside the window and adds one `read_note` issue that counts and lists the requested periods left out and names the window: `13 of the 20 requested periods are not in this read (2025-02 through 2026-01, 2026-09): they are outside the table's window, 2026-02 through 2026-08.` A table that saves no valid dates names the default window instead. The note appears on a table with one Date axis at month, quarter, or year grain.

A changelog entry larger than one page keeps its place in the list. Without `include_details`, it comes back with an empty `changes` list and no `blocks` list, and `changes_truncation` and `blocks_truncation` beside them count what each list held. With `include_details`, it keeps every change, and a result larger than the allowance is replaced whole by the allowance marker.

## Read the Model at an earlier point

`inspect_pages`, `inspect_table_blocks` (every action except `bounds`), `inspect_canvas_blocks`, `inspect_dimension_mappings`, and `inspect_scenarios` take `as_of_point`. Without it they read the current state. It holds exactly one point type:

| Point type | Meaning |
| - | - |
| `change_log_id` | One of the workspace's changes, as a write receipt or `inspect_history` reports it. The snapshot is the Model right after that change. Change ids are numbered across all workspaces, so an id between two of this workspace's changes can belong to another workspace. It accepts the ID as an integer or as a string of digits, as do `before_change_log_id` on `inspect_table_blocks` `compare`, `at_change_log_id` on `edit_scenarios` `snapshot`, and `change_log_ids` and `to_change_log_id` on `edit_history`. Results print the ID in either form. |
| `timestamp` | An exact instant in RFC 3339 with a time zone, supplied by the user, the context, or a tool result. |
| `calendar_boundary` | `unit` (`day`, `week`, `month`, `quarter`, or `year`), `offset` (0 this period, -1 the previous, 1 the next), and `boundary` (`start` or `end`), in the user's time zone from `_context`, or UTC without one. Weeks start on Monday. Use it for "yesterday" or "last month". |
| `relative_duration` | `amount`, `unit` (`minute`, `hour`, `day`, or `week`), and `direction` (`ago` or `from_now`), from server time. A day is 24 hours and a week seven days. |

A `change_log_id` the workspace does not have is refused with `not_found`: `as_of_point.change_log_id: no change with id <n> exists in this workspace. Change ids are numbered across all workspaces, so an id between two of this workspace's changes can belong to another workspace.`, with the hint `This workspace's changes are the ids its write receipts and inspect_history report.` and, when one exists, `Its latest change before <n> is <m>.`

`inspect_history` `changes_between_points` takes a `start` point and an optional `end` point, which may also be `latest: true`. A `change_log_id` there resolves to the workspace's latest change at or before it. The range is the response's own `startChangeLogId` and `endChangeLogId`, so the parent's `changes_between_points` over the same points lists what a child Scenario's `inheritedChanges` counts.

## Safety annotations

Each tool carries standard MCP annotations, which clients use to decide which calls need the user's approval:

* `readOnlyHint: true` on every `inspect_*` tool, `inspect_chats` included, `validate_code_blocks`, and `list_orgs`.
* `openWorldHint: true` on tools that can reach outside cfo.ai, notify a person, send an invitation, or change an outside integration: `edit_pages`, `edit_triggers`, `edit_profile`, `edit_integrations`, `edit_team`, `edit_org`, `call_connected_api`, `notify_user`, and `validate_code_blocks`.
* `destructiveHint: false` only on `notify_user`. Every other write keeps the MCP default, which treats it as possibly destructive.

## What the server does not publish

Ari has tools that an outside agent does not get, because they need the cfo.ai app, belong to cfo.ai's own agents, or are switched on per workspace by a release setting that the server's single tool list cannot follow.

| Kind | Not published | Instead |
| - | - | - |
| Cards and views shown in the cfo.ai chat | Asking the user questions in a card, playing a Guide, showing a Scenario or table rows on screen, scenario confirmation cards, and sign-up steps | Ask the user in your own conversation, and describe what to open. |
| cfo.ai's own agents | Delegating to background agents, task tools, the ingestion worker's reads of raw source data, and reports to cfo.ai engineering | Read a connection's saved queries, their rows, and their jobs with `inspect_integrations` `queries`, `query_results`, and `jobs`; save and run a query with `edit_integrations` `save_query` and `start_query`; start a sync with `start_ingestion` and read its progress with `inspect_integrations` `ingestion`. cfo.ai runs the workers and jobs. |
| Ari's own runtime tools | Its code sandbox and files, web search, chat attachments and spreadsheets, calling other MCP servers, and reading past chats | Use your own client's tools. |
| Tools switched on per workspace | Downloading a Page as a spreadsheet, image generation, and the publication library | None through MCP. The user can download a Page as a spreadsheet in cfo.ai, or ask Ari for one. |
| Tools of the cfo.ai app only | Input forms: writing a form, sending it, and reading its answers | None through MCP. The user asks Ari for a form in cfo.ai; see [Collect numbers and answers from people with a form](https://docs.cfo.ai/guides/collect-answers-with-a-form.md). |


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.