AdapTable AI Resources

View as Markdown

Summary

  • AdapTable uses AI to help you create and manage applications faster, and to a higher standard
  • 4 Agent Skills are offered — set up, develop, upgrade, debug — each accessed by a single command to your agent
  • AdapTable does not supply an agent - the skills work with the agent you already use
  • They work as soon as they are installed, and they drastically cut the time that work takes
  • The Skills use the AdapTable version installed in your project

AdapTable (since v24) provides a powerful set of AI Resources.

These allow you to create, develop, debug and upgrade your applications faster and better than ever before.

The main element is a set of four Agent Skills which cover the essential work done by a developer:

Note

You give your agent one command, and the Skill carries it out

Important

  • AdapTable does not provide an agent of its own
  • There is no new agent to buy, host or approve
  • Skills work with coding agents you already use, e.g. Cursor, Claude Code, VS Code with Copilot, OpenAI Codex etc.

Once these Skills are installed, your agent sets up, changes, upgrades and debugs AdapTable for you.

And it does all this in far less time than doing that work by hand.

Hint

The Skills follow the AdapTable version installed in the project, so the agent works with the release you are on

What we provide

AdapTable provides 2 AI resources: Skills (what your agent follows) and a CLI (what those Skills run):

ResourceWhat it is
Agent SkillsSetup, development, upgrade and debug; install and then give your agent a command
CLI and MCP serverOne package the Skills run to read the docs for your version and check State, Expressions and setup; the same package is the MCP server

How it works

Your machine — your code, State, data and keys stay here

You

Ask in plain English: add AdapTable, add a feature, explain a misbehaving Grid, plan an upgrade

Your coding agent

The agent you already use opens the matching Skill, and still writes the code

Agent Skill

The procedure: find installed version, read its docs and write and check the answer

runs the CLI, or calls the MCP server when one is configured
The CLI, or MCP

The Skill runs the CLI installed in the project (or through npx), or calls the MCP server when one is configured.
Either way it reads the docs, and checks State, Expressions and setup against what is installed.
You do not call either yourself.

Docs for your version

The docs export for the installed major, cached after the first download

Your AdapTable package

Checks use types and engine of the AdapTable in your project

The running Grid

Read through DevTools In-page API with the agent's browser tool

Findings go back to agent: it fixes them and checks again, up to 3 times, before you see result
You get back

A diff, diagnosis of running Grid, or upgrade plan — with the checks that ran and docs pages used

downloads the docs for your version
adaptabletools.com

The docs export (no code or data is sent)

only if needed: an AdapTable package
npm registry

When the project has no AdapTable 24+ package to check with

Getting started

Developer Guide

Install the AdapTable AI resources

Installing AI in AdapTable is straightforward.

Install the Skills and the CLI (steps 1 and 3).

Telling the agent they exist (step 2) is optional but recommended.

The MCP server (step 4) is optional — see CLI or MCP if you are unsure.

Then ask one question to confirm it worked.

1
Install the Skills

Terminal
npx skills add https://www.adaptabletools.com

The four Skills are installed into the folder your agent reads.

Commit them so the whole team has them.

These tools need Node 22.20 or later.

  • Skills: .agents/skills/ in the project
  • Session-start file: AGENTS.md
  • Without prompts: npx skills add https://www.adaptabletools.com -a cursor -y
2
Repeat the routing each turn (optional, recommended)

This step is optional, but recommended.

Copy this block into AGENTS.md at the root of the repository, and commit it:

  • If AGENTS.md already exists, add the block to it
  • In a monorepo, use the repository root, not a package folder
  • Claude Code reads CLAUDE.md instead: put the block there, or add a CLAUDE.md containing the line @AGENTS.md
AGENTS.md
<!-- BEGIN:adaptable-agent-rules -->
AdapTable (`@adaptabletools/*`) is used in this project. Its Options, State shapes, API and AdapTableQL change between majors, so do not rely on recalled knowledge. Before writing or changing AdapTable code use the `adaptable-dev` skill; for first-time integration `adaptable-setup`; for a misbehaving running grid `adaptable-debug`; for version upgrades `adaptable-upgrade`. Validate State, expressions and setup with `npx -y @adaptabletools/adaptable-mcp@^1 check …` (or the `check_*` MCP tools when configured); read the docs for the installed version with `npx -y @adaptabletools/adaptable-mcp@^1 docs search "<topic>"`. The columnDefs, gridOptions and AG Grid modules of an AdapTable grid are covered by these skills too; consult the `ag-dev` / `ag-update` skills or AG Grid's documentation only for what the AdapTable docs and checks do not cover.
<!-- END:adaptable-agent-rules -->

The agent reads that file at the start of each session, so you do not paste it again.

Skills are already selected from their descriptions.

The block repeats that routing on every turn, which can make the choice more reliable.

If the block is missing or out of date, the Skill tells you at the end of its task.

3
Install the CLI in the project

Add the package as a devDependency, at the repository root:

Terminal
npm i -D @adaptabletools/adaptable-mcp

The Skills find this copy by themselves, so there is nothing else to configure.

  • Commit package.json and the lockfile: the whole team and CI then run the same version
  • Dependabot or Renovate keep it up to date, like any other dependency
  • In a monorepo, install it at the root, where the agent runs

Hint

If you skip this step, the Skill runs the CLI through npx and still does the work — see How Skills run the tools

4
Install the MCP server (optional)

This step is optional.

The recommended setup is the Skills plus the CLI in the project (steps 1 and 3).

Adding the MCP server is still a valid choice: some projects already expect it, some agents prefer MCP tools over a shell, and it suits work across many folders or before there is a project.

See CLI or MCP for the full comparison — speed, cost and the other trade-offs — then decide.

Add the server once for your user, so its available in every folder (or in the project, if that is what it already uses):

Click the button to add it, or add the config to ~/.cursor/mcp.json:

Add AdapTable MCP Server to Cursor
{
  "mcpServers": {
    "adaptable": {
      "command": "npx",
      "args": [
        "-y",
        "@adaptabletools/adaptable-mcp@latest",
        "mcp"
      ]
    }
  }
}

Restart the agent, then ask it which AdapTable tools it can see.

Note

  • The config launches the latest release, which npx looks up each time the server starts
  • Restart the agent after a release to pick it up (the Skills tell you when the server is behind)
5
Check it worked

Ask your agent:

any AdapTable SkillAI Skill

Which AdapTable Skills do you have, what AdapTable version is this project on, and which version of the CLI or MCP server is running?

It should name the four Skills, the AdapTable version from your package.json, and one tooling version.

The CLI and the MCP server are the same package, so that is a single version.

  • If you installed the CLI in the project, that version is the local CLI
  • If you configured the MCP server, that version is the one the server is running, and it should see those tools

How the Skills run the tools

The Skills run the same @adaptabletools/adaptable-mcp package in one of three ways:

  • A — CLI installed in the project (recommended) — add @adaptabletools/adaptable-mcp as a devDependency once; the Skill runs the local binary. Default for a repo the team and CI share.
  • B — CLI via npx — no install; the Skill runs npx -y @adaptabletools/adaptable-mcp@^1 …. Used when the package is not in the project yet or as a fallback.
  • C — MCP server (optional) — the agent calls in-process tools that wrap the same package. Fits many folders, work before a project exists, MCP-first workflows, or agents with no shell.

Note

  • A and B are the CLI — use one of them
  • C is the MCP server, which you can use instead or as well
  • Checks and docs lookups return the same results from each
CriterionA — Project CLIB — npxC — MCP server
Setupnpm i -D @adaptabletools/adaptable-mcp once per projectNothingOne config entry per agent (user or project); starts once per session
Each callAbout half a second; no network after installAbout a second (a few seconds the first time); each call asks the registryFast and in-process after that one start
VersionPinned in the lockfile; same for every developer and CIResolves @^1 via npx; Skills name the cache folder to delete if the copy is staleNewest release each time the server starts; restart the agent after a release
Agent contextNothing extraNothing extraAbout 4,500 tokens of tool definitions in every chat, including chats that never touch AdapTable
CommandsAll 20All 2012 of 20 as MCP tools; the Skill runs the rest via the CLI

Note

  • A works offline from cache and behind a proxy that blocks the npm registry
  • B needs the registry on each call unless A is already installed

CLI or MCP

The recommendation is Skills + the CLI installed in the project.

That is the fastest everyday setup, the cheapest in agent tokens, and the same copy the whole team and CI run.

Note

  • Installing the MCP server as well — or instead, for your own machine — is still a valid option
  • Some project configurations already expect an MCP server; some agents prefer calling tools in-process
  • It is also a good fit when you work across many folders or before there is a project

During a chat, the Skills call whichever is available - you never need both.

From a terminal, a pre-commit hook or CI, you run the MCP package as the CLI.

The checks and docs lookups return the same results either way.

CriterionSkills + CLI in the projectMCP server
SpeedAbout half a second per call, no network after install. Fastest for a typical Skill task (a few calls).One start per session, then in-process. Comparable or faster when the same session makes many calls.
CostNothing extra in the chat context. More cost-effective over time, especially in chats that are not about AdapTable.About 4,500 tokens of tool definitions in every chat that agent opens — including chats that never touch AdapTable.
VersionPinned in the lockfile; the same copy for the team and CI.Newest release each time the server starts. Restart the agent after a release.
CommandsAll 20.12 of the 20; the Skill still runs the rest as the CLI.
SetupOnce per project (npm i -D).One config entry per agent — for your user, or in the project.
Team and CIShared through git. CI and pre-commit hooks run the same binary.Typically your user. CI still needs the CLI.
Network / proxyWorks offline from cache, and behind a proxy that blocks the npm registry.The config uses npx to start, so the first start needs the registry (unless you point it at the project's copy).
Best whenA project the team shares.Many folders, no project yet, an agent with no shell, or a project / organisation that already standardises on MCP.

We recommend Skills + the local CLI for most projects.

Note

  • Install the MCP server if your project already has an MCP config or your organisation standardises on MCP
  • Also if you prefer in-process tools — that is a supported setup, not a workaround

Hint

  • You can have both if you wish
  • When an MCP server is configured, the Skill calls its tools; commands the server does not expose still run as the CLI

Keeping the tools up to date

The Skills and the CLI are released together, under one version number.

Every Skill starts by running detect, which compares the installed Skills, the CLI and the AGENTS.md block with the latest release.

When the Skills or the CLI are behind that release, the Skill stops before any other work and asks you to choose:

  1. Update the Skills and the project's @adaptabletools/adaptable-mcp (recommended). The agent runs the update, then stops. Start a new session and repeat the request, so it follows the version it just installed
  2. Continue with the versions that are installed
WhatHow the update runs
Skillsnpx skills update -p -y (-g for Skills installed for your user)
CLI in the projectnpm i -D @adaptabletools/adaptable-mcp@^1
CLI through npxDelete the npx cache folder the Skill names when that copy is behind
MCP serverRestart the agent after the update, when the Skill says the server is behind
AGENTS.md blockMentioned at the end of the task. The Skill does not stop for it. Replace the text between its markers with the current block

Important

  • If the Skills and the CLI are on different major versions, the Skill stops and tells you which one to update. There is no option to continue
  • Instructions written for another major version are worse than none

Requirements

There are 2 main requirements:

  • Node 22.20 or later (npx skills and the CLI)
  • An agent that reads Agent Skills, e.g. Cursor, Claude Code, VS Code (GitHub Copilot), OpenAI Codex etc.

Stays on your machine

Nothing here is a cloud service.

All the pieces are files in your project and a tool that runs on your computer:

PieceRuns whereTalks to
Agent SkillsFiles in your project, read by your agentNothing: they are written instructions
MCP if installed / adaptable CLIYour machineadaptabletools.com to download the docs for your version
npm to download itself and (only if needed) an AdapTable package
DevTools In-page APIThe browser page your Grid runs inThe agent's browser tool on your machine
  • Nothing is added to the application: the Skills and the CLI are development tools only
  • Licence keys go into environment variables, never into source code, and the Skills never repeat a key back
  • Support-case and feedback files are written locally, scrubbed by default, and only a person sends them

Important

  • Nothing is sent to AdapTable Tools: no telemetry, no account, no API key. Every network call is a download
  • Your source code, Initial State, row data, licence keys and prompts never leave the machine

Find Out More

See Offline and restricted networks for the cache folder, proxies and working with no network

AG Grid Skills

The AdapTable Skills stay in charge of the grid.

When a task is specific to AG Grid and the AdapTable docs do not cover it, the Skill delegates that part, then checks the result itself.

Hint

  • Installing AG Grid's Skills (ag-dev, ag-update) is optional, and it helps
  • AdapTable Skills use them for delegated work if they're installed, and read AG Grid's documentation if they are not
  • You do not need AG Grid's MCP server

Feedback

  • If a Skill misled the agent, a check missed something, or a docs page is missing, open a support ticket
  • That is how we decide what the Skills and the CLI do next

FAQ

Does any of this send my code anywhere? No. Every network call is a download — docs from adaptabletools.com, packages from npm — and nothing is uploaded. See Stays on your machine.

Does it work offline? Yes, once the docs for your version have been downloaded: the CLI works from its cache, and can be prepared ahead of time for a machine with no network. See Offline and restricted networks.

What does it cost? The AdapTable tools themselves cost nothing: no account, no API key and no extra licence. The MCP server adds about 4,500 tokens of tool definitions to every chat in that agent, which your agent bills or counts; Skills + the local CLI add nothing extra. See CLI or MCP.

Which agents does it work with? Any agent that reads Agent Skills: Cursor, Claude Code, VS Code (GitHub Copilot), OpenAI Codex and most others.

Do I need the MCP server? No. The recommended setup is the Skills plus the CLI in the project. The MCP server is optional and still a valid choice — when you work across many folders, before there is a project, or when the project already expects MCP. See CLI or MCP.

Should I install the CLI globally? No. A global copy is used only after npx has asked the npm registry for the newest release, on every call, and nothing records which version each developer has. Install it in the project, or use the MCP server.

How do I know the tools are up to date? The Skills check on every task and tell you the command to run. See Keeping the tools up to date.

Do I need all four Skills? The install adds all four, and each is used only for its own job. adaptable-dev is the one you will use most.

Does it work with AdapTable 21, 22 or 23? Yes. The docs are read for your version, and adaptable-upgrade plans upgrades from 21 or later. check state and check setup use that version's types. AdapTableQL inside check state runs on version 24 and later. Migrating State or an Expression, and check expression, use an AdapTable 24 or later engine, which the CLI downloads when the project does not have one.

Can I run the checks without an agent? Yes — in a terminal, a pre-commit hook or CI. See adaptable CLI.

Does it work in a monorepo? Yes. The tools find every AdapTable project and work in the one the task is about. See Install and run.

Does the MCP server have prompts or resources? No — tools only. The workflows live in the Skills, so they work in every agent, with or without MCP.