DEV Community

The Tool Continues; the Human Stops

What we learned building an offline AI guardrails checker — including the test it failed

AISoltrics Technologies Inc. — engineering note, 16 November 2026. Every figure in this article comes from internal tests run on synthetic data written for testing. No customer data, no production system, and no client engagement is described or implied anywhere in this article.


We did not set out to build a wall. The wall — a guardrail placed in front of a live model to stop bad things from happening — was the idea we deliberately chose not to build. We built something smaller and more honest: an offline assessment tool — and then we ran a test that showed us exactly where its honesty has to live.

The tool is a standard-library-only Python command-line program. It reads a JSONL file of recorded AI interactions (the prompts, responses and tool traces a log contains), runs a set of pattern checks over each record, and writes a JSON and Markdown report: findings by category and severity, a per-record breakdown, and a summary score with a grade. It runs entirely offline. On our fixed synthetic test corpus, under our recorded test conditions, its output was deterministic: repeated runs produced byte-identical reports, which we verified by hashing repeated runs against the shipped reference outputs. That is a statement about those tests on that corpus — not a promise of identical output in every environment, and not a safety guarantee.

On that shipped synthetic test corpus — ten records we wrote ourselves, seeded with known problems — the reference run reports 10 records evaluated, 7 with findings, 14 findings in total (5 critical, 7 high, 2 medium), score 0/100, grade D. The corpus is a deliberately failing test fixture: it was written to be dirty, and the failing grade is the fixture working as intended. These statistics describe the fixture only — they are not customer outcomes, not evidence of product efficacy, and not a compliance certification.

That is the easy part. The interesting part is the test the tool failed.

The drill

We appended one extra record to a copy of the corpus. The record contained two obvious, fake credential assignments — the kind of thing that should never appear in an AI interaction log:

  • one written with a credential keyword form the checker recognizes, and
  • one written with a credential keyword form it does not.

Our demonstration protocol expected this record to trigger a stop-and-report behaviour. It did not. The tool flagged the record — one finding, high severity, with the credential excerpt masked in the report — and then carried on, finished the run, and exited with code 0. One finding, not two. No stop, no alert.

We recorded the test — T5 in our internal test log — as a FAIL, in those words, and left it failed. Then we investigated, because "one finding from two planted secrets" has more than one possible explanation, and the wrong explanation leads to the wrong fix.

Why it behaved that way

Two plain design properties, both visible in the tool's observable behaviour, fully explain the result:

  1. One match per pattern per record. For the generic-credential-assignment pattern examined in this drill, the tool reports at most one matching finding per record. It searches that named pattern once per record; additional matches to that same pattern are not counted. Other named checks may still report separate findings on the same record.
  2. Detection is bound to the pattern list. Some credential keyword forms are not recognized by the current pattern list. A secret written with a keyword form the list does not cover produced no finding at all: to this tool, it is not there.

These are known functional limitations of the tool as shipped, and we record them as limitations — not as quirks, and not as acceptable behaviour. Their common property is silence: the report looks complete, the count looks authoritative, and nothing in the output tells you that a record can hold three credential assignments and be reported once, or that a fourth keyword spelling would have passed through unflagged. A limitation a user cannot see in the output is a limitation the documentation has to state plainly — which is what this section is for.

The lessons we took

A detector is not a control. Flagging a planted secret is detection. Stopping the engagement, quarantining the material, and reporting it is a control — and in an offline tool, that control is a human procedure, not a code path. So we wrote the procedure down as a versioned, timed tabletop exercise (T5-SOP): the operator identifies the flagged record, stops, quarantines the material instead of retaining it, reports the same day (masked excerpt only — the procedure forbids circulating the secret itself), and documents the disposition — all five steps to be completed inside fifteen minutes, and scored. Its status must be stated exactly: T5-SOP is defined but has not yet been run. It is a written procedure awaiting its first rehearsal, and nothing in this article should be read as claiming it has been rehearsed, passed, or relied on. The one-line disclosure that now travels with every description of this tool is the title of this article: the tool continues; the human stops.

Coverage is a list, and lists have edges. Our checker detects the spellings in its pattern list — no others. Publishing the tool's behaviour honestly means publishing that limit with it: detection is pattern-list-bound, and a clean report means "nothing matched the patterns," never "nothing was there."

Counts can hide multiplicity. "One finding" for a record is a statement about the checker's design, not about the record. If your reporting collapses multiple hits into one, say so — otherwise a reader will price the risk wrong.

Reproducibility is a feature worth the discipline. On the fixed synthetic corpus and under the recorded execution conditions, our runs were byte-identical and hash-stable, so a reviewer can rerun our exact test under those conditions and reproduce our exact report, byte for byte. That made the failure above cheap to prove and straightforward to verify under the recorded conditions. We recommend the property to anyone building assessment tooling: if your evidence cannot be reproduced, it is a story, not evidence.

Scope, stated plainly. This tool is offline pattern detection plus human assessment. It is not runtime enforcement, it does not sit in front of a live model, and it is not a compliance certification. We would rather publish that sentence than let a demo imply otherwise.

Where this stands

The timeline, stated plainly. The original drill (T5) was run and recorded FAIL; it stays failed in our records, and we did not regrade it after writing the human procedure, because the procedure is a different test of a different thing. The tabletop procedure written in response (T5-SOP) is defined but NOT RUN. The demonstration protocol's presenter-timing test (T2) is also NOT RUN. Our internal QA has kept the tool's customer-facing demonstration blocked until both T5-SOP and T2 have actually been executed and evidenced. That is the correct order of things, and it is why this article describes an internal test programme rather than a launch.

If you log AI interactions, the questions worth asking of any guardrails checker, ours included, are the ones this drill forced on us: What spellings does it not know? What does one finding actually count? And when it finds something real, who stops — because it won't be the tool.

Reproducibility

The algorithm and numerical claims in this article rest on our internal test log, KAN386-TESTS-AND-RESEARCH-2026-11-15.md (SHA-256: d03dab5b27e2ef39425b4a9173457bbefe9d65b819f39ed82ae2650cf32891b1), which records the runs behind every figure quoted here, including the T5 drill — run, as recorded in that log, on a copy of the corpus with the one appended record described above. The tool under test was guardrails_assessment v0.1.0, a standard-library-only Python CLI whose check and engine modules are as recorded in the KAN-386 investigation. The corpus was the shipped synthetic test file samples/sample_corpus.jsonl — ten records we wrote ourselves, seeded with known problems (file SHA-256: dc451720146378baf3dd7c3dc4f52b29a27b6127e32d2a620aef41bcc15d23d5). These references are our execution records: they are the evidence for what we ran and what it produced, and no independent rerun of them is claimed.


AISoltrics Technologies Inc. is a Delaware C-Corporation working on enterprise AI: a services arm that builds AI solutions for clients, and a products arm building its own AI products, with end-to-end AI product engineering as the centre of gravity. This article reports internal tests on synthetic data only; it makes no claim about any real-world system, customer, or outcome.

Top comments (0)