A compiler for the interface your agent already has: the shell.

One envelope, and it does not vary by engine

--json is the default when stdout is not a TTY, so an agent gets structured output without asking. Success carries data plus meta.count and meta.truncated. Failure carries the error string and the exit code, and data too when the engine has a payload, such as an API error body or a desktop tree diff. --fields projects named fields and takes dotted paths like error.code or items.0.name. --limit caps a list at 50 by default. --rows unwraps a nested array and records the path in meta.rows while meta.extra keeps the siblings. --where k=v narrows a list before --fields and --limit run, --max-bytes N caps what data can carry, and --cache <s> answers a read-only verb from a stored response instead of calling the engine again; the section below has the detail. --each file runs a verb once per item in a file or stdin and answers with one envelope, meta.count and meta.failed covering the whole batch. ~/.declick/<name>/defaults.json supplies flags you would otherwise retype on every call, and a run that used one lists the keys in meta.defaults. Both --flag value and --flag=value parse, boolean flags never eat the next argument, and an unknown flag is exit 1, never ignored. The shape is identical across all ten engines and across declick's own commands.

{ok:true, data, meta:{count, truncated}}

{ok:false, error, exit}

$ declick run demo list-notes
{"ok":true,"data":[{"id":"n1","title":"A"},{"id":"n2","title":"B"}],"meta":{"count":2,"truncated":false,"rows":"notes","extra":{"total":2,"echo":{}},"governance":{"enabled":false,"decision":"skipped","reason":"read-only verb"}}}

Less lands in the context, and it is measured

--where k=v filters a list on the machine that has it, before --fields and --limit run. It is repeatable and comma-separable, takes dotted paths, and every condition has to hold: eight operators, k=v, k!=v, k~re (case-insensitive regex), k>n, k>=n, k<n, k<=n, and k=* for present and not null. meta.where reports {matched, of}, and meta.count is what matched.

data also carries a ceiling: 8192 bytes by default, moved for every call with DECLICK_MAX_BYTES or for one with --max-bytes N, and turned off with 0. Over the cap a list drops tail rows and keeps at least one, a string is sliced, and an object keeps every key with its biggest values replaced by <N bytes; add --fields or --limit>, so the shape needed to write a --fields survives the cut. meta.capped names the size with a hint, meta.truncated is true, and the exit code stays 0; the cap never touches --dry-run, --help or describe.

--cache <seconds> on a read-only verb answers from the response the wire already gave. The key is the adapter, the verb, its positional args and its own flags, not --fields or --limit, so the same call shaped four ways reads one stored entry. And now that every audit line carries bytes, declick audit --sum adds the run log up instead of listing it, one row per adapter and a total: 212 calls, 340.2 KB read through adapters, 3 failed.

declick daemon start keeps stdio MCP servers warm in a detached per-user process, so only the first declick run <mcp adapter> <verb> pays a server's startup. A run tries the daemon with a 300ms connect budget and falls back to spawning its own server when nothing answers, so nothing breaks when the daemon is not up; the endpoint is a per-user named pipe on Windows or a 0600 socket elsewhere, plus a token, and a served run carries meta.daemon: true.

$ node scripts/bench-tokens.mjs
adapter                             tools  raw init+tools/list   declick describe   ratio
nine stdio MCP servers, combined      258        236,818 bytes         58,309 bytes    4.1x

A miss names what exists

$ declick version --nope
{"ok":false,"error":"unknown flag --nope for version; did you mean --rows?; run: declick version --help","exit":1}

$ declick run petstore get-pet 7
{"ok":false,"error":"unknown verb get-pet; run: declick describe petstore; did you mean get-pet-by-id, add-pet?","exit":2,"meta":{"governance":{"enabled":true,"decision":"skipped","reason":"no mutating action"}}}

$ declick describe nosuchthing
{"ok":false,"error":"no adapter named nosuchthing; run: declick list","exit":2}

$ declick list --fields nope
{"ok":false,"error":"no field matched nope; available: name, engine, source, verbs, lastRun, lastError, auth","exit":1}

$ declick run petstore get-pet-by-id 7 --pretty
{"ok":false,"error":"unknown flag --pretty for get-pet-by-id; run: declick describe petstore --verb get-pet-by-id; did you mean --retry?","exit":1,"meta":{"governance":{"enabled":false,"decision":"skipped","reason":"no mutating action"}}}

The whole surface, under 500 tokens, or the build fails

declick describe prints every verb, its required args and its flags in one block small enough to hold in context. --full adds per-verb flags and a -> line with the compiled returns shape, read from the first 2xx response schema. --verb isolates one verb, --grep and --offset page a large adapter, and --json emits the same thing as data. The 2,000-character ceiling is enforced by declick lint at build time: compiling all of git produces 2,284 characters of describe, so the build fails and prints every verb you could narrow to. Add --verbs status,log,diff and the same tool builds at a size an agent can read.

$ declick describe petstore --verb add-pet --full
petstore (openapi)  source: https://petstore3.swagger.io/api/v3/openapi.json  base: https://petstore3.swagger.io/api/v3
run: petstore <verb> [args] [--flags]   or: declick run petstore <verb> ...
  add-pet  Add a new pet to the store. [mutating]
      --body  raw application/json body
      --id    e.g. 10
      --name (required)    e.g. doggie
      --category.id    e.g. 1
      --category.name    e.g. Dogs
      --photoUrls (required)
      --tags
      --status  pet status in the store  one of available|pending|sold
      -> {id, name, category, photoUrls, tags, status}
common: --json --fields --limit --dry-run --full --help   exit: 0 ok 1 err 2 missing 3 blocked 4 auth
request: --header --base-url --server --content-type --body-file --output --retry --timeout --curl --verbose
auth env: PETSTORE_PETSTORE_AUTH, PETSTORE_API_KEY

$ declick lint petstore
{"ok":true,"data":{"name":"petstore","errors":[],"verbs":19},"meta":{"count":1,"truncated":false}}

$ declick add cli:git --name gitx
{"ok":false,"error":"lint failed:\n  describe is 2284 chars; limit 2000 (about 500 tokens); narrow with: declick add <source> --verbs a,b or --tag t\n  verbs: clone, init, add, mv, restore, rm, bisect, diff, grep, log, show, status, backfill, branch, commit, merge, rebase, reset, switch, tag, fetch, pull, push","exit":1}

$ declick add cli:git --name gitx --verbs status,log,diff
$ declick describe gitx
gitx (cli)  source: cli:"C:\Program Files\Git\mingw64\bin\git.exe"  bin: C:\Program Files\Git\mingw64\bin\git.exe diff
run: gitx <verb> [args] [--flags]   or: declick run gitx <verb> ...
  diff [commit] [path]         Show changes between commits, commit and working tree, etc
  log [revision-range] [path]  Show commit logs
  status [pathspec]            Show the working tree status
common: --json --fields --limit --full --help   exit: 0 ok 1 err 2 missing 3 blocked 4 auth

Every write previews before it happens

$ declick run petstore add-pet --name Rex --dry-run
{"ok":true,"data":{"method":"POST","url":"https://petstore3.swagger.io/api/v3/pet","headers":{"accept":"application/json","content-type":"application/json","authorization":"Bearer <PETSTORE_PETSTORE_AUTH>"},"body":"{\"name\":\"Rex\"}"},"meta":{"count":1,"truncated":false,"governance":{"enabled":false,"decision":"dry-run","reason":"preview only, nothing sent"},"dryRun":true}}

Start with four engines. Six more are compiled in.

Most agents need four: openapi for a spec, mcp for a server the agent already has, sqlite for a database, and compose to name a chain of verbs the model would otherwise rediscover every session. Nothing outside declick runs for any of them. The six below cover a source the first four do not read: a GraphQL endpoint, a Postman or Insomnia export, a HAR capture, another tool's --help, a browser page, a Windows window. The last three drive something live, so they carry the flakiness of that thing; the first seven do not.

Every engine is compiled into declick, so there is no plugin to find and no service in the path. Four of them shell out to something you already have: web needs Chrome or Edge, desktop needs deskclaw, cli needs the target binary on PATH, and authoring needs the Claude Code CLI. compose shells out too, but only to declick itself: every step in a chain runs as its own guarded, audited command, not a third-party binary. The requirements section lists all of it. declick engines --source says which engine a source lands on, and why, before anything is written. A URL spec is fetched once at compile time and never again at run time.

$ declick engines --json
{"ok":true,"data":[{"name":"openapi","ready":true,"source":"spec.json | spec.yaml | https://.../openapi.json","note":"openapi 3 and swagger 2, json or yaml; a url spec is fetched once at compile time"},{"name":"desktop","ready":true,"source":"app:<window title>","note":"needs deskclaw; declick doctor checks it"},{"name":"mcp","ready":true,"source":"mcp:<command args> | mcp:https://host/mcp","note":"stdio servers spawn the command; http servers take a bearer from <NAME>_TOKEN"},{"name":"web","ready":true,"source":"web:https://<site> --recipes <dir>","note":"needs Chrome or Edge; one recipe json per verb, and errors carry candidates instead of screenshots"},{"name":"graphql","ready":true,"source":"graphql:https://.../graphql | schema.json | schema.graphql","note":"introspects the endpoint; bearer from <NAME>_TOKEN when it answers 401"},{"name":"postman","ready":true,"source":"collection.json | insomnia.json","note":"postman v2.1 collections and insomnia v4 exports; recorded secrets become env keys"},{"name":"har","ready":true,"source":"capture.har","note":"browser network capture; --host picks the API host when the capture has several"},{"name":"sqlite","ready":true,"source":"sqlite:<path> | data.db","note":"introspects tables and views into list, get, insert, update, delete and a parameterized query"},{"name":"cli","ready":true,"source":"cli:<binary> [fixed args]","note":"compiled from the tool own --help; the binary must be on PATH"},{"name":"compose","ready":true,"source":"compose:<chain.json>","note":"chains verbs from adapters already built into one verb; every step still runs as its own guarded, audited command"}],"meta":{"count":10,"truncated":false}}

$ declick engines --source app:Calculator
engine=desktop  ready=true  why=app:Calculator routes to the desktop engine  next=declick add app:Calculator --name <name>

If your agent already has MCP servers or a screenshot loop

An MCP server's tool list rides in every prompt. Compile it with declick and the agent reads describe once, under 500 tokens, then calls verbs from a shell it already has; a nested payload comes back as rows with meta.rows naming what was unwrapped. A screenshot agent puts an image in the context window for every step. declick web tree returns the page as elements, interactive ones first, and the desktop engine replays element paths against a fresh window tree. declick web text <url> --grep re returns the page's own text filtered by a regex, for the times an agent needs the words on the page rather than its elements. The example.com tree below is 330 bytes and contains no image. A hand-written wrapper is a parser you maintain per tool. declick writes the parser, the launcher, and the SKILL.md, and lint fails the build when the surface grows past what an agent can hold.

Read the MCP vs CLI measurementHow the SKILL.md is generatedAll guides

$ declick describe demo
demo (mcp)  source: mcp:node fixtures/mcp-server.mjs  server: node fixtures/mcp-server.mjs
run: demo <verb> [args] [--flags]   or: declick run demo <verb> ...
  list-notes        List notes, newest first.
  add-note <title>  Add a note to the book [mutating]
  boom              Always reports a tool error [mutating]
common: --json --fields --limit --rows --dry-run --full --help   exit: 0 ok 1 err 2 missing 3 blocked 4 auth

$ declick web tree https://example.com --limit 6
{"ok":true,"data":[{"role":"link","name":"Learn more","id":null,"href":"https://iana.org/domains/example","value":null,"interactive":true},{"role":"heading","name":"Example Domain","id":null,"href":null,"value":null,"interactive":false}],"meta":{"count":2,"truncated":false,"url":"https://example.com/","title":"Example Domain"}}

One command wires your agent. One command unwires it.

$ declick setup --dry-run
$ declick setup
$ declick setup --revert
$ declick uninstall --yes

Windows apps replay as element paths, not pixels

$ declick add app:Calculator --name calculator --recipes fixtures/calculator
$ declick describe calculator
calculator (desktop)  source: app:Calculator  window: "Calculator"
run: calculator <verb> [args] [--flags]   or: declick run calculator <verb> ...
  add <a> <b>  Add two digits and read the display [mutating]
common: --json --fields --limit --dry-run --help   exit: 0 ok 1 err 2 missing 3 blocked 4 auth

$ declick run calculator add Seven Seven --dry-run
{"ok":true,"data":{"steps":[{"window":"Calculator"},{"would":"wait-for","find":["Text:Display is *"],"timeout":5000},{"found":["Group:Number pad","Button:Seven"],"ref":"@e64"},{"would":"click","ref":"@e64","name":"Seven"},{"found":["Group:Standard operators","Button:Plus"],"ref":"@e53"},{"would":"click","ref":"@e53","name":"Plus"},{"found":["Group:Number pad","Button:Seven"],"ref":"@e64"},{"would":"click","ref":"@e64","name":"Seven"},{"found":["Group:Standard operators","Button:Equals"],"ref":"@e54"},{"would":"click","ref":"@e54","name":"Equals"},{"found":["Text:Display is *"],"ref":"@e10"},{"read":"result","prop":"name"}]},"meta":{"count":1,"truncated":false,"governance":{"enabled":false,"decision":"dry-run","reason":"preview only, nothing sent"},"dryRun":true}}

$ declick desk status
{"ok":true,"data":{"path":"~/.claude/tools/deskclaw/desk","exists":true,"armed":false,"expires":null,"stop":false},"meta":{"count":1,"truncated":false}}

$ declick audit --limit 1
2026-09-03T03:59:50.435Z	calculator add	exit 3	skipped	954ms

{"ok":false,"error":"element not found: Group:Standard operators > Button:Plus Sign in \"Calculator\"; run: declick repair calculator add","exit":2,"data":{"missing":[...],"added":[...],"unresolved":[...]}}

$ declick add app:Calculator --name calculator --goal "multiply two numbers and return the display" --verb multiply

window, launch, find, wait-for, read-all, read, wait-for-text, assert, click, type, key, scroll, expand, collapse, select, context, set, clipboard, dismiss, wait; any step can carry optional: true

Refusals are compiled in. The guard is a tier you turn on.

Tier one, with the guard key unset

$ PETSTORE_API_KEY=... DECLICK_PETSTORE_BASE_URL=https://api.attacker.example declick run petstore get-pet-by-id 7
{"ok":false,"error":"PETSTORE_API_KEY is scoped to https://petstore3.swagger.io but this request goes to https://api.attacker.example; rebuild the adapter for https://api.attacker.example or set DECLICK_ENV_ALLOW=PETSTORE_API_KEY","exit":4,"meta":{"governance":{"enabled":false,"decision":"skipped","reason":"read-only verb"}}}

$ PETSTORE_API_KEY=... declick run petstore get-pet-by-id 7 --curl --fields meta.curl,meta.credentials
"curl":"curl -X GET -H 'accept: application/json' -H 'api_key: <PETSTORE_API_KEY>' 'https://petstore3.swagger.io/api/v3/pet/7'"
"credentials":[{"name":"PETSTORE_API_KEY","from":"env"}]

$ declick add app:Calculator --name calc --recipes fixtures/calculator
{"ok":false,"error":"calc already resolves to C:\\Windows\\System32\\calc.exe; pick another --name or pass --force","exit":1}

Tier two, opt in

The guard is DashClaw, the approval and policy layer for unattended agents from the same author: it intercepts a risky action before it runs and blocks it, or asks a person to approve it from anywhere. With no DASHCLAW_API_KEY set, a mutating call proceeds with nothing on stderr, and the envelope records governance.enabled false with the reason no guard configured. A local ~/.declick/policy.json decides first, with or without a key: allow, warn or block by adapter and verb, first matching rule wins, no network involved. Set the key and DASHCLAW_URL and every real mutating call posts {action_type, agent_id, agent_name, declared_goal, risk_score, target, systems_touched, tool: {name, engine, method, args}} to your guard first, the key in x-api-key, and the decision lands as an action record on your dashboard, secret-shaped args replaced by <redacted> and everything else truncated at 64 characters, with a 3 second timeout. From then on strict is the default: a guard that is unreachable, times out, or answers anything but a decision is exit 3. DECLICK_GUARD=open restores warn-and-proceed on a guard failure; a block or require_approval the guard actually returns is refused either way. Every invocation appends one line to ~/.declick/audit.jsonl, declick audit reads it newest first, and DECLICK_AUDIT=off turns the log off. That switch is worth knowing about if you are the one who has to prove it was on.

$ declick run demo add-note --title hello --count 1
{"ok":true,"data":{"id":"n3","echo":{"title":"hello","count":1}},"meta":{"count":1,"truncated":false,"governance":{"enabled":false,"decision":"skipped","reason":"no guard configured"}}}

$ DASHCLAW_API_KEY=test-key DASHCLAW_URL=http://127.0.0.1:9 declick run demo add-note --title hello --count 1
{"ok":false,"error":"blocked by governance: governance unreachable (fetch failed) (strict; set DECLICK_GUARD=open to proceed ungoverned)","exit":3,"meta":{"governance":{"enabled":true,"decision":"block","reason":"governance unreachable (fetch failed) (strict; set DECLICK_GUARD=open to proceed ungoverned)"}}}

$ declick audit --limit 3
2026-09-03T03:59:27.835Z	demo list-notes	ok	skipped	42ms
2026-09-03T03:59:27.660Z	demo add-note	exit 3	block	16ms
2026-09-03T03:59:27.509Z	demo add-note	ok	skipped	45ms

Read the control matrix

Any agent with a shell, not only Claude Code

import { execFile } from 'node:child_process';
import { fileURLToPath } from 'node:url';
import { promisify } from 'node:util';
const bin = fileURLToPath(import.meta.resolve('declick/bin/declick.mjs'));

// The one tool an SDK agent needs. The envelope is the result, on success and on failure.
export async function declick(adapter, verb, args = []) {
  const r = await promisify(execFile)(process.execPath, [bin, 'run', adapter, verb, ...args, '--json']).catch(e => e);
  return JSON.parse(r.stdout);
}

declick honors the contract it compiles

All 35 commands take --json and return the same envelope. declick commands prints the table as data: every command with its positionals, its flags, whether it mutates, whether it previews, and runnable examples. The shipped declick skill is rendered from that same table, so what an agent reads cannot drift from what the binary does. An agent with only a shell can compile, inspect, run, repair and audit. declick ui serves one page on 127.0.0.1 with the same buttons, for the parts a human should decide.

{
  "name": "add",
  "summary": "compile a source into an adapter: manifest, launcher, SKILL.md",
  "positionals": [{ "name": "source", "required": true }],
  "mutating": true,
  "dryRun": true,
  "examples": [
    "declick add fixtures/petstore.json --name petstore --verbs get-pet-by-id,add-pet",
    "declick add https://api.example.com/openapi.json",
    "declick add app:Calculator --name calc --goal \"add two numbers\" --verb add"
  ],
  "usage": "declick add <source> [--name n] [--verbs a,b] [--tag t] [--engine e] [--goal \"...\"] [--verb v] [--recipes dir|file|-] [--host api.example.com] [--url https://.../graphql] [--force]"
}

$ declick describe declick
declick 0.6.2: turn anything into a CLI so your agents stop clicking

What it needs, and what 0.6.2 does not do

Node 24 or newer; declick doctor checks it and keeps blocking problems separate from warnings. The desktop engine is Windows only and needs deskclaw 0.3.0 or newer on PATH; there is no macOS or Linux desktop backend. The web engine needs Chrome or Edge installed. The cli engine needs the target binary on PATH. Authoring or repair needs the Claude Code CLI on PATH for one bounded sonnet session, default timeout 300,000 ms. mcp and graphql against a private server read a bearer from <NAME>_TOKEN. declick ui listens on 127.0.0.1 only. Not shipped in 0.6.2: a macOS or Linux desktop backend.

$ declick doctor --fields node,blocking
{"ok":true,"data":{"node":{"version":"24.15.0","ok":true,"need":">=24"},"blocking":[]},"meta":{"count":1,"truncated":false}}

Free for individuals and small teams. Larger teams buy seats.

The 0.3.0 release on npm is MIT and stays that way. Releases after it are source-available under the Elastic License 2.0: read it, run it, change it, ship it inside your own product. Do not offer it to others as a managed service.

Free. Individuals, and companies with fewer than ten people. Everything included, no key, no sign-up.

Team, $19 per developer per month, or $190 per year. Commercial use at a company of ten people or more. Self-serve, no call.

Production support, $2,000 per year per company. A named contact, a two business day response, a private issue tracker. This is the tier a platform team buys once declick is in a pipeline.

Buy seats, monthlyBuy seats, yearlyBuy production support

Checkout is Stripe. Pick the seat count on the checkout page; the license arrives by email within a minute of paying, names the seats or the support tier it covers, and is your proof of purchase. Receipts and invoices come from Stripe. Anything bigger, or an invoice instead of a card: email for terms, not a sales call.

Four commands to a working adapter

$ npm i -g declick
$ declick setup
$ declick add https://petstore3.swagger.io/api/v3/openapi.json --name petstore
$ declick describe petstore
petstore (openapi)  source: https://petstore3.swagger.io/api/v3/openapi.json  base: https://petstore3.swagger.io/api/v3
run: petstore <verb> [args] [--flags]   or: declick run petstore <verb> ...
  update-pet                    Update an existing pet. [mutating]
  add-pet                       Add a new pet to the store. [mutating]

$ petstore get-user-by-name user1 --fields username,email
{"ok":true,"data":{"username":"user1","email":"email1@test.com"},"meta":{"count":1,"truncated":false,"status":200,"governance":{"enabled":false,"decision":"skipped","reason":"read-only verb"}}}
$ petstore get-pet-by-id 7
error: set PETSTORE_API_KEY or PETSTORE_PETSTORE_AUTH in the environment or ~/.creds/vault.env (or run: creds mint petstore)

Install declick and compile a spec