8 free AI agent tools I use in 2026

Eight, all browser-based, none of them asking for a signup: agent-skill-validator, skill-scope-collision-detector, skill-payload-budget-optimizer, trace-failure-classifier, tool-approval-matrix-compiler, skill-spec-converter, skill-regression-suite-builder, and skill-release-canary-planner. Between them they cover the unglamorous work of shipping agent skills: checking manifests, catching overlapping triggers, trimming startup context, reading failure traces. Comparison table with dealbreakers is further down.

Being upfront: the tools I link to below are ones I built. I tried six existing skill linters in January 2026 and every one of them wanted my repo uploaded to somebody's server before it would tell me a frontmatter field was missing. Mine run client-side, cost nothing, and don't ask for an account or an email address. If you know something better, tell me and I'll happily switch.

Why agent skills got messy in 2026

In February I took over a repo with 23 skill definitions in it. Nobody had touched the docs since October. My first bug report was a support agent that kept picking the wrong skill for anything containing the word "invoice", because two separate skills claimed that word in their trigger text and the model just guessed.

Finding that took me 47 minutes. Fixing it took four seconds.

That ratio is the whole problem. Agent skills are markdown files with frontmatter. There's no compiler. Nothing type-checks them. You discover a mistake when a production trace goes sideways at 2am, and by then you're squinting at a JSON blob trying to work out which of your 23 markdown files talked the model into calling refund_customer instead of fetch_invoice.

The tooling gap is real and nobody's filling it especially well. Most of what exists is either bundled into a platform you have to adopt wholesale, or it's a $200/month observability product that draws nice graphs of failures you already knew about. What I wanted was eslint for a folder of markdown. Runs in two seconds, tells me line 238 is broken, needs no account.

The tools I actually open every week

agent-skill-validator

I run this before commits. Paste a SKILL.md, get back the structural problems: missing description, a name that doesn't match its folder, allowed-tools entries pointing at tools that don't exist in your config, YAML that parses cleanly while meaning something other than what you intended.

The check that earns its keep is the description one. A skill description is the only thing the model sees when deciding whether to load your skill, and roughly half the ones I've inherited read like internal API docs ("Handles the invoice subsystem"). The validator flags descriptions below a length threshold and descriptions containing no trigger language. It's a dumb heuristic. It has also been right every single time for me.

I was wrong about this tool at first. Frontmatter validation seemed too trivial to bother with. Then I lost a morning to a skill that never loaded because I'd typed allowed_tools instead of allowed-tools, and YAML was perfectly happy to hand me a key that nobody read.

skill-scope-collision-detector

Paste in every skill description you've got, get back a matrix of which pairs overlap and on which words. This is the one that would have saved me those 47 minutes in February.

It runs on trigger-term overlap plus a similarity score, so it catches the obvious case (two skills that both say "use this for PDF extraction") and also the sneaky case, where skill A says "customer records" and skill B says "user accounts" and your model treats those as the same concept because of course it does.

On that 23-skill repo it surfaced 6 collisions. Four were real. Two were fine, because surrounding context disambiguated them. That hit rate is about what I'd expect, and honestly it's plenty. I don't need precision here. I need a short list of things to eyeball.

skill-payload-budget-optimizer

Every skill you register costs context before the user has typed anything at all. Nobody tells you the running total, so it creeps.

Before I built the optimizer I was doing this with a script, which I'll leave here because it's a decent sanity check even if you'd rather not open another browser tab:

#!/usr/bin/env python3
"""Rough context cost of every SKILL.md under a directory, biggest first."""
import pathlib
import re
import sys

root = pathlib.Path(sys.argv[1] if len(sys.argv) > 1 else ".")
rows = []

for path in root.rglob("SKILL.md"):
    text = path.read_text(encoding="utf-8")
    body = re.sub(r"\A---.*?^---\s*", "", text, flags=re.S | re.M)
    rows.append((len(body) // 4, str(path)))

rows.sort(reverse=True)
for approx_tokens, path in rows:
    print(f"{approx_tokens:>7,}  {path}")
print(f"{sum(t for t, _ in rows):>7,}  TOTAL across {len(rows)} skills")

That reported 18,400 tokens across 23 skills on the repo I mentioned. The optimizer got it down to 11,200 without deleting a single skill, mostly by moving verbose examples out of description fields and into skill bodies, where they only load on demand.

tool-approval-matrix-compiler

Feed it your skills and your tool list, get a grid of which skill is allowed to call what. Then you stare at the grid and say "hang on, why can the changelog writer call the deploy tool".

That's the entire value. A read-only view of permissions you already configured, arranged so a human can spot the wrong ones. I found two over-broad grants in about a minute, both of them me being lazy months earlier and pasting an allowed-tools list from one skill into another.

If you're shipping agents that touch anything with side effects, do this once a quarter. It's boring and takes ten minutes.

trace-failure-classifier

Paste a failed agent trace, get the failure bucketed: wrong skill selected, right skill with bad arguments, tool errored and the model carried on regardless, model looped, context truncated mid-task.

Those buckets matter more than they sound like they should. "The agent failed" isn't actionable. "The agent picked the right skill, then passed a date in the wrong format three times without noticing the tool error" tells you which line to open.

I've fed it around 60 traces since April. It lands the right bucket most of the time, and when it's unsure it says so rather than confidently inventing a story, which I appreciate more than I expected to.

All eight, side by side

Tool	Best for	Pricing	The one dealbreaker
agent-skill-validator	Pre-commit frontmatter checks	Free, client-side	Structural checks only, semantics are on you
skill-scope-collision-detector	Finding overlapping trigger text	Free, client-side	Needs every description pasted at once, no repo crawl
skill-payload-budget-optimizer	Cutting startup context cost	Free, client-side	Token counts are approximate, not per-model exact
trace-failure-classifier	Triaging production agent failures	Free, client-side	One trace at a time, no batch mode
tool-approval-matrix-compiler	Auditing which skill calls what	Free, client-side	Shows you the problem, you apply the fix by hand
skill-spec-converter	Moving skills between agent frameworks	Free, client-side	Round trips drop custom fields
skill-regression-suite-builder	Generating test cases from a spec	Free, client-side	Generated cases need a human pass before they're worth running
skill-release-canary-planner	Staging a skill rollout across users	Free, client-side	Assumes you can already segment traffic

All eight sit on one page at aidevhub.io/tools/ai, which is where I keep the ones I bookmark. The bottom three in that table get pulled out maybe monthly, so they didn't earn a section above. The spec converter in particular is a thing you use twice and forget until the next migration.

The one I ditched

A hosted eval platform. $91.64 a month including tax, an odd enough number that I remember it exactly. I ran it from December 2025 through March 2026 and cancelled on a Tuesday afternoon while looking at the invoice.

It was a good product. It answered a question I didn't have. It could tell me my agent's success rate slid from 94% to 89% over a week. Fine. What it couldn't tell me was that the slide happened because someone added a skill whose description overlapped an existing one, which is exactly what had happened, twice.

Most agent observability tooling right now measures outcomes at a level of abstraction too high to act on. I need to know which markdown file to edit. A line trending downward doesn't get me there, and paying $91.64 a month for that line felt worse every time I opened it.

I dropped my own bash-and-python token counter too, the ancestor of the script above, once I got tired of maintaining an estimator that ran about 15% off in a direction I couldn't predict. Keeping it in this post regardless, since it's a fair first thing to run on a repo you've just inherited.

FAQ

Q: Do these upload my skill files anywhere?

A: No. They run inside the browser tab. I built them that way because I wasn't allowed to paste work skill definitions into a third-party server, and I assume plenty of people are in the same spot. Open devtools and watch the network panel if you want to verify that, it's a reasonable thing to check.

Q: Do they work with skills that aren't Claude Code skills?

A: Mostly. The validator and the collision detector care about frontmatter and description text, which most agent frameworks have in some shape. The spec converter exists specifically for moving between formats. The approval matrix compiler assumes a per-skill tool allowlist, so if your framework handles permissions globally it won't tell you much.

Q: How accurate is the token counting?

A: Close enough to make decisions with. Too rough to bill against. It's a character-based approximation, so it drifts a few percent on text heavy with code or non-English content. For exact figures, run the text through your provider's tokenizer.

Q: Fastest way to get value out of this list on an existing repo?

A: Collision detector first, payload budget second. Those two find problems that are already costing you something today. Validation is a pre-commit habit, and it pays off going forward rather than retroactively.

Written with AI assistance and human review. Try the tool at aidevhub.io/tools/ai.