Layerz
Server Details
A structured financial modeling layer for AI agents. Build, version, and audit financial models without drift, then export to Excel, from Claude or any MCP client. Learn more: https://layerz.cc/for-agents
- Status
- Healthy
- Uptime
- 100.0% over the last 24 hours
- OAuth
- Works in Glama
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- ChatGPT
- –
- Claude
- Layerz
TDQS
Scored across 29 tools
Most tools target distinct resources or operations, and descriptions clearly separate read-only, write, import, mapping, and versioning flows. However, several write paths overlap (layerz_patch, layerz_build_from_blueprint, layerz_import_branch, layerz_update_branch, and layerz_manage_integration sync), which could make an agent hesitate over the correct mutation tool.
Names consistently use the layerz_ prefix and snake_case, mostly following a verb_noun pattern such as layerz_create_model, layerz_list_models, and layerz_manage_mapping. A few names are noun-only or less action-oriented (layerz_history, layerz_dependencies, layerz_external_ref), which is a minor deviation.
The 29-tool surface is heavy but largely reflects a broad domain: models, branches, imports, mappings, integrations, versions, sharing, exports, and validation. It is borderline for an agent-facing set, with some operational overlap that could be consolidated.
The server covers the main financial-model lifecycle well: create/read/update models, manage branches, imports, mappings, integrations, versions, exports, validation, sharing, and conventions. The main visible gap is model deletion or archival, plus branch listing is only embedded in model details rather than exposed directly.
Publisher details
- Operator
- Layerz · Publisher source
- Operator website
- https://layerz.cc · Publisher source
- Vendor relationship
- First-party · Publisher source
- Documentation
- https://layerz.cc/for-agents · Publisher source
- Privacy policy
- Not provided
- Trust center
- https://layerz.cc/trust · Publisher source
- Restrictions
- Requires a Layerz account, free for one person working alone, with OAuth sign-in (or a Layerz API key as a bearer token). No admin approval or regional limit. A paid Team plan applies only when a second person edits the same models. · Publisher source
Available Tools
29 toolslayerz_build_from_blueprintBuild from blueprintADestructiveInspect
Builds or extends a model from a strict Blueprint (whole sections with their hierarchy, items referenced by name), or applies a stored template as a module through template_id (mutually exclusive with blueprint, loaded server-side). mode: 'merge' (default) adds to the model, reusing items by name and keeping the presentation fields a re-declared item omits; mode: 'replace' rebuilds the whole model (structure, timelines, values, branches), keeping style colours, custom formats, locale, glyph, subtitle and FINANCE.md. dry_run: true validates and returns errors with their path without writing; apply_if_clean: true validates and writes only when there is no error (one call instead of a dry run then the same blueprint again). A large blueprint can come as file_id (a JSON file uploaded through layerz_create_upload_url) instead of blueprint. UIDs are stable for a given model, so a dry run's name_to_uid holds for the apply. The result is concise: name_to_uid, counters, warnings / errors, version_number and revision_id, health when the model has checks; include_items: true adds every item of the model. Persists one version labelled with summary. The result carries conventions (workspace conventions + model FINANCE.md, as in layerz_get_conventions) when either is set. Not advertised to read-only keys.
Inputs: summary (required), mode, dry_run, file_id, +5 more.
layerz_create_modelCreate modelAInspect
Creates a model and returns its detail with its UUID, in workspace_id (a workspace the caller belongs to; default the personal one) where every member of that workspace edits it. template_id copies a template (official, or from the library of a workspace the caller belongs to) into the new model with its sources, staged transactions and mapping rules under fresh ids (connector credentials excluded); the template itself is unchanged. timelines sets the grains and bounds (only the grains given: { monthly } alone gives a monthly-only model; on a template, the bounds), glyph its emblem (a kebab-case Lucide icon name, e.g. trending-up, landmark, house, coffee, wallet). file_id imports an uploaded workbook instead (deterministic compiler, no AI) and returns { model_id, name, status: "importing" } with guidance (the rebuild method) at once: the import runs after the response (about a minute for a large workbook), then its report (fidelity by scenario, residue, constructions map) lands in the model FINANCE.md (has_finance_md); a failed import deletes the model. The workbook stays with the model for layerz_diff { source }. Undated period headers return IMPORT_DECISION_REQUIRED with the axes to anchor (anchors). conventions carries the conventions of the workspace it lands in and its FINANCE.md (as in layerz_get_conventions) when either is set. Rejected past the plan model cap. Not advertised to model-scoped or read-only keys.
Inputs: name, glyph, anchors, file_id, +4 more.
layerz_create_upload_urlCreate file upload URLAInspect
Issues a signed Storage URL for an Excel/CSV file and returns file_id, signed_url, upload_expires_at, expires_at. signed_url accepts one HTTP PUT of the file body with the declared content type within 2 h of issue (upload_expires_at): create the URL right before the PUT (a shell curl -X PUT --data-binary @file; the binary stays out of the conversation); after that a new call issues a fresh URL and file_id. The uploaded file_id is the identifier the file-consuming tools take, readable for 24 h (expires_at). Limits: 25 MB, MIME whitelist (xlsx, xls, csv, json, txt). Mints no model data, so it stays available to read-only keys.
Inputs: size (required), filename (required), content_type (required).
layerz_delete_branchDelete branchADestructiveIdempotentInspect
Deletes a branch, every input row tagged with its dataset_id, and the data sources that fed only that branch (their staged transactions with them); a source shared with another branch is detached instead. The default branch is rejected. Returns deleted_dataset_id, inputs_removed, sources_removed. Persists one version labelled with summary. Not advertised to read-only keys.
Inputs: summary (required), dataset_id (required), model_id.
layerz_dependenciesTrace dependenciesARead-onlyIdempotentInspect
Returns an item's dependency graph, like Excel trace precedents / dependents: precedents (items its formula references) and dependents (items referencing it). depth (1–5) walks transitively, direction restricts to one side.
Inputs: uid (required), depth, model_id, direction.
layerz_diffDiff two versionsARead-onlyIdempotentInspect
Returns the semantic diff between two revisions of a model: { from, to, diff: { items: [{ uid, displayName, status, fields? }], branches: [{ id, display_name, status?, items }], metadata: [...], summary: { added, removed, modified, branches } } }. items compares the base plan; branches lists, per branch, the overlay cells it records over the base (null where the base shows through): a write under branch_id or an import on a branch appears there, not as a base change. from and to each take exactly one of revision_id, version_number or id; without to, the diff runs against the live model. sources carries the delta of the source settings and bindings (sources[] { id, display_name, status, fields[] }) and of the mapping rules (rules { added, removed, changed }), present when both endpoints carry that state. values: true adds values, the computed-values diff: { granularity, scope, tolerance, computable, items: [{ uid, display_name, status?, changed, cells: [{ period, before, after, delta }] }], summary: { items_compared, items_changed, cells_changed, max_abs_delta, truncated } } — the periods whose value moved beyond tolerance, on the lines uids names, else the key lines (checks, totals), else every value line; computed on the base plan or under branch_id, at granularity. computable: false with errors per endpoint when a revision cannot be computed. source (in place of from): the live model against its source workbook recalculated.
Inputs: to, from, uids, source, +5 more.
layerz_exportExport to fileAInspect
Generates a file from a model and returns { download_url, filename, size, file_id, expires_at }. target: 'model' (default) is the Excel workbook (the same export as the web app: Intro + per-section sheets, native charts and dashboards, live formulas), plus structure_hash / values_hash; when the model has branches, the statements and single-value widgets follow branch_id (default: the base branch) while dashboards keep every branch they break down by. target: 'transactions' is the full staged import of the data source source_id as a CSV file (no filters, no routing annotations), plus row_count. Each call persists a new private file in Storage, where the file and its signed download_url expire after 24h; the model itself is not modified, so the tool stays available to read-only keys, off quota.
Inputs: target, model_id, branch_id, source_id.
layerz_external_refLink, refresh or unlink external referenceADestructiveInspect
Manages the links from this model to items of other Layerz models (an external ref, like an Excel linked workbook), by op. link: creates (or retargets, with uid) a non-list assumption whose values hold a snapshot of the source item's computed series projected to this model's grain (null outside the source's coverage); requires read access to the source model; the line is referenceable in formulas like any assumption; up to 200 links in links (one form per call) load each source once, are validated whole (one failure writes nothing) and return results. refresh: re-reads every linked source (or uids) and rewrites the snapshots, the only way the values move; a per-link failure (source or item gone) leaves the stored values intact; when values change, the pre-refresh state is snapshotted first (Auto-backup before refresh). unlink: detaches the line uid, keeping its values as an ordinary assumption. A self-link is rejected; a cross-model cycle resolves one hop per refresh. Link status and staleness: layerz_list_integrations { include_external_refs: true }. Persists one version labelled with summary. Not advertised to read-only keys.
Inputs: op (required), summary (required), uid, name, +7 more.
layerz_get_conventionsGet conventionsARead-onlyIdempotentInspect
Returns the conventions the tools' values are expressed in: custom_instructions (the conventions of a workspace, the standing instructions for AI agents its members share, ≤ 3000 chars, empty string when unset; also carried as conventions by the entry tools on a model), workspace ({ id, name, kind }: the targeted model's workspace when the caller is a member of it, else workspace_id, else the personal workspace) and, when a model is targeted, finance_md (the model's FINANCE.md: raw Markdown, source, spec_version, parsed front_matter with currency / units / sign convention / glossary, validation_errors; null when the model has none). include_guide: true adds guide, the modeling guide (session workflow, structure, stock-flow, lists, branches, sources, templates, checks, versions; also the resource modeling-guide://reference); include_formula_spec: true adds formula_spec, the formula language (functions, lags, list subscripts; also the resource formula-spec://reference), for a client that cannot read resources.
Inputs: model_id, workspace_id, include_guide, include_formula_spec.
layerz_get_modelGet model detailARead-onlyIdempotentInspect
Returns the full detail of a model: items, lists, timelines, custom formats, number_locale, glyph, revision_id (sha256 fingerprint) and version_number, plus branches[] (id, display_name, priority, actuals_through, actuals_through_locked) and sharing with the roster (members[]: owner, collaborators and pending invites with their roles and ids, is_owner, link_visibility: invite = sign-in required, public = anyone with the link reads it). Item values are the base plan; read a branch with layerz_read branch_id. Larger payload than layerz_read, which returns a filtered snapshot. conventions carries the workspace conventions and the model FINANCE.md (as in layerz_get_conventions) when either is set.
Inputs: model_id.
layerz_historyList version historyARead-onlyIdempotentInspect
Returns the version history of a model, newest first: { current_revision_id, current_version_number, history_days, hidden_count, oldest_hidden_at, pinned_count, max_pinned_versions, versions: [{ revision_id, version_number, created_at, trigger_type, actor_user_id, label, conversation_id, pinned }] }. Each version is a full snapshot persisted at one mutation boundary; revision_id (sha256 of the snapshot) is stable while the model is unchanged. Versions older than the plan window are counted in hidden_count but not listed; pinned versions stay listed whatever their age. limit and since scope the list. With uid, returns instead that item's change events across the history: { uid, events: [{ revision_id, version_number, created_at, actor_user_id, trigger_type, status: added | removed | modified, fields?: [{ field, oldValue, newValue }], branches?: [{ id, display_name, status, fields? }] }] } — fields describes the base plan, branches the overlay cells a branch records over it (a write under branch_id or an import on a branch lands there, not in fields).
Inputs: uid, limit, since, model_id.
layerz_import_branchImport data into branchADestructiveInspect
Writes values onto a branch of the model, creating the branch when branch.id names none (branch.display_name required then). Two sources, mutually exclusive: entries[] (one value per item and period, items resolved by item_uid or item_label, created as assumptions when absent; entry_uid / entry_label target one entry of a list-mode item) or file_id (an uploaded spreadsheet parsed server-side, rows classified with the source's mapping rules). A new version of a file already imported: file_id + replace_source_id, nothing else (refreshed in place on the branch it feeds, default included). A first file onto the base: file_id + branch.id: "default" (a new source, own rows only). A new file of a kind the model already has: file_id + rules_from_source_id (classified with that sibling's rules, copied onto the new source). An entry's timeline_ref equals the target item's grain or constant; on a formula / balance it is a per-period override; on a callup it lands on the source. replace: true (with branch.id) wipes the branch's rows before writing; replace_scope: 'import' wipes only this source's own rows; merge: true upserts cell by cell; dry_run: true returns the impact without persisting (purged_periods, overridden_items, validation_errors_new, suggested_replace_source). Returns counts, warnings and, on the file path, skipped, opening_entries, rules_copied, file_structure. Persists one version labelled with summary.
Inputs: branch (required), summary (required), merge, dry_run, +11 more.
layerz_list_integrationsList data sourcesARead-onlyIdempotentInspect
Lists every data source feeding a model: API connectors (Qonto, Pennylane, Stripe, Airtable, Metabase) and file imports (kind csv | fec), each with kind, display_name, branch_ids (the branches it feeds), sync status, last_synced_at and source_fields (the payload fields an API connector's field_map can re-point its description / category / account_number to; null when there is nothing to choose). A row with legacy_import_id is a materialized pre-staging import that owns input rows but staged no transactions. include_external_refs: true adds external_refs: the links to items of other Layerz models, each with a value-aware stale flag (the source moved in a way that changes the snapshot) and its source health. Stored credentials are not returned.
Inputs: model_id, include_external_refs.
layerz_list_mappingsList mapping rulesARead-onlyIdempotentInspect
Lists the import classification rules in scope for a model: sets (each with a scope: model = the model's own rules, system_template = the curated country catalogs (PCG, US GAAP, UK, SKR03/04), user_template = the reusable catalogs of the caller's workspaces), mappings (every effective rule: pattern → target item, sign, source scope; total counts them) and templates (the catalogs importable through layerz_manage_mapping { op: "import_template" }). A model classifies with its own model rules only; a catalog applies once imported. A pattern is a case-insensitive glob where * matches anywhere. include_user_mappings: true adds the catalogs of the caller's workspaces to sets / mappings; include_coverage: true adds per-rule match_count and a coverage block (auto-created count, ignored count, the top keys routing nowhere).
Inputs: model_id, include_coverage, include_user_mappings.
layerz_list_modelsList modelsARead-onlyIdempotentInspect
A user's Layerz models are where their financial models, budgets, forecasts, closes and imported Excel models persist from one session to the next. Lists the models the authenticated user can access, most recently edited first, and the workspaces they belong to (workspaces[]: id, name, kind personal | team, role admin | member, plan, has_conventions). Each model carries id, name, workspace_id, can_write (owner, workspace member or editor guest) and updated_at; layerz_get_model returns its detail. limit caps the list (default 20, at most 200) and total counts every match. q filters by name (case- and accent-insensitive substring, * wildcard), writable: true keeps owner/editor models only. A model-scoped key gets its bound model only.
Inputs: q, limit, writable.
layerz_list_templatesList templatesARead-onlyIdempotentInspect
Lists the model templates the caller can start from: the official templates curated by Layerz and the workspace templates of the caller's workspaces (each workspace's library, read by its members and not by its guests; workspace_id names it). A template is a read-only copy published from a model in the web app; this tool reads it and changes nothing. Each entry carries name, subtitle, glyph, description (the template's FINANCE.md, its usage guide), scope and a structure summary (section names + item count). With template_id, returns that single template in full, blueprint included. A template forks into a new model through layerz_create_model { template_id } and applies as a module through layerz_build_from_blueprint { template_id }.
Inputs: scope, template_id.
layerz_list_transactionsList staged transactionsARead-onlyIdempotentInspect
Returns a data source's staged transactions (API connector or csv/fec file import) annotated with their routing: the target item and whether a rule or an auto-created item matched, the skip reason otherwise (mapping is the only routing path, no fuzzy match), or ignored for a row an __ignore__ rule routes nowhere on purpose. period (YYYY-MM) and q (substring on description/category) filter the rows; the rows come one page at a time (limit, default 200, at most 1000; offset), with the matching total on the first page. The full staged import as a CSV file is layerz_export { target: 'transactions' }. A materialized legacy import derives one row per owned cell from the model's input rows.
Inputs: connection_id (required), q, limit, offset, +2 more.
layerz_manage_integrationSync, configure or delete data sourceADestructiveInspect
Runs one operation on a data source (API connector Qonto, Pennylane, Stripe, Airtable, Metabase, or a csv/fec file import) by op. sync: pulls the provider's rows into the bound branch as a replace of this source's own rows (the baseline is untouched); on a file source, replays the projection over the staged rows; target_branch_id lands a still-unbound connection on an existing branch; dry_run: true reports the impact without persisting. rebind: re-points the source at branch_ids, wiping its rows from detached branches and reprojecting into the new ones. update: renames the source (display_name) and/or applies config then replays the projection; a change of import_level or of a tabular mapping (field_map, measures, sign_rule) re-fetches and re-stages, and is rejected on a csv/fec file source. delete: disconnects the source, drops its staged transactions and purges everything it projected into the model (input rows, provenance, import entry); items and the branch are kept, emptied; when the purge would destroy values the source cannot re-project, the call is refused with PURGE_CONFIRMATION_REQUIRED and a purge_preview, and a retry with confirm_purge: true performs it. Every projecting op returns unmapped, proposed_window, deletable_items (reported, not removed), cutover_changes, shadowed, warnings. Credentials stay in the web app. Persists one version labelled with summary. Not advertised to read-only keys.
Inputs: op (required), summary (required), connection_id (required), config, +7 more.
layerz_manage_mappingSet, delete or import mapping rulesADestructiveIdempotentInspect
Writes the model's classification rules by op, in its single mapping set. set: creates or updates rules identified by (source_id, pattern, secondary_pattern), one rule from the flat fields or up to 500 in rules. pattern is a case-insensitive glob (* anywhere: Apport*, *641) tested against the source's primary key, secondary_pattern (default *) against its secondary key; source_id is the data source the rules classify, or source_ids writes the same rules on several sources at once (one file per exercise: one correction, every year; a rules item may name its own source_id); target is an item name or uid, uid::entryUid for one list entry, or __ignore__; sign (natural | negate | absolute) adjusts the amount. The batch is validated whole: one failure writes nothing; each rule reports created, updated or unchanged, a replay writes nothing. delete: removes mapping_id or every id of mapping_ids (up to 500). import_template: copies the catalog template_id onto source_id (targets by item name; a conflict overwrites, reported in overwritten). copy: gives source_id the rules of rules_from_source_id (another source of the model) by rule key, on_conflict keep (default) or replace; reports copied, replaced, kept, unchanged. A rule change applies on the next layerz_manage_integration { op: "sync" }. Rules are versioned under summary; a restore puts them back. Not advertised to read-only keys.
Inputs: op (required), summary (required), sign, rules, +11 more.
layerz_manage_versionPin, unpin or restore versionADestructiveIdempotentInspect
Acts on one version of a model (version: exactly one of revision_id, version_number, id) by op. pin: keeps the version listed, diffable and restorable beyond the plan history window; capped per plan (max_pinned_versions, 403 past the cap); a no-op on a pinned version. unpin: frees the slot; a version past the window then stops being listed. restore: replaces the live items, schema and inputs with that snapshot, and puts back the source settings (window, keys, bindings) and the mapping rules as they stood at that version, after saving the current state as a restore backup version (backup_version_id, null when the live state already matched the latest snapshot); requires summary, the label of the restored state. Returns { ok, version_id, version_number, revision_id, pinned, pinned_count, max_pinned_versions } for pin / unpin, { ok, restored_version_id, restored_version_number, restored_revision_id, backup_version_id, sources?: { sources_restored, rules_written, rules_removed }, warnings[] } for restore — warnings names what could not come back (a source deleted since, a rule whose target is gone, a version written before source versioning). The target is inside the plan window or pinned. Not advertised to read-only keys.
Inputs: op (required), version (required), summary, model_id.
layerz_match_itemsMatch labels to itemsARead-onlyIdempotentInspect
Resolves free-text labels (e.g. row labels of a parsed file) to existing item UIDs of a model: the top 3 candidates per label across exact_uid, exact_name, slug and fuzzy (Levenshtein) methods, each with a score. An empty candidate list means no existing item matched. Deterministic, no LLM call.
Inputs: labels (required), model_id.
layerz_parse_fileParse uploaded fileARead-onlyIdempotentInspect
Parses an uploaded Excel/CSV (file_id) deterministically and returns a token-optimized structure: sheet summaries (without sheet_name) or, for one sheet, the detected timeline, suggested_structure (layout, header row, columns), row labels and column headers with samples. A wide sheet is recognised by its period header: a run of at least three consecutive periods (bare years such as 2026, YYYY-MM, Jan 2026, Q1 2026, date cells) in any column, reported as detected_periods and period_range. A raw DATEV EXTF export and a French FEC (compact YYYYMMDD dates) are detected natively; on any columnar ledger a journal column of short codes is mapped as category_column, and its opening journal (AN, RAN, ANO, AD, or a journal labelled "à nouveau") is read as opening entries (opening_rows; prior-year rows moved into the first month) — remap or ignore that column to change it. structure_override re-parses with corrected columns when a ledger is misdetected (a Débit column taken as the value, an account-code column taken as the label) or when a wide sheet has fewer than three period columns (layout: "wide"). Without sheet_name, a model workbook (formulas under period headers) also returns workbook (how far the Excel engine recalculates it, its scenario selectors with their scenarios, its data tables) and guidance. The raw binary is not returned.
Inputs: file_id (required), sheet_name, structure_override.
layerz_patchApply model patchADestructiveInspect
Applies a batch of mutations to a model: create, replace, update, delete, move, list_create, list_update, list_delete and meta (name, subtitle, finance_md, timelines, formats, number_locale, default_branch, glyph). The batch is all-or-nothing: a validation failure persists nothing and returns every error at once (MODEL_VALIDATION_ERROR, details[]). A create may carry a temp id later ops reference (parent, source, target, series, liste_ref, after, before, $_id in a formula); map gives each temp id its UID. replace keeps the item's UID and presentation fields; update is a strict partial merge of the named fields. after / before (create, move, list ops) order siblings and tabs; unchanged: true: nothing written. Root accepts section and dashboard; dashboard accepts widgets only; a formula with both an expression and children is rejected (FORMULA_EXPR_AND_CHILDREN); a list-mode item takes timeline_values, a non-list item value / values. branch_id routes the value writes onto that branch as an overlay of the cells differing from the base; compute returns the computed series of the given UIDs (under compute_branch, default branch_id); dry_run validates and computes without persisting; compare_values adds value_diff (as in layerz_diff). Persists one version labelled with summary. Not advertised to read-only keys. Modeling patterns and examples: resource modeling-guide://reference.
Inputs: ops (required), summary (required), compute, dry_run, +4 more.
layerz_readRead model snapshotARead-onlyIdempotentInspect
Returns a UID-native snapshot of a model: model (name, timelines, lists, branches), items (flat, parent_uid carries the hierarchy, each with role, formula, check, note; values are the base plan) and revision_id / version_number. Filters: uids, roles, include_children. with_values: true adds the computed series v aligned with the periods p (periods for explicit labels of mixed grains, else granularity), variance adds vv, per_element adds ve for list-mode items, health adds the check report, branch_id computes v and health under one branch's [base, branch] checkout, else they are the base plan. The check report is judged on a branch checkout: without branch_id, a multi-branch model reports the branch it opens on (health.branch_id) and every branch under health.by_branch. When the response leads with computable: false, errors[] names the broken dependencies (e.g. CIRCULAR_DEPENDENCY) and every series is a zero-filled placeholder. A read without uids or roles also carries conventions (workspace conventions + model FINANCE.md, as in layerz_get_conventions) when either is set, and guidance (the rebuild method of the modeling guide § 12) on a model of 1000 items or more.
Inputs: uids, roles, health, periods, +8 more.
layerz_set_custom_instructionsSet custom instructionsADestructiveIdempotentInspect
Replaces the conventions of a workspace (the personal one by default, or workspace_id): the standing instructions for AI agents its members share (plain Markdown/text, ≤ 3000 chars; an empty string clears them). They apply across every model of the workspace, on top of each model's FINANCE.md, and come back as conventions in the results of the tools that open a model of the workspace. Any member may write them. No version is persisted. Not advertised to model-scoped or read-only keys.
Inputs: content (required), workspace_id.
layerz_set_finance_mdSet FINANCE.mdADestructiveIdempotentInspect
Replaces the FINANCE.md attached to a model with the given Markdown (YAML front matter + body, ≤ 5,000 chars). source: 'imported' marks content synced from a project-root file, 'user' (default) content authored in place. The content parses as a YAML front-matter document; schema warnings are returned without blocking. A template is a read-only published copy and is out of this tool's reach; a model's FINANCE.md becomes a template's usage guide when the model is published from the web app. Persists one version labelled with summary. Not advertised to read-only keys.
Inputs: content (required), summary (required), source, model_id.
layerz_update_branchCreate or update branchADestructiveIdempotentInspect
Creates or updates a branch. With dataset_id, patches that branch's metadata (display_name, priority, source_hint, file_name, actuals_through). Without it, the branch named patch.display_name is updated when it exists and created otherwise, with no data source and no input rows. ops (the layerz_patch operations) are applied on the branch in the same call, as layerz_patch { branch_id } would: a scenario that changes a value is one call; the result then carries patch. priority is rejected on the default branch. An explicit actuals_through pins the real/forecast cutover (actuals_through_locked: true: source syncs stop rewriting it); null resets it to auto. Returns { branch, created }. Persists one version labelled with summary. Not advertised to read-only keys.
Inputs: patch (required), summary (required), ops, model_id, +1 more.
layerz_validate_modelValidate modelARead-onlyIdempotentInspect
Runs the core model validator (structural / formula / timeline checks) without writing and returns { ok, error_count, warning_count, errors[], warnings[] }; each issue carries a code (e.g. UNKNOWN_UID, CIRCULAR_DEPENDENCY, INVALID_ROLE_CHILD, TIMELINE_MISMATCH), a message and item_uids. The write path auto-repairs some of these issues and enforces a few invariants this audit skips, so ok: true is a sanity signal rather than a write guarantee.
Inputs: model_id.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Related MCP Connectors
AI-native data layer: sheets, databases and apps for every agent, with exact answers and audit.
Personal finance for AI agents — onboard, import statements, categorize & budget over MCP.
Connect AI agents to financial institution origination, analytics, and compliance workflows.
Build financial models as code. Cloud execution, GSheets MCP, version control, collaboration.
Related MCP Servers
AlicenseNot gradedqualityBmaintenanceEnables AI agents to build, edit, validate, version, and export structured financial models with items, formulas, dependencies, scenarios, and actuals through MCP tools.MIT
OpenVariance MCP Serverofficial
AlicenseNot gradedqualityBmaintenanceEnables AI agents to perform variance analysis, generate reconciling driver bridges and three-statement forecasts, export Excel workbooks, and analyze SEC or private-company financial data locally with engine-verified calculations.MIT- FlicenseAqualityCmaintenanceProvides AI agents with deterministic, offline finance tools for commodity margin analysis, loan covenant compliance, invoice auditing, AP exception classification, and five-day close readiness.143 npm-
- AlicenseNot gradedqualityDmaintenanceFinancial intelligence for AI agents. Give Claude access to insider trading data, SEC filings, economic indicators, and multi-signal analysis — all through a single MCP server.MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.