AI Resources

View as Markdown

Summary

AdapTable uses AI to help you create and manage applications faster, and to a higher standard
Four Agent Skills do that work — set up, develop, upgrade and debug — each from 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 follow the AdapTable version installed in your project

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

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

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

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

adaptable-setup — add AdapTable to an application
adaptable-dev — build and change AdapTable
adaptable-upgrade — move to a newer AdapTable
adaptable-debug — find out why a running Grid is wrong

Note

AdapTable does not provide an agent of its own
The Skills work with coding agents you already use, e.g. Cursor, Claude Code, VS Code with Copilot, OpenAI etc.

Once these Skills are installed, your agent sets up, changes, upgrades and debugs AdapTable for you, 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 an MCP Server (what those Skills call):

Resource	What it is
Agent Skills	Setup, development, upgrade and debug; install and then give your agent a command
MCP server	The tool the Skills call to ensure all works quickly and efficiently

Note

If the MCP Server is not installed, the Skill runs the CLI — the same package — and still does the work
You never need to call the MCP Server yourself

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 the installed version, read its docs, decide where the answer belongs, write it, check it

calls MCP when it is installed, otherwise the CLI

MCP, or the CLI

When MCP is installed, the Skill calls its tools. Otherwise the Skill runs the CLI. Either way it reads the docs for your version and checks State, Expressions and setup against what is installed. You do not call MCP yourself

Docs for your version

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

Your AdapTable package

The checks use the types and engine of the AdapTable in your project

The running Grid

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

Findings go back to the agent: it fixes them and checks again, up to three rounds, before you see the result

You get back

A diff, a diagnosis of the running Grid, or an upgrade plan — with the checks that ran and the 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

You ask your agent in plain English
The agent opens the Agent Skill for the job
The Skill uses the MCP server when it is installed, and the adaptable CLI when it is not, to read the docs for your version and to check what it wrote. You do not call MCP yourself
The CLI checks against the AdapTable package in your project, or the State of the running Grid; the agent fixes what it finds and checks again
You get a diff, a diagnosis or a plan to review

Get started

Developer Guide

Install the AdapTable AI resources

Installing AI in AdapTable is straightforward.

There are 3 steps in the project folder, then 1 question to confirm it worked.

Then do either step 4 or step 5.

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.

Skills: .agents/skills/ in the project
Session-start file: AGENTS.md, or a .cursor/rules/*.mdc rule
Without prompts: npx skills add https://www.adaptabletools.com -a cursor -y

Tell the agent they exist

Paste this block into the project once, and commit it.

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

Use AGENTS.md (Codex, Cursor, VS Code etc.), CLAUDE.md (Claude Code) or .cursor/rules/*.mdc file (Cursor):

<!-- 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.
<

This is what makes the agent reach for the Skills reliably, before it has opened any of them.

Check it worked

Ask your agent:

any AdapTable SkillAI Skill

Which AdapTable Skills do you have, and what AdapTable version is this project on?

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

Either: Install the MCP server

Install the MCP server so the Skills can call it.

Add it to the agent's configuration — .cursor/mcp.json in Cursor, or .mcp.json in Claude Code:

{
  "mcpServers": {
    "adaptable": {
      "command": "npx",
      "args": [
        "-y",
        "@adaptabletools/adaptable-mcp@^1",
        "mcp"
      ]
    }
  }
}

See MCP mode for VS Code, Codex and the other clients.

Or: Let the Skill use the CLI

If you have skippled the previous step, the Skill runs the CLI instead, and the work still gets done.

It runs the CLI through npx.

If npx is blocked or slow, pin the package in the project so the run starts instantly and the version stays fixed:

Terminal

npm i -D @adaptabletools/adaptable-mcp

See Install and run for the details.

Requirements

There are 2 main requirements:

Node 22.20 or later for the skills installer (the CLI itself needs Node 20 or later)
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:

Piece	Runs where	Talks to
Agent Skills	Files in your project, read by your agent	Nothing: they are written instructions
MCP if installed / `adaptable` CLI	Your machine	adaptabletools.com, to download the docs for your version; npm, to download itself and, only if needed, an AdapTable package
DevTools In-page API	The browser page your Grid runs in	The agent's browser tool on your machine

Why AdapTable AI is Safe and Cost-Effective

No new agent to buy, host or approve — developers keep the tools you already standardised on
Nothing is sent to AdapTable Tools: no telemetry, no account, no API key
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
Your agent's own data policy is unchanged; these tools add no destination for your code
Support-case and feedback files are written locally, scrubbed by default, and only a person sends them

Every network call is a download:

adaptabletools.com: docs for your AdapTable version, kept in cache after 1st time (plus Skills' version no)
npm: the CLI itself (and, if project has no AdapTable package to check, a copy of one)

Important

Nothing is uploaded when using the AdapTable AI tools
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, MCP Server and CLI cover AdapTable.

Column definitions, AG Grid modules, row models and the Grid API belong to AG Grid.

Hint

Install AG Grid's Skills (ag-dev, ag-update) and, if you use MCP, its MCP Server alongside
The AdapTable Skills hand AG Grid work over to them

Agents without a shell

Every page of these docs is also published as markdown:

https://www.adaptabletools.com/llms.txt lists every page
llms-full.txt holds them all in one file
/index.md after any page URL returns that page

The Skills tell an agent to read those pages rather than recall an older API.

Feedback

If a Skill misled the agent, a check missed something or missing docs page, ask agent for ADAPTABLE_FEEDBACK.md
Review it and send it through 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? Nothing. There is no account, no API key and no extra licence.

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? Install the Skills or nothing works, and install the MCP server as well. When it is configured, the Skill calls its tools, which is the easiest path. When it is not, the Skill runs the CLI and still finishes the job. You do not call MCP yourself.

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. The checks run with 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.

AdapTable Resources

NextAgent Skills