- Brand
- Abacum
- Category
- Finance
- Primary Subcategory
- Financial Planning & FP&A Analytics
Integration details
Description
Ask ChatGPT about your business, and get answers straight from your Abacum data. Abacum, the AI-native business planning platform, gives ChatGPT governed access to your workspace: actuals, budgets, forecasts and scenarios across every dimension, the tables in your Spaces, the logic behind every model and the source data that feeds them. Review budget vs actuals, see the variance behind what moved, and compare forecasts and scenarios, all on the same numbers your team plans on. ChatGPT can only reach what your Abacum user can see, and nothing saves without your approval. Built for FP&A and finance teams and the business leaders they plan with. Requires an Abacum account, with access turned on by your admin.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- Financial Planning & FP&A Analytics
- Secondary Subcategories
- None listed
- Brand
- Abacum
- Access
- Account required
- First tracked
- 2026-11-20
- Tool count
- 28
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Not discoverable in ChatGPT yet
ChatGPT now suggests Plugins on its own when they match a user's request, but not every Plugin is being surfaced yet.We haven’t seen Abacum suggested yet. Sign up and we’ll track it, and your Discoverability Score will appear here once ChatGPT starts surfacing it.
What discovery looks like

Get alerts for Abacum
Get updates when Abacum’s Discoverability Score or category rank changes.
Competing in ChatGPT Financial Planning & FP&A Analytics
View Category28 tools agents can invoke
Write a previewed plan to its input table, exactly as the user saw it. Call this once the user confirms the plan from abacum_preview_input_table_edits. It overwrites those cells, and overwritten values are not recoverable through this tool. If any value in the plan changed since the preview, nothing is written and the call fails with VALUE_EDIT_PLAN_OUTDATED: read the table again, preview again and ask the user again. A plan is written once at most, and a plan whose apply fails for any other reason, VERSION_BUSY included, is cancelled: do not send that plan_id again, preview again instead. The one exception is a refusal saying the plan is 'applied': it was already written, so tell the user it is done and do not preview it again.
abacum_apply_input_table_edits
Write a previewed version plan, exactly as the user saw it. Call this once the user confirms the plan from abacum_preview_version_edits. It overwrites those cells, and overwritten values are not recoverable through this tool. If any value in the plan changed since the preview, nothing is written and the call fails with VALUE_EDIT_PLAN_OUTDATED: preview again and ask the user again. A plan is written once at most, and a plan whose apply fails for any other reason, VERSION_BUSY included, is cancelled: do not send that plan_id again, preview again instead. The one exception is a refusal saying the plan is 'applied': it was already written, so tell the user it is done and do not preview it again.
abacum_apply_version_edits
Create, edit and reorder a model's variables in one call. Deleting a variable is not available. Only an admin can do this. It runs the same save as the Module Builder: either every change applies or none does, and a refusal means resending the whole call. Without version_id it changes the actuals side; with one, also the version fields of that version. Names, formats, aggregation and the order apply to actuals and every version either way. To build a model, send every variable with its actuals formula and, through version_id, its version formulas in one call. For each further version, send one more call with that version_id and the created variables as edits. Every save changes the updated_at of each variable it touches, so always send the updated_at from the latest response, never an older one. Variables you created in this conversation need no read in between. To change variables you did not create here, read abacum_get_model_logic first for their codes, section ids and updated_at. A 409 with code stale_variable means someone saved that variable after you read it. Read the logic again, tell the user what changed since they saw the plan, and ask before you send the change with the new updated_at. The same holds when you read the logic again for any other reason and a variable you change has a new updated_at: never overwrite newer work without asking. Values recalculate in the background, and the response names the variables still pending under actuals and version. A variable created without version_id has no forecast logic yet, as in the model builder: its version cells stay blank until a version gets use_actuals_formula or version_formulas. Tell the user, and offer to set it for the versions they name. Formula rules, so the save is not refused: - Refer to another variable of the model by its code, UNITS * PRICE. A plain number is a constant. - Refer to the variable itself as This, never by its own code and never as THIS. In a version formula This always takes a period: This.t-1 * 1.05. - Earlier periods: CODE.t-1 one month back, CODE.t-3:t-1 a range, CODE.LM last month, CODE.MLY the same month last year, CODE.Jan25 a fixed month, CODE.YTD year to date. - Conditions: IF MonthNumber > 6 THEN (UNITS * PRICE) ELSE 0, with IS, IS NOT, >, >=, <, <=, AND, OR, NOT. A THEN or ELSE value with an operator goes in brackets. ISBLANK works only inside an IF: IF ISBLANK(This.t-1) THEN 0 ELSE This.t-1. - SUM(DATASET, measure), COUNT(DATASET) and AVERAGE(DATASET, measure) work only in the actuals formula, filtered with WHERE dimension_level_1 IS 'item'. A version formula reads them through use_actuals_formula. Dataset and measure names come from abacum_get_datasets. GET(MODEL, CODE) reads another model, in either formula. - MOVING_AVERAGE(3, monthly) is a whole version formula on its own, never combined with others.
abacum_change_model_variables
Create an empty model. Only an admin can do this. Unless the user asks for a restricted one, the model is visible to every admin. It arrives with no variables and no data, so the user still has to build it. A name the system cannot turn into a code, one with no letter in it, is refused. Ask the user for the name rather than inventing one.
abacum_create_model
Describe one input table: its variables, their dimensions, and its version columns. Call this before previewing or writing, because the edits take the column's scenario_id exactly as this returns it. Each column says whether the user can edit it, and gives the reason when they cannot. This returns no rows: to name the rows an edit changes, read them with abacum_read_input_table_rows and use their dimension items exactly as it returns them.
abacum_describe_input_table
Overwrite values in one input table, replacing whatever those cells held. Only a user whose Abacum permissions let them edit that table in that space can do this, and a locked version refuses the whole call. The edits are applied together or not at all: if one row cannot be written, nothing is written and the plan says which rows failed and why. Overwritten values are not recoverable through this tool. Prefer abacum_preview_input_table_edits and then abacum_apply_input_table_edits, so the user sees the plan and nothing that changed meanwhile is overwritten; use this only when the user asks to write without a preview.
abacum_edit_input_table_values
List the input tables where the user can edit a variable. A variable is edited through an input table inside a space, so start here when the user asks to change a number. Each entry holds input_table.id and its spaces, each with an id and whether the user can edit there; those are the input_table_id and space_id the other input-table tools take. A 404 "No input table you can view holds this variable" means no table holds it for this user: an admin can still edit it in a whole version with abacum_preview_version_edits, and anyone else cannot.
abacum_find_input_tables
Get the full calculation logic and structure for every variable in a model: formulas (with variable dependencies expressed through formula references), dimension assignments, aggregation types, and formatting metadata. Use this tool to understand how a model's variables are connected — which formulas drive which outputs — and to analyze the model's structure for potential improvements (e.g. variables missing dimension assignments, inconsistent aggregation types, overly complex or fragile formulas). This is the right tool any time the user wants a model explained, reviewed, or improved, even if they don't ask for "model logic" by name. CRITICAL: ALWAYS call abacum_get_models first to get a valid model_id. Do NOT assume model IDs from past conversations. When scenario_id is omitted, the organization's active Forecast version is used by default (falling back to the active Budget version if no Forecast is active) — check the response's resolved_scenario_id to see which one. If neither exists, every variable's version is null and note explains why; the version/forecast layer is never silently dropped. Pass scenario_id explicitly to pin to a specific plan instead of the org's default, or pass 'actuals_only' to skip the default and get actuals-only logic on purpose. Access: super-admins see logic for all models; admins see logic only for models that are unrestricted or explicitly granted to them; members cannot use this tool.
abacum_get_model_logic
Get a single space table's metadata: variables, versions and time periods. Use this before downloading rows via ``abacum_execute_sql`` to understand the table's schema, pick relevant variables, and check which periods the table covers. ``time_periods`` is a list of period configs (shape varies by ``preset_type``: BETWEEN has ``start_date``/``end_date``/``timescale``; RELATIVE has ``start_of``/``end_of`` anchors with offsets; MTD/QTD/YTD/FYE have a ``date``). Read it to decide whether the table's period coverage matches what you need before downloading data.
abacum_get_space_table
List the datasets the current user can access (the integration data that feeds models). Datasets have two variants: ``raw`` (what the integration sent, before processing) and ``processed`` (after typing, transformations and classification — the data that feeds models). Each item includes name, code, connection_type (source), last_synced_at, last_processed_at, and both row_count_raw (rows as ingested from the source) and row_count_processed (rows after typing, classification and formulas). Processing only enriches the data with columns (classification, dimensions), so row_count_processed should never be lower than row_count_raw; if it is, rows were lost in processing. Access: super-admins see all datasets; admins see the ones granted to them; members none.
abacum_get_datasets
List all DuckDB tables loaded in the current session. Returns each table's name, columns, row count, and the parameters it was loaded with, plus ``count`` in use and the session ``capacity``. Use this to recover context after a previous abacum_describe_data call rather than reloading the same data. A session holds 40 tables and expires after 30 minutes idle. It is keyed by the connection, not the chat, so tables loaded in another chat on the same connection count against the same 40. Call abacum_unload_tables to free slots.
abacum_list_tables
Get all available Abacum financial models. Call this before any tool that requires a model_id. Do NOT assume model IDs from past conversations — always fetch fresh values. Before selecting a model for a metric, call ``abacum_get_variables`` and check ``is_ai_priority`` across candidate models. Prefer any variable with ``is_ai_priority: true`` — the admin has flagged it as the authoritative source for that metric. Do not pick a model based on name heuristics alone.
abacum_get_models
Get all available Abacum scenarios (budgets, forecasts, rolling forecasts). This tool takes no arguments. Scenarios belong to the organization, not to a model, so there is no per-model scenario list and passing model_id will fail validation. Any scenario can be used with any model: fetch the scenario here, then pass scenario_id and model_id together to the data tools. Call this before any tool that requires a scenario_id. Do NOT assume scenario IDs from past conversations — always fetch fresh values.
abacum_get_scenarios
List the Abacum skills this organization can load, with a one-line description of each. A skill is expert guidance for one kind of task, for example explaining a model. Call this at the start of a task, pick the skill whose description matches the task, and load it with ``abacum_load_skill`` before you use the other Abacum tools for that task. The list depends on the organization's MCP plan and on the tools this user can use, so it can be empty. An empty list is not an error: continue the task with the tools alone.
abacum_list_skills
List tables in a space. CRITICAL: ALWAYS call abacum_list_spaces first to get a valid space_id. Returns table summaries (id, name, view_mode, timestamps). Call ``abacum_get_space_table`` for variables/versions/time_periods, then query rows via ``abacum_execute_sql``.
abacum_list_space_tables
List spaces the authenticated user has view access to. Spaces are the building blocks of Abacum: each one groups tables, charts and KPIs around a topic (e.g. board reporting, departmental review). Use the returned ``spaces[].id`` with ``abacum_list_space_tables`` to discover their tables. Pagination follows the standard pattern — ``pagination.next`` indicates more pages are available; call again with ``page=N+1``.
abacum_list_spaces
List all available Abacum variables (metrics/line items). Call this before any tool that requires variable_ids to filter data. Do NOT assume variable IDs from past conversations — always fetch fresh values. Each variable includes ``is_ai_priority`` — when ``true``, the admin has flagged this variable as the preferred source for its metric. Prefer it over similarly-named alternatives when the user's query doesn't specifically point to a different one.
abacum_get_variables
Load one Abacum skill, or one of its reference files, and follow it for the rest of the task. Without ``file`` this returns the skill itself. When the skill points to a reference file, call this again with that file's name from ``reference_files``.
abacum_load_skill
Load a dataset's raw or processed data into the SQL engine and return its schema. Datasets are the integration data that feeds Models. Each has two variants: - ``raw`` — exactly what the integration sent us, before any processing (arbitrary schema — read the returned ``columns`` to know what you can query). - ``processed`` — after typing, transformations and classification (the data that feeds Models). This is the DEFAULT when ``variant`` is omitted. Call abacum_get_datasets FIRST to get dataset IDs, then call this to discover the table name, columns, row count and a 5-row sample. The data is registered as a DuckDB view over a presigned S3 Parquet URL — query it afterwards with abacum_execute_sql, exactly like a Model. An optional YYYY-MM month range filters the data; provide both ends or neither. SESSION LIMITS: 40 tables at a time, expiring after 30 minutes idle. The session is keyed by the connection, not the chat, so tables loaded in another chat count against the same 40. When the cap is reached, call abacum_unload_tables to free a slot rather than waiting for the session to expire.
abacum_describe_dataset
Load Abacum data into the SQL engine and return its schema. Call this BEFORE abacum_execute_sql to discover the table name, columns, row count, and a 5-row sample. The data is registered as a DuckDB view pointing to a presigned S3 Parquet URL — subsequent SQL queries stream only the columns/rows they need. - ``model_id`` alone → actuals data. ADMIN ONLY. - ``model_id`` + ``scenario_id`` → scenario / budget / rolling-forecast data. ADMIN ONLY. - ``space_id`` + ``table_id`` → space table data. Available to members. PERFORMANCE: prefer MINIMAL date ranges unless the user asks otherwise — the SQL engine handles wide windows, but smaller loads are faster. If row_count = 0 the date range likely has no data — check ``last_actuals_date`` from abacum_get_models. SESSION LIMITS: 40 tables at a time, expiring after 30 minutes idle. The session is keyed by the connection, not the chat, so tables loaded in another chat count against the same 40. When the cap is reached, call abacum_unload_tables to free a slot rather than waiting for the session to expire.
abacum_describe_data
Show what a set of edits would change in an input table, writing nothing. Returns the same plan the write returns, with applied false: the resulting cells, the edits that would land, the ones that would be skipped and why, and any other values that would move with them. Show this to the user, and once they confirm, call abacum_apply_input_table_edits with the plan's plan_id. That writes exactly what the user saw, and is refused if any of those values changed in between.
abacum_preview_input_table_edits
Show what a set of edits would change in a whole version, with no space or input table, writing nothing. For admins only, for a variable that is not in any input table the user can edit: call abacum_find_input_tables first, and when it lists a table, use abacum_preview_input_table_edits instead, which keeps the space's filters. Every variable of a model the admin can open can be edited, in the rows it already holds in that version. A 'set' or 'copy' that names every dimension level of a row the variable does not hold yet adds that row, with items that already exist, as described for `dimensions`. Take version_id and scenario_id from the same entry of abacum_get_scenarios. Returns a plan with applied false: show it to the user, and once they confirm, call abacum_apply_version_edits with its plan_id.
abacum_preview_version_edits
Read the current values of one column of an input table, as the user sees them in that space. Call this when the user wants to see their numbers, or before an edit that depends on them, for example "set Q1 to the Q4 value". Each row says whether the user can edit it. Rows come in pages: while next_cursor is set, call again with it to read the rest.
abacum_read_input_table_rows
Rename a model, move it to another section of the model list, or restrict it. Only an admin can do this. The model's variables and data are untouched; only its name, its place in the list and who can see it change. Renaming is not reversible through this tool, so show the user the current name first. A request that changes nothing is refused.
abacum_update_model
Execute a DuckDB SQL query against the views loaded by abacum_describe_data. The dialect is DuckDB SQL (https://duckdb.org/docs/sql/introduction). Only single-statement SELECT (or ``WITH ... SELECT``) queries are permitted. Results are capped at 10,000 rows; an implicit LIMIT is appended if absent. JOINs, aggregations, window functions and CTEs are supported. Call abacum_describe_data FIRST to load data and discover table names.
abacum_execute_sql
Fuzzy-search the org's variables, models, tables, spaces, scenarios, and datasets by NAME. Use this as a discovery primitive: turn a user's natural-language reference ("the revenue line in the P&L model") into concrete IDs you can pass to the other tools (``abacum_get_variance_analysis``, ``abacum_get_space_table``...). For datasets (admin-only), turn a found ``id`` into queryable data via ``abacum_describe_dataset`` (then ``abacum_execute_sql``); ``abacum_get_datasets`` lists them all without a query. Each result row carries ``similarity_score`` (higher = closer match), an optional ``is_ai_priority`` flag (``true`` = admin-preferred variable — prefer it when multiple matches score similarly), and a ``parents`` chain (variable→model→table→space, table→space, sub-space→parent space, scenario→version) so the caller can disambiguate same-named entities. A row lists at most 5 of the tables that use it; ``tables_not_shown`` counts the rest. Which 5 are listed can change between calls. When ``tables_not_shown`` is above 0 and the table the user named is not listed, find it with ``abacum_list_space_tables`` / ``abacum_get_space_table`` instead of guessing. Query tips — the index is small and unforgiving: - Pass ONE short token (acronym, single word, stem). Multi-word queries are matched as a literal substring, not tokenized. - On empty results, retry with a shorter/synonym query before falling back. Scope — what is NOT searched: - Row labels inside table data (e.g. a "CLTV" line inside a KPI table). To find those, list ``abacum_list_spaces`` → ``abacum_list_space_tables`` → ``abacum_get_space_table`` (then query rows via ``abacum_execute_sql``) and scan the ``line``/``line_code`` columns. - Cell values, formulas, comments, descriptions. For exploration prefer ``entity_type='all'``; for follow-up filtering use a specific type with pagination.
abacum_search
Free loaded tables from the current session. Pass table_names to unload specific tables, or omit it to unload all of them. Freed slots accept new abacum_describe_data or abacum_describe_dataset calls immediately — there is no need to wait for the session to expire. Unloading only discards the loaded view. The underlying Abacum data is untouched and can be loaded again at any time.
abacum_unload_tables
Compare actuals vs budget/forecast with automatic variance calculations. Use this tool for board prep, profitability reviews, and forecast accuracy analysis. Returns actual values, baseline (budget/forecast), variance_abs, and variance_pct. CRITICAL: ALWAYS call abacum_get_models and abacum_get_scenarios first to get valid model_id and scenario_id values. Do NOT assume IDs from past conversations. PERFORMANCE OPTIMIZATION: - For profitability/performance reviews: Use last 3 months only (e.g., if today is Dec 2025, use start_date="2025-09", end_date="2025-11") - For trend analysis: Use last 6-12 months - Only request full history when explicitly asked by user - Default to MINIMAL date ranges unless user specifies otherwise.
abacum_get_variance_analysis
Abacum ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve Abacum's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are Abacum alternatives on ChatGPT?
As of 2026-11-20, Abacum competes with Aleph, Alvore Finance, Boldin, Caixa Semanal, Cash Flow Frog, CashflowPot, Centry Adviser Coordination, Centry Global Cashflow and 29 more in ChatGPT Financial Planning & FP&A Analytics, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.