Building Dashboards with an AI Agent

Instead of clicking around the dashboard editor yourself, you can ask an AI agent (Penny, BankSync's in-app assistant, or an external agent like Claude) to build a dashboard for you in plain English: "Make me a spending-by-category dashboard for my Chase feed, last 90 days." The agent does the work through a set of dashboard authoring tools, and what it creates is a real, editable dashboard you can open and tweak by hand afterwards.

This page explains what the agent can do, the order it works in, and the honest limits of the feature today.

A few plain-language terms used here:

• An AI agent is an assistant (for example Claude) connected to BankSync that can call BankSync's tools on your behalf.
• A tool is a single named action the agent can take, like "list my feeds" or "create a widget". The agent picks which tools to call; you just describe what you want.
• A feed is one of your synced data sources (for example a Chase transactions feed). The agent builds on top of feeds you have already connected.

Two ways to build#

There are two ways to get widgets onto a dashboard, and it helps to know which one this page is about:

The rest of this page is about the second surface: asking an agent to build dashboards for you.

What the agent can build#

Once connected, the agent has tools to do essentially everything you can do in the editor, plus a few discovery tools it uses to figure out what is possible. The main groups:

The quickest route is compose dashboard: one call creates the queries, the widgets, and the dashboard together, with a real 12-column layout. Unless the agent passes its own layout, BankSync packs the widgets for it: KPIs in a row across the top, charts in half-width pairs, tables full width, and rows that fill the grid rather than leaving gaps. The agent can also stage the result as a draft and commit it once you have reviewed it.

An agent can also build step by step. A short slice of that looks like this. It creates the dashboard, then pins a widget it built earlier onto it (each step is one tool call, with the tool's reply shown beneath):

// 1. The agent creates the dashboard and gets back its id + slug.→ create_dashboard {    "slug": "spending-overview",    "name": "Spending Overview"  }← { "dashboardId": "dash_8fK2", "slug": "spending-overview" }
// 2. It pins the bar-chart widget it already created at a large footprint.→ attach_widget {    "dashboardId": "dash_8fK2",    "widgetId": "wgt_4Qa9",    "size": "l"  }← { "dashboardId": "dash_8fK2", "placementId": "place_Lm3" }

A good agent narrates each step in plain English as it goes ("creating the dashboard, now pinning the spending chart"), and the dashboard appears in your list the moment these calls return.

The building blocks, briefly#

When the agent builds a dashboard it works with the same three pieces you do in the editor:

• A Query is the recipe for the data: which feed to read, and how to shape it (for example "Transactions, group by category, sum the amount, last 90 days").
• A Widget is the visual: a chart, a KPI big-number, a table, or a gauge. A view widget points at a query.
• A Dashboard is the page that holds widgets in a grid, with optional shared filters across all of them.

The agent typically creates a query first, then a widget that reads it, then pins the widget onto a dashboard. For more on what a query can do (joining feeds, multi-step shaping), see Shaping data.

How the agent works: a worked example#

Suppose you ask: "Build me a spending-by-category dashboard from my Chase transactions feed for the last 90 days, and add a Total spend KPI." A capable agent works roughly in this order. The labels in parentheses are the tools it calls, so you can recognise them if your agent shows its steps.

The agent could do all of this in a single compose dashboard call instead. Either way, the result is a normal dashboard. Open it in the editor and you can resize widgets, change the chart kind, swap the feed, or add more, exactly as if you had built it yourself.

Tidy defaults for agent-built widgets#

Agents tend to write long titles and label numbers with raw field names. So every widget an agent creates (through Penny, MCP, or a template) is tidied before it is saved:

• Short titles. A title is kept to 28 characters. A period phrase such as "Last 30 days" or "YTD" moves out of the title into the widget's description, which the card shows as its subtitle. If a title still has to be shortened, its full wording is kept in the description.
• No field names as KPI labels. A KPI label that is really a field name (such as total_spend) or that repeats the title is dropped, so the card reads cleanly.
• Sparklines that know their field. A KPI sparkline with no field set plots the KPI's own number.
• One axis unless asked. Only layered charts draw a second, right-hand axis. A stray right-axis setting on any other chart is reset; a layered chart keeps the axes the agent asked for.

You can change any of these by hand afterwards.

Starting from a template instead#

The agent does not have to build from scratch. Templates — BankSync's own and every creator's — are marketplace listings, and the agent installs one the way the app does: it finds the template (marketplace_search), asks what installing it needs (installs_plan), then installs it (installs_create), connecting each of the template's data requirements to one of your feeds or banks. This is the fastest path when a prebuilt dashboard already matches what you want.

installs_plan changes nothing: it lists each requirement and whether the bindings given answer it, so a missing feed is reported by name and the agent can tell you what to connect first rather than producing an empty dashboard. See Dashboard templates for how templates and their requirements work.

Here the agent installs Spend by category, filling its txns requirement with a Chase transactions feed:

→ installs_plan {    "source": "listing",    "listingId": "lst_…",    "bindings": { "txns": { "kind": "feed", "feedId": "feed_chase_txns" } }  }← every requirement answered; one widget will be created→ installs_create { /* the same source and bindings */ }← the install, and the widget it made in your workspace

Editing and tidying up#

The agent is not limited to creating. It can also:

• Update an existing dashboard or widget: rename it, change its chart kind, swap the query it reads, or adjust its filters.
• Organize: create folders, move dashboards between them, and reorder.
• Delete: remove a dashboard, widget, query, or folder you no longer need.

Publishing through the agent#

The agent can publish a finished dashboard, or a single widget on its own, to a shareable link. Publishing sets the dashboard's visibility and, where public sharing is enabled for your workspace, returns a share URL and an embed snippet.

Two honest caveats the agent should pass along:

• Public sharing is rolled out per workspace. If your workspace is not yet provisioned for public serving, publishing returns no link rather than a dead one. The dashboard is still saved; it just is not shareable yet.
• Regenerating a link revokes the old one. Asking the agent to regenerate a share link rotates it, so any previously copied link or embed stops working.

For the full picture of share links, embeds, and how published dashboards behave, see Publishing and sharing.

When the agent publishes, the tool returns the share and embed URLs (where public sharing is enabled for your workspace), which the agent then passes back to you:

→ publish_dashboard {    "dashboardId": "dash_8fK2",    "visibility": "public"  }← {    "shortcode": "sc_7Hq2Lp",    "urls": {      "share": "https://app.banksync.io/share/sc_7Hq2Lp",      "embed": "https://app.banksync.io/embed/sc_7Hq2Lp",      "canonical": "https://app.banksync.io/d/dash_8fK2"    }  }

If your workspace is not yet provisioned for public serving, shortcode comes back null with no share URL: the dashboard is saved, it is just not shareable yet.

What to expect, and the limits#

A few real limits to set expectations:

• Beta. Dashboard authoring is part of the dashboards public beta, so tools and results may still change.
• The minimal-spec tradeoff. When the agent creates a widget, BankSync deliberately does not force every advanced chart-styling option at create time, so reasonable minimal widgets are accepted. The agent uses the separate validate step to check the visual contract; some fine styling is then adjusted in the editor.
• Live preview is in the app. The agent can confirm a widget definition is valid, but rendering it against your live data with a visual preview happens when you open the dashboard in BankSync. In some environments the agent cannot run a full data preview itself and will tell you to open the dashboard to see it.
• You stay in control. Nothing the agent builds is hidden. It all shows up in your dashboards list and content tree, ready for you to review and change.

Related guides#

• Dashboards overview: the four parts of a dashboard and how saving works.
• Binding data: how a widget reads from a feed or live bank source.
• Shaping data: joins, multi-feed queries, and multi-step shaping the agent can build.
• KPI, table & gauge widgets: the non-chart widget kinds the agent can create.
• Dashboard templates: starter dashboards the agent can instantiate against your feeds.
• Publishing and sharing: share links, embeds, and how published dashboards behave.