AdapTable AI Resources
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
- 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
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):
| Resource | What it is |
|---|---|
| Agent Skills | Setup, development, upgrade and debug; install and then give your agent a command |
| CLI and MCP server | One 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
Ask in plain English: add AdapTable, add a feature, explain a misbehaving Grid, plan an upgrade
The agent you already use opens the matching Skill, and still writes the code
The procedure: find installed version, read its docs and write and check the answer
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.
The docs export for the installed major, cached after the first download
Checks use types and engine of the AdapTable in your project
Read through DevTools In-page API with the agent's browser tool
A diff, diagnosis of running Grid, or upgrade plan — with the checks that ran and docs pages used
The docs export (no code or data is sent)
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.
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
This step is optional, but recommended.
Copy this block into AGENTS.md at the root of the repository, and commit it:
- If
AGENTS.mdalready exists, add the block to it - In a monorepo, use the repository root, not a package folder
- Claude Code reads
CLAUDE.mdinstead: put the block there, or add aCLAUDE.mdcontaining the line@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.
Add the package as a devDependency, at the repository root:
The Skills find this copy by themselves, so there is nothing else to configure.
- Commit
package.jsonand 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
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):
Restart the agent, then ask it which AdapTable tools it can see.
Note
- The config launches the
latestrelease, whichnpxlooks 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)
Ask your agent:
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-mcpas 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 runsnpx -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
| Criterion | A — Project CLI | B — npx | C — MCP server |
|---|---|---|---|
| Setup | npm i -D @adaptabletools/adaptable-mcp once per project | Nothing | One config entry per agent (user or project); starts once per session |
| Each call | About half a second; no network after install | About a second (a few seconds the first time); each call asks the registry | Fast and in-process after that one start |
| Version | Pinned in the lockfile; same for every developer and CI | Resolves @^1 via npx; Skills name the cache folder to delete if the copy is stale | Newest release each time the server starts; restart the agent after a release |
| Agent context | Nothing extra | Nothing extra | About 4,500 tokens of tool definitions in every chat, including chats that never touch AdapTable |
| Commands | All 20 | All 20 | 12 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.
| Criterion | Skills + CLI in the project | MCP server |
|---|---|---|
| Speed | About 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. |
| Cost | Nothing 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. |
| Version | Pinned in the lockfile; the same copy for the team and CI. | Newest release each time the server starts. Restart the agent after a release. |
| Commands | All 20. | 12 of the 20; the Skill still runs the rest as the CLI. |
| Setup | Once per project (npm i -D). | One config entry per agent — for your user, or in the project. |
| Team and CI | Shared through git. CI and pre-commit hooks run the same binary. | Typically your user. CI still needs the CLI. |
| Network / proxy | Works 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 when | A 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:
- 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 - Continue with the versions that are installed
| What | How the update runs |
|---|---|
| Skills | npx skills update -p -y (-g for Skills installed for your user) |
| CLI in the project | npm i -D @adaptabletools/adaptable-mcp@^1 |
CLI through npx | Delete the npx cache folder the Skill names when that copy is behind |
| MCP server | Restart the agent after the update, when the Skill says the server is behind |
AGENTS.md block | Mentioned 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 skillsand 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:
| 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 |
- 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.