Command Palette

Navigate
Projects
Writing
Actions
↑↓Navigate↵Select
EscClose
Writing / All notesNovember 10, 2026

A code-security gate that an agent can't argue out of

How Veylqorix normalizes six heterogeneous scanners into one finding schema and a deterministic PASS / FAIL / INCOMPLETE decision — and why INCOMPLETE is the most important of the three.

RustTypeScriptSecurityMCPCI4 min
Veylqorix — Code-security gate platform
2026 // Security / DevTools

The most common failure mode of a homegrown security pipeline isn't that it misses a vulnerability. It's that it *claims* to have checked something it didn't. A license scanner times out, the step still exits zero, and the pipeline reports green. A skipped mandatory check is indistinguishable from a clean one. Six scanners later, "what did this gate actually verify?" has no answer in the output.

Veylqorix started from that observation. It's a code-security and quality gate platform, built as a TypeScript/pnpm monorepo with a standalone Rust security engine, and it's the project I'm most proud of in this portfolio because its whole design is a refusal to be optimistic by default.

The core idea: INCOMPLETE is a first-class outcome

The gate emits one of three decisions, with stable exit codes:

  • 0 — PASS: every mandatory check ran, every finding was evaluated, and the policy allows the result.
  • 1 — FAIL: a finding violates the policy.
  • 2 — INCOMPLETE: a mandatory check was skipped, errored, or a scanner was unavailable.

That third one is the entire thesis. INCOMPLETE is not a soft FAIL — it's a different claim. It says "I cannot certify this codebase as clean." A skipped dependency audit must never read as "no vulnerabilities found." By giving it its own exit code, dashboards and CI can tell *certified clean* apart from *we didn't look*, which is a distinction most pipelines collapse into a single green check.

Why Rust for the engine, TypeScript for everything else

The engine is the part where a mistake is expensive: it runs scanners, normalizes their wildly different output formats, applies policy, and produces the verdict. Rust gives me ownership-checked state around the scan lifecycle, and — honestly — the discipline of not silently dropping a scanner's error behind a Result I forgot to handle.

Everything around it is thin. The CLI, the MCP server, the REST API, the GitHub Actions integration, and the agent skills all call the same engine and never implement policy themselves. One engine, many adapters:

scanners ──► Rust engine ──► finding schema ──► gate decision
                │
                ├── CLI            (shell)
                ├── MCP server     (6 tools, for agents)
                ├── API            (REST, for dashboards)
                └── Actions       (CI gate)

The payoff is that a decision made in CI is identical to one made by an agent calling the MCP tools — same engine, same policy, same evidence. There's no second, looser path.

The finding schema

Every scanner speaks a different dialect. Veylqorix normalizes each result into one schema so policy and reporting never care which scanner produced a finding:

interface Finding {
  id: string;               // stable, deduplicated across scanners
  severity: "info" | "low" | "medium" | "high" | "critical";
  category: string;         // "dependency" | "secret" | "license" | "static" | "test" | ...
  source: string;           // which scanner produced it
  status: "open" | "suppressed";
  evidence: { file?: string; line?: number; detail: string };
}

The status field is where the agent-safety work lives.

Why an agent can't suppress a finding

This was the constraint I cared about most. An AI agent driving a pipeline has a real incentive to make a gate go green: retry a flaky scanner, mark a "noisy" finding as accepted, or simply skip the check that's failing its current change. Veylqorix's policy is agent-safe, which means suppression and policy edits come from a human-owned channel, and the engine records who (or which actor) changed what. An agent can *request* a review of a finding; it can't remove one. The audit trail is the point — a gate you can't interrogate afterward is just a confidence trick.

Sample data, labeled as sample

One more thing I keep coming back to: the demo dashboard ships with sample findings that are explicitly labeled as sample. Presenting a synthetic scan as if it were a live result would erode the exact trust the product is trying to build, so the UI is unambiguous about which numbers are illustrative.

Where it's at

MIT-licensed, with a live dashboard demo. The next pieces are scanner result caching and a diff-aware policy engine that only re-evaluates the surface a PR actually touched. If you build security tooling and you've ever watched a green check mean "we gave up partway through," I'd love to compare notes.

“The soul becomes dyed with the color of its thoughts.”
Marcus Aurelius
Soumya Chakraborty status avatar

Away from the keyboard.

Drop a mail, I'll reply when I'm back.

Made with <3 and lots of coffee.