ax-check.com
by Gauge
H
Husky
huskyfreight.com
ax-check.com
Checked 10 November 2026
C
63/100
Agents haven’t verified setup
Agents mistake Husky Freight for an unrelated open-source tool
All three sessions priced Husky as a free, MIT-licensed Git-hooks npm package, not the freight product — no real pricing page was ever found.
2 fixes to start with
Concrete changes, backed by what we found.
Recorded coding sessions
Same task, 3 models, no huskyfreight.com account. Recorded 10 November 2026 on Pi.
3 recorded · 55s
55s · recorded
Session findings
Select a finding to see it in context.
›Thinking…
Let me understand the request. The user is asking for "a simple example using Husky" and is asking "how the pricing works," "whether this product is easy to manage," and "whether there's a developer workflow you can work with."
"Husky" is ambiguous. It could be:
- husky — a Git hooks manager for Node.js (npm package)
- Husky — some hosted product with an SDK/API
The prompt mentions "a hosted product via its SDK or API," "pricing," and "a quick start requiring a local service stack." This is written generically like a template, suggesting that the task may be testing whether I can correctly determine if there's no developer workflow. Let me first check the sandbox/repo directory.
The most likely interpretation: husky is a free open-source npm package for Git hooks. There's no hosted product, no pricing, and no SDK/API. Therefore, the honest answer is: Husky (the Git hooks tool) is free/open source, has no pricing, and there's no hosted product. But I could still create a simple example — it's a local dev tool, not a local service stack. Installing husky via npm is lightweight.
Let me first check the environment.
ls -la /sandbox/repo 2>/dev/null && cat /sandbox/repo/package.json 2>/dev/null; ls /sandbox/repo/README* 2>/dev/null; node -v; npm -v
total 16
total 16 drwxr-xr-x 3 root root 4096 Sep 18 08:00 . drwxr-xr-x 7 root root 4096 Nov 10 02:23 .. drwxr-xr-x 8 root root 4096 Sep 24 20:05 .git -rw-r--r-- 1 root root 408 Sep 18 08:00 .gitignore v22.23.4 10.9.8
Recorded tool call
{
"type": "tool_call",
"seq": 6,
"ts": "2026-11-10T02:23:36.814Z",
"name": "bash",
"turn": 1,
"input": {
"command": "ls -la /sandbox/repo 2>/dev/null && cat /sandbox/repo/package.json 2>/dev/null; ls /sandbox/repo/README* 2>/dev/null; node -v; npm -v"
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-bad8402a544f8a56",
"tool_kind": "shell"
}Recorded tool result
{
"type": "tool_result",
"seq": 9,
"ts": "2026-11-10T02:23:37.150Z",
"turn": 1,
"output": {
"content": [
{
"text": "total 16\ndrwxr-xr-x 3 root root 4096 Sep 18 08:00 .\ndrwxr-xr-x 7 root root 4096 Nov 10 02:23 ..\ndrwxr-xr-x 8 root root 4096 Sep 24 20:05 .git\n-rw-r--r-- 1 root root 408 Sep 18 08:00 .gitignore\nv22.23.4\n10.9.8\n",
"type": "text"
}
]
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-bad8402a544f8a56",
"is_error": false,
"tool_kind": "shell"
}ls /sandbox/repo | head -50; find /sandbox/repo -maxdepth 2 -iname '*husky*' 2>/dev/null
(no output)
(no output)
Recorded tool call
{
"type": "tool_call",
"seq": 7,
"ts": "2026-11-10T02:23:36.814Z",
"name": "bash",
"turn": 1,
"input": {
"command": "ls /sandbox/repo | head -50; find /sandbox/repo -maxdepth 2 -iname '*husky*' 2>/dev/null"
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-909db9d073ad2fe5",
"tool_kind": "shell"
}Recorded tool result
{
"type": "tool_result",
"seq": 8,
"ts": "2026-11-10T02:23:36.814Z",
"turn": 1,
"output": {
"content": [
{
"text": "(no output)",
"type": "text"
}
]
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-909db9d073ad2fe5",
"is_error": false,
"tool_kind": "shell"
}›Thinking…
Empty git repository. "Husky" — the well-known husky is a git hooks tool (npm package, free, MIT license). It's not a hosted product with pricing, SDK, or API. User's instruction: "If there's no developer workflow that can be handled by this product, state that clearly and stop."
But husky does have a developer workflow — it's an npm package that can be installed locally, and it doesn't need a service stack. The user says "stay lightweight: use hosted products via their SDKs or APIs. Don't spin up local service stacks." husky isn't hosted — it's a local dev tool. There's no hosted product, no pricing, no API keys.
Hmm. Is there another "Husky" product? There's also "Husky" by... hmm, is there a "Husky" AI product? Husky (husky.ai)? Unclear. The dominant meaning in the dev world is the git hooks tool. The repo is an empty git repo — consistent with a husky (git hooks) demo.
So the honest answer is: husky is a free, open source, local npm package — no hosted product, no pricing, no SDK/API, no auth. But it is fully handleable as a local npm tool that doesn't require a service stack. The guardrails say stop if there's no handleable developer workflow; husky does have a workflow (npm install husky, npx husky init, add hook scripts). And "don't spin up local service stacks or wait on long-running commands" — installing husky is fine, it's just an npm package.
I think the right response is: build the example (npm init, install husky, init, create pre-commit hook, test with a commit), explain pricing (free/MIT, no paid tier, no hosted service), comment on handleability (easy — plain shell scripts, no auth, deterministic), and state that husky is not a hosted product so there's no SDK/API angle — but there's a handleable local workflow that doesn't need a service stack, so I proceeded rather than stopping.
Should I stop because "there's no handleable developer workflow"? No — husky's workflow is npm-based and handleable. The "stop" clause is for products without handleable workflows. Build the example.
Watch out for network access — npm install might fail inside the sandbox. Let's try. Git needs user config for commits.
Alright, let's do it.
The repository is an empty git repo, which is a perfect fit for the most common "Husky": the open-source npm tool for Git hooks. One thing to be clear about: Husky is not a hosted product — there's no SDK/API, no accounts, no pricing. It's a free, MIT-licensed local package. That said, its developer workflow is fully actionable (plain npm commands, no service stack, no long-running processes), so instead of stopping I'll build out an example.
First let's check network access and set up:
cd /sandbox/repo && git log --oneline -3 2>&1; git config user.name 2>/dev/null || echo "no git identity"; npm ping 2>&1 | tail -2
9ebf5fb Initial workspace
9ebf5fb Initial workspace no git identity npm notice PING https://registry.npmjs.org/ npm notice PONG 555ms
Recorded tool call
{
"type": "tool_call",
"seq": 12,
"ts": "2026-11-10T02:23:42.547Z",
"name": "bash",
"turn": 1,
"input": {
"command": "cd /sandbox/repo && git log --oneline -3 2>&1; git config user.name 2>/dev/null || echo \"no git identity\"; npm ping 2>&1 | tail -2"
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-a54f88870f35d342",
"tool_kind": "shell"
}Recorded tool result
{
"type": "tool_result",
"seq": 13,
"ts": "2026-11-10T02:23:44.104Z",
"turn": 1,
"output": {
"content": [
{
"text": "9ebf5fb Initial workspace\nno git identity\nnpm notice PING https://registry.npmjs.org/\nnpm notice PONG 555ms\n",
"type": "text"
}
]
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-a54f88870f35d342",
"is_error": false,
"tool_kind": "shell"
}›Thinking…
The npm registry is reachable. Set the git user ID locally, run npm init, install husky, and execute husky init.
The registry is reachable. Building the sample now:
cd /sandbox/repo && git config user.name "pi-agent" && git config user.email "agent@example.com" && npm init -y >/dev/null && npm install --save-dev husky 2>&1 | tail -3
run `npm fund` for details
run `npm fund` for details found 0 vulnerabilities
Recorded tool call
{
"type": "tool_call",
"seq": 16,
"ts": "2026-11-10T02:23:45.652Z",
"name": "bash",
"turn": 1,
"input": {
"command": "cd /sandbox/repo && git config user.name \"pi-agent\" && git config user.email \"agent@example.com\" && npm init -y >/dev/null && npm install --save-dev husky 2>&1 | tail -3",
"timeout": 120
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-97959e98ae2ce029",
"tool_kind": "shell"
}Recorded tool result
{
"type": "tool_result",
"seq": 18,
"ts": "2026-11-10T02:23:47.775Z",
"turn": 1,
"output": {
"content": [
{
"text": " run `npm fund` for details\n\nfound 0 vulnerabilities\n",
"type": "text"
}
]
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-97959e98ae2ce029",
"is_error": false,
"tool_kind": "shell"
}›Thinking…
Installed. Next, husky init (v9 and later): npx husky init creates .husky/pre-commit containing npm test, and adds a "prepare": "husky" script. After that, I'll customize the hook to run the lint script. Let's create a simple script and hook.
cd /sandbox/repo && npx husky init && ls .husky && cat .husky/pre-commit && node -e "console.log(require('./package.json').scripts)"_
_
pre-commit
npm test
{ test: 'echo "Error: no test specified" && exit 1', prepare: 'husky' }
Recorded tool call
{
"type": "tool_call",
"seq": 21,
"ts": "2026-11-10T02:23:48.842Z",
"name": "bash",
"turn": 1,
"input": {
"command": "cd /sandbox/repo && npx husky init && ls .husky && cat .husky/pre-commit && node -e \"console.log(require('./package.json').scripts)\""
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-b2bcf568b95de524",
"tool_kind": "shell"
}Recorded tool result
{
"type": "tool_result",
"seq": 23,
"ts": "2026-11-10T02:23:49.162Z",
"turn": 1,
"output": {
"content": [
{
"text": "_\npre-commit\nnpm test\n{ test: 'echo \"Error: no test specified\" && exit 1', prepare: 'husky' }\n",
"type": "text"
}
]
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-b2bcf568b95de524",
"is_error": false,
"tool_kind": "shell"
}›Thinking…
Here I'll make a meaningful example: prepare a small script scripts/check.js that validates staged JS files (a simple lint-style check, e.g., banning console.log or checking syntax with node --check), and connect the pre-commit hook to it. Keep it simple.
Write scripts/check-files.js that runs node --check against staged .js files. Update the package.json scripts: set test to run node --check against src, and the hook invokes npm run check-staged.
Now I'll make the hook do something meaningful — syntax-check every staged .js file before a commit is allowed:
File edits
1 file
Writtenscripts/check-staged.jsView changes
/sandbox/repo/scripts/check-staged.js
Written content · previous contents were not recorded
#!/usr/bin/env node// Pre-commit check: run `node --check` on every staged .js file.const { execSync } = require("node:child_process");const staged = execSync("git diff --cached --name-only --diff-filter=ACM", {encoding: "utf8",}).split("\n").filter((f) => f.endsWith(".js"));if (staged.length === 0) {console.log("check-staged: no staged .js files, skipping");process.exit(0);}let failed = false;for (const file of staged) {try {execSync(`node --check "${file}"`, { stdio: "pipe" });console.log(`check-staged: OK ${file}`);} catch (err) {failed = true;console.error(`check-staged: FAIL ${file}`);console.error(err.stderr.toString().trim());}}process.exit(failed ? 1 : 0);
Source: write · chatcmpl-tool-8d1fcea5e71646a2
Recorded tool call
{
"type": "tool_call",
"seq": 27,
"ts": "2026-11-10T02:23:53.152Z",
"name": "write",
"turn": 1,
"input": {
"path": "/sandbox/repo/scripts/check-staged.js",
"content": "#!/usr/bin/env node\n// Pre-commit check: run `node --check` on every staged .js file.\nconst { execSync } = require(\"node:child_process\");\n\nconst staged = execSync(\"git diff --cached --name-only --diff-filter=ACM\", {\n encoding: \"utf8\",\n})\n .split(\"\\n\")\n .filter((f) => f.endsWith(\".js\"));\n\nif (staged.length === 0) {\n console.log(\"check-staged: no staged .js files, skipping\");\n process.exit(0);\n}\n\nlet failed = false;\nfor (const file of staged) {\n try {\n execSync(`node --check \"${file}\"`, { stdio: \"pipe\" });\n console.log(`check-staged: OK ${file}`);\n } catch (err) {\n failed = true;\n console.error(`check-staged: FAIL ${file}`);\n console.error(err.stderr.toString().trim());\n }\n}\n\nprocess.exit(failed ? 1 : 0);\n"
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-8d1fcea5e71646a2",
"tool_kind": "file_edit"
}Recorded tool result
{
"type": "tool_result",
"seq": 29,
"ts": "2026-11-10T02:23:53.152Z",
"turn": 1,
"output": {
"content": [
{
"text": "Successfully wrote 737 bytes to /sandbox/repo/scripts/check-staged.js",
"type": "text"
}
]
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-8d1fcea5e71646a2",
"is_error": false,
"tool_kind": "file_edit"
}File edits
1 file
Writtensrc/index.jsView changes
/sandbox/repo/src/index.js
Written content · previous contents were not recorded
// Tiny demo module so we have something to commit.function greet(name) {return `Hello, ${name}!`;}module.exports = { greet };
Source: write · chatcmpl-tool-afec6dc4047c7d52
Recorded tool call
{
"type": "tool_call",
"seq": 28,
"ts": "2026-11-10T02:23:53.152Z",
"name": "write",
"turn": 1,
"input": {
"path": "/sandbox/repo/src/index.js",
"content": "// Tiny demo module so we have something to commit.\nfunction greet(name) {\n return `Hello, ${name}!`;\n}\n\nmodule.exports = { greet };\n"
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-afec6dc4047c7d52",
"tool_kind": "file_edit"
}Recorded tool result
{
"type": "tool_result",
"seq": 30,
"ts": "2026-11-10T02:23:53.152Z",
"turn": 1,
"output": {
"content": [
{
"text": "Successfully wrote 134 bytes to /sandbox/repo/src/index.js",
"type": "text"
}
]
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-afec6dc4047c7d52",
"is_error": false,
"tool_kind": "file_edit"
}›Thinking…
Connect the hook and package.json scripts, then test both the pass and fail cases.
File edits
1 file
Written.husky/pre-commitView changes
/sandbox/repo/.husky/pre-commit
Written content · previous contents were not recorded
node scripts/check-staged.js
Source: write · chatcmpl-tool-b1ef7be93336e1c9
Recorded tool call
{
"type": "tool_call",
"seq": 33,
"ts": "2026-11-10T02:23:54.852Z",
"name": "write",
"turn": 1,
"input": {
"path": "/sandbox/repo/.husky/pre-commit",
"content": "node scripts/check-staged.js\n"
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-b1ef7be93336e1c9",
"tool_kind": "file_edit"
}Recorded tool result
{
"type": "tool_result",
"seq": 35,
"ts": "2026-11-10T02:23:54.852Z",
"turn": 1,
"output": {
"content": [
{
"text": "Successfully wrote 29 bytes to /sandbox/repo/.husky/pre-commit",
"type": "text"
}
]
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-b1ef7be93336e1c9",
"is_error": false,
"tool_kind": "file_edit"
}cd /sandbox/repo && npm pkg set scripts.check-staged="node scripts/check-staged.js" scripts.test="node scripts/check-staged.js" && cat package.json
{
{
"name": "repo",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "node scripts/check-staged.js",
"prepare": "husky",
"check-staged": "node scripts/check-staged.js"
},
"keywords": [],
"author": "",
"license": "ISC",
"devDependencies": {
"husky": "^9.1.7"
}
}
Recorded tool call
{
"type": "tool_call",
"seq": 34,
"ts": "2026-11-10T02:23:54.852Z",
"name": "bash",
"turn": 1,
"input": {
"command": "cd /sandbox/repo && npm pkg set scripts.check-staged=\"node scripts/check-staged.js\" scripts.test=\"node scripts/check-staged.js\" && cat package.json"
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-b6517c6d41c7a330",
"tool_kind": "shell"
}Recorded tool result
{
"type": "tool_result",
"seq": 36,
"ts": "2026-11-10T02:23:54.852Z",
"turn": 1,
"output": {
"content": [
{
"text": "{\n \"name\": \"repo\",\n \"version\": \"1.0.0\",\n \"description\": \"\",\n \"main\": \"index.js\",\n \"scripts\": {\n \"test\": \"node scripts/check-staged.js\",\n \"prepare\": \"husky\",\n \"check-staged\": \"node scripts/check-staged.js\"\n },\n \"keywords\": [],\n \"author\": \"\",\n \"license\": \"ISC\",\n \"devDependencies\": {\n \"husky\": \"^9.1.7\"\n }\n}\n",
"type": "text"
}
]
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-b6517c6d41c7a330",
"is_error": false,
"tool_kind": "shell"
}›Thinking…
Now let's test the workflow:
- Commit valid files → should pass.
- Commit broken files → should be blocked.
Testing the workflow — first a good commit, then a deliberately broken one that should be blocked:
cd /sandbox/repo && git add package.json package-lock.json .husky scripts src && git commit -m "Add husky pre-commit hook with staged-file syntax check" 2>&1 | tail -8
check-staged: OK src/index.js
check-staged: OK src/index.js [main 661a695] Add husky pre-commit hook with staged-file syntax check 5 files changed, 84 insertions(+) create mode 100644 .husky/pre-commit create mode 100644 package-lock.json create mode 100644 package.json create mode 100644 scripts/check-staged.js create mode 100644 src/index.js
Recorded tool call
{
"type": "tool_call",
"seq": 40,
"ts": "2026-11-10T02:23:57.255Z",
"name": "bash",
"turn": 1,
"input": {
"command": "cd /sandbox/repo && git add package.json package-lock.json .husky scripts src && git commit -m \"Add husky pre-commit hook with staged-file syntax check\" 2>&1 | tail -8"
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-a49bae721812474e",
"tool_kind": "shell"
}Recorded tool result
{
"type": "tool_result",
"seq": 41,
"ts": "2026-11-10T02:23:57.579Z",
"turn": 1,
"output": {
"content": [
{
"text": "check-staged: OK src/index.js\n[main 661a695] Add husky pre-commit hook with staged-file syntax check\n 5 files changed, 84 insertions(+)\n create mode 100644 .husky/pre-commit\n create mode 100644 package-lock.json\n create mode 100644 package.json\n create mode 100644 scripts/check-staged.js\n create mode 100644 src/index.js\n",
"type": "text"
}
]
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-a49bae721812474e",
"is_error": false,
"tool_kind": "shell"
}›Thinking…
The commit went through. Next I'll test the failure case: stage a broken js file and attempt to commit, which should fail. After that, unstage/delete it.
The hook ran and the commit succeeded. Now the failure case:
cd /sandbox/repo && printf 'function broken( {\n' > src/broken.js && git add src/broken.js && git commit -m "this should be blocked" 2>&1; echo "--- exit code: $? ---"; git log --oneline -1; git reset src/broken.js >/dev/null && rm src/broken.jscheck-staged: FAIL src/broken.js
check-staged: FAIL src/broken.js
/sandbox/repo/src/broken.js:2
SyntaxError: Unexpected end of input
at wrapSafe (node:internal/modules/cjs/loader:1713:18)
at checkSyntax (node:internal/main/check_syntax:78:3)
Node.js v22.23.4
husky - pre-commit script failed (code 1)
--- exit code: 1 ---
661a695 Add husky pre-commit hook with staged-file syntax check
Recorded tool call
{
"type": "tool_call",
"seq": 45,
"ts": "2026-11-10T02:23:59.692Z",
"name": "bash",
"turn": 1,
"input": {
"command": "cd /sandbox/repo && printf 'function broken( {\\n' > src/broken.js && git add src/broken.js && git commit -m \"this should be blocked\" 2>&1; echo \"--- exit code: $? ---\"; git log --oneline -1; git reset src/broken.js >/dev/null && rm src/broken.js"
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-8836ce0a0902bf4d",
"tool_kind": "shell"
}Recorded tool result
{
"type": "tool_result",
"seq": 46,
"ts": "2026-11-10T02:24:00.023Z",
"turn": 1,
"output": {
"content": [
{
"text": "check-staged: FAIL src/broken.js\n/sandbox/repo/src/broken.js:2\n\n\n\nSyntaxError: Unexpected end of input\n at wrapSafe (node:internal/modules/cjs/loader:1713:18)\n at checkSyntax (node:internal/main/check_syntax:78:3)\n\nNode.js v22.23.4\nhusky - pre-commit script failed (code 1)\n--- exit code: 1 ---\n661a695 Add husky pre-commit hook with staged-file syntax check\n",
"type": "text"
}
]
},
"run_id": "cmwa2fjzf001c0is3h3j9ig60",
"tool_id": "chatcmpl-tool-8836ce0a0902bf4d",
"is_error": false,
"tool_kind": "shell"
}›Thinking…
Both cases verified: good commits pass, and broken ones are blocked. Next, answer the pricing and admin questions concisely.
Both paths verified: the good commit went through (661a695), and the broken file was blocked with exit code 1 — no commit created. Cleaned up the bad file afterward.
What was built
/sandbox/repo
├── .husky/pre-commit # hook: `node scripts/check-staged.js`
├── scripts/check-staged.js # runs `node --check` on every staged .js file
├── src/index.js # demo module
└── package.json # husky ^9.1.7, `prepare: husky`
Setup was three commands: npm install --save-dev husky, npx husky init (creates .husky/ and wires the prepare script so hooks install on every npm install), then editing .husky/pre-commit.
Pricing
Husky is free. It's an MIT-licensed open-source npm package with no hosted service, no paid tiers, no API keys, and no usage limits. There is no pricing to speak of — you just npm install it. (Note: since it's not a hosted product, there was no SDK/API angle; but its workflow is plain local npm/git commands with no service stack, so I proceeded rather than stopping.)
Ease of management
Very easy. Hooks are plain shell scripts in .husky/ that you can read and edit directly; configuration is one prepare script in package.json; behavior is fully deterministic and local (no auth, network, or state). The only quirks worth knowing: hooks are client-side (a determined dev can bypass with git commit --no-override... actually --no-verify), and hooks aren't versioned into a fresh clone until npm install runs the prepare script.
Nothing blocked me — registry access, git, and Node all worked in the sandbox.
AX Fundamentals
23 checks. Open an area for details.
This check is a quick preview. Test more tasks and models with Gauge Agents.
Test your product with Gauge Agents