# Shared Tables and Live Dashboards for Your AI

> Shared tables and live dashboards on Elaichi Black. A workflow writes the rows, your AI reads them, and leadership sees one published dashboard.

**TL;DR** Elaichi Black gives a team shared tables (collections) and live dashboards that a workflow fills. Claude, ChatGPT, Cursor or any MCP client reads them, with the Elaichi Agent beside them. The team's own AI drafts and test-runs the workflow on real data, every write held back; dashboards stay drafts until published. Storage past the free 1 GB-month allowance is $5 a GB-month in US dollars.

## Why do teams need shared tables and live dashboards for their AI?

Every Monday, someone copies this quarter's renewals from the CRM into a spreadsheet and sends leadership a screenshot. Elaichi Black replaces that with shared tables and live dashboards that sit next to your team's AI. A workflow writes the rows on a schedule. Claude, ChatGPT, Cursor or any MCP client reads them, and so does the Elaichi Agent. Leadership opens one published dashboard, not a screenshot that is stale by Wednesday.

A collection is the shared table. A dashboard is the page of metrics, charts and tables on top of it. The example is Jake Morgan's renewals tracker.

## What does a collection hold?

A collection is a shared table, or up to 20 tables with one share for all of them. Each table has its own fields and rows, and there are no joins between tables. In the console, Collections sits in the Automate group.

Fields take 12 types. They are text, long text, number, yes/no, date, date and time, one of a list, several of a list, person, email, link and structured data.

The limits are fixed:

| Limit | Value |
| --- | --- |
| Collections per organization | 500 |
| Fields per collection | 100 |
| Rows per collection | 1,000,000 |
| Size per collection | 1 GB |
| Size per row | 64 KB |
| Rows per write, through the API | 500 |
| Rows per write, from an AI client or the Agent | 100 |

A schema is a table's list of fields and their types. A schema change applies all at once or not at all. A change that would clear stored values can only be made in the console.

## Who can read and change a collection?

A collection is shared at one of three levels. View lets a person read it. Use also lets them write rows and restore them. Edit also lets them change the schema and share the collection. Only the owner can delete it.

Three permissions sit behind this: `collection:create`, `collection:share` and `collection:manage`. Create lets a person create collections, and work in the ones they own or can edit. The built-in Member role holds create and share.

Each collection lists its references, the workflows and dashboards that read or write it.

## How does row history undo a bad write?

Row history keeps earlier versions of each row, so a bad write can be rolled back. It is off by default. Turn it on per collection in Table settings, with "Keep a history of row changes".

Once it is on, Elaichi keeps 1 to 365 days of changes, 90 by default, and at most 500 versions a row. A row's menu offers "History of this row", where any version can be restored. A restore writes a fresh version, so it can itself be undone. Restoring needs use access; view is not enough.

Turn it on for any table a workflow writes into. Then a step that maps a field wrong costs a restore, not a rebuild.

## What can a dashboard show?

A [dashboard](https://en.wikipedia.org/wiki/Dashboard_(computing)) is a quick summary of the data behind one goal. In Elaichi, it shows widgets. Each widget reads a collection, a read-only tool from a toolbox (live data from a connected app), or workflow runs.

Widget types are metric, chart (bar, line, area, pie or scatter), table, markdown, progress, stepper, form, action and heading. A dashboard holds up to 10 pages, 24 widgets a page, 100 widgets in all, and up to 8 filters.

Every widget runs as the person looking at it, so sharing a dashboard never widens anyone's data access:

- A collection widget runs a query or an aggregate with the viewer's own access and row scope.
- A tool widget calls a read-only tool with the viewer's own use access on the toolbox and their own restrictions. It shapes the result with a [JSONata](https://docs.jsonata.org/overview) transform. JSONata is a query language for JSON. The result is cached per viewer for 60 seconds to 24 hours, 5 minutes by default.

## Walk-through: Jake Morgan's renewals tracker

Jake Morgan runs renewals. He wants a weekly table of accounts that renew this quarter, and a dashboard leadership opens on Monday. Claude and the Elaichi Agent do the building.

**The collection.** Claude calls `elaichi__collection__create` for a collection named Renewals. Its fields are Account (text), Owner (person), Renewal date (date), Annual value (number), Stage (one of a list), CRM record (link) and Notes (long text). Jake turns on row history with the 90-day default.

**The workflow.** A cron trigger runs it every Monday at 7:00 AM in America/New_York. A `call_tool` step reads upcoming renewals from the team's CRM connector. A `map_fields` step lines the results up with the table's fields. A `collection.upsert` step writes them, inserting new accounts and updating ones already there.

**The dashboard.** The Agent calls `elaichi__dashboard__create`. Then it calls `upsert_widget` for three widgets: a metric of annual value up for renewal, a bar chart of value by stage, and a table. The table lists accounts renewing in the next 30 days. `publish` makes the draft live, and the Agent asks Jake every time.

**The share.** Jake opens "Share", then "Manage access", and shares the dashboard at view with the leadership team. He shares the Renewals collection at view too, since each widget reads as its viewer. Without it, a viewer sees "You don't have access to the data this widget reads." Emily Carter, the CFO, opens it at 8:00 AM.

## Your team's own AI builds it and tests it first

Jake builds none of this by hand. His own AI does: Claude, ChatGPT, Cursor or any MCP client, or the Elaichi Agent in the console or in Slack. The Agent uses the same operation catalog that MCP clients use. So it can create the collection, write rows, build the dashboard and draft the workflow. The workflow is checked and tried before it goes live.

The loop runs in five steps:

1. **Draft.** The AI calls `elaichi__automation__draft__create`, then `draft__update` or `draft__patch` as Jake refines it. A draft saves even while it has validation issues.
2. **Validate.** `draft__validate` checks the definition without saving it.
3. **Test run.** `dry_run` over MCP, or "Test run (changes nothing)" in the console's Run now dialog, runs the latest draft against real data. Tools that only read run for real, as the person running the test. Tool calls that write are recorded as what would have been sent, and never sent. So are collection writes, state writes and knowledge writes. A notify step sends nothing. A test run costs no run time.
4. **Publish.** `publish` turns the draft into a numbered version, and is refused while validation finds errors.
5. **Turn on.** Turn on (`enable` over MCP) starts the triggers. An older version can be made live again from the Versions list in Details, with "Restore this version".

For a webhook trigger, the draft already has its address. A webhook is a message an app sends when something happens in it. Deliveries to the address are kept as samples, up to five for seven days. A test run can replay one as the trigger's payload.

The dashboard follows the same pattern. Edits land in a draft. The bar that holds unpublished changes offers "Review changes", "Publish" and "Discard draft". Viewers see only the published version.

With the Agent, creating or writing a collection or dashboard shows an approval card. It offers "Deny", "Allow once" and, when the action can be remembered, "Always allow". A remembered choice or the organization's automatic-writes setting skips the card. Publishing a dashboard or a workflow, and turning a workflow on, ask every time.

## One place, any AI, one set of rules

On Black, connectors, workflows, collections, dashboards and the AI that drives them sit in one place, under one set of rules. In Jake's tracker, a connector feeds the workflow, the workflow writes the collection, and the dashboard reads it. A `knowledge.search` step or an AI client can also pull answers from a knowledge base.

Any AI the team already uses reaches all of it. MCP (Model Context Protocol) is the standard way an AI assistant calls tools in other apps. Claude, ChatGPT, Cursor or any MCP client signs in to one address, `https://api.elaichi.ai/mcp`. The [MCP tools specification](https://modelcontextprotocol.io/specification/2026-07-28/server/tools) describes how those clients call tools.

- Collections use `elaichi__collection__` operations such as `query_rows`, `upsert_rows`, `row_history` and `row_restore`, up to 100 rows a write.
- Dashboards use `elaichi__dashboard__` operations such as `get`, `upsert_widget`, `publish` and `public_link__revoke`.
- Delete operations are offered only to a grant that allows destructive operations. A grant is the access a person approves when they connect a client.

The Elaichi Agent runs on the organization's own keys, one per AI provider. Its models are the same ones workflow agent steps use.

The same rules hold wherever a call starts:

- **One restriction check.** Every connected-tool call passes the same restriction check for the member it acts as. That holds from an MCP client, the Agent or a synthetic tool step. Emily's ChatGPT sees what Emily may see.
- **A named person behind every action.** A workflow runs as its owner, under the owner's restrictions. If Jake can no longer act, his workflow fails with `owner_invalid` and pauses instead of running on.
- **One audit log.** It holds one entry for each connected-tool call that reaches execution (a call refused earlier writes none). In Elaichi, export to your own Datadog comes with the Black plan.
- **One bill.** You pay per user, never for the AI apps working for them, plus usage pooled across the workspace.

Elaichi does not browse, search or fetch the web for a workflow or the Agent.

## How do public dashboard links work?

A public link shares a snapshot: a copy of a published dashboard, not live access. Public links are off until an admin turns them on for the organization, which needs `org:manage`. Until then, no one can create one.

Once they are on, the Member role's `dashboard:publish` lets a member create links for dashboards they can edit. The copy is captured with the publisher's access. A visitor never runs a data source, and sees only the widgets the publisher confirmed.

The rules:

- A link expires after 90 days by default, and can be set from 1 to 365 days. A link that never expires is not offered, and any link can be revoked.
- A dashboard holds at most five active links. Deleting the dashboard revokes them all.
- The copy refreshes by hand, or every 1, 6, 12 or 24 hours. It also refreshes after a run of a workflow that writes a collection the dashboard reads, at most every 15 minutes.
- Buttons are never public. Forms and row edits stay off unless the publisher turns them on, and live tables are off by default.

Creating, extending and revealing a link happen in the console or the API. An AI client can only list, refresh and revoke one.

## What do shared tables and dashboards cost on Black?

Collections and dashboards come with Black. Black lists at $24 per user per month, or $18 per user per month billed yearly ($216 a year). These are US-dollar list prices; see [the pricing page](/pricing/) for yours. Gold, at $15 per user per month in USD, or $10 per user per month billed annually, does not include them.

Usage bills on top of seats, past a monthly allowance pooled across the organization:

| Meter | Free each month | Past the allowance |
|---|---|---|
| Run time | 1,000 run minutes | $0.02 a run minute |
| Collection storage | 1 GB-month | $5 a GB-month |

Storage is sampled once a day (UTC) as the stored size of every row, summed across a collection's tables. Run time counts only working time. Waiting on a person or a timer is free, and test runs cost nothing.

The 14-day free trial is Black itself, with no card to start. Every Black feature is on during it: workflows, collections, dashboards, knowledge bases and the Elaichi Agent. Its one limit is the free monthly usage, 1,000 run minutes and 1 GB, which is a hard stop until you buy Black. A trial that ends without a plan moves to the free Personal plan and deletes nothing. Start at [app.elaichi.ai/signup](https://app.elaichi.ai/signup) and build your first tracker.

## When you may not need collections and dashboards

If your team only asks questions of live apps, Gold may be enough. Claude or ChatGPT reads the CRM through Elaichi's connectors, with no table in between. A collection earns its place when the data must outlive the conversation. Examples are a weekly snapshot, or a tracker several people and workflows write to.

A spreadsheet fits a table one person updates by hand. A BI (business intelligence) tool fits years of warehouse history, since a collection caps at 1,000,000 rows and 1 GB.

For the wider plan, read [what comes with Elaichi Black](/blog/elaichi-black-plan/). The workflow side is covered in [building workflows in Elaichi](/blog/elaichi-workflows/), and documents agents search live in [Elaichi knowledge bases](/blog/elaichi-knowledge-bases/). To pick the apps that feed your tables, browse [the connector catalog](/connectors/).

## FAQ

### What is a collection in Elaichi?

A collection in Elaichi is a shared table, or a set of up to 20 tables. Each table has its own fields and rows, and one share covers them all. Fields take 12 types, from text and number to person, link and structured data. A collection holds up to 100 fields, 1,000,000 rows and 1 GB. It is shared at view, use or edit. Collections come with the Black plan.

### Does an Elaichi public dashboard link give visitors live access to my data?

No. An Elaichi public dashboard link shows a copy the publisher captured with their own access. A visitor never runs a data source. Public links are off until an admin turns them on for the organization. A link expires after 90 days by default, and a dashboard has at most five active links. The copy refreshes by hand, after a workflow run that writes the collection, or every 1, 6, 12 or 24 hours.

### Can I undo a bad write to an Elaichi collection?

Yes, if row history is on for that collection. It is off by default, and you turn it on in Table settings with "Keep a history of row changes". It keeps 1 to 365 days of changes, 90 by default, and up to 500 versions a row. Restoring a version writes a fresh version, so a restore can itself be undone. Restoring needs use access to the collection.

### How much does Elaichi collection storage cost?

Black includes 1 GB-month of collection storage a month, pooled across the organization. Past it, storage bills at $5 a GB-month in US dollars. Storage is sampled once a day (UTC) as the stored size of every row. Black lists at $24 per user per month in USD, or $18 billed yearly. The pricing page shows your own price.

## Read next

- [Connect Elaichi to Claude](/blog/connect-elaichi-to-claude/) — To connect Elaichi to Claude, add one URL as a custom connector and sign in with OAuth. On Team and Enterprise, an Owner adds it once for everyone.
- [Video: Connect Your First Work App to Elaichi](/blog/connect-your-first-work-app-to-elaichi/) — Watch how to connect your first work app to Elaichi: add a connection, sign in with OAuth 2.0, see it turn Active, and fix it if it will not connect.
- [Connect Elaichi to ChatGPT](/blog/connect-elaichi-to-chatgpt/) — To connect Elaichi to ChatGPT, a workspace admin adds one MCP endpoint as a custom app and each person signs in with OAuth. No API key, no per-user URL.