AI that verifies its own code.
Bodega One Code is built around QEL, the Quality Enforcement Layer. Every change the agent makes runs a 5-step verification pass before it can be called done, so you review proof instead of guesses.
What is QEL?
QEL, the Quality Enforcement Layer, is Bodega One Code's built-in verification system. When the agent finishes a code task, QEL checks the work against a contract pulled from your prompt, runs a real compiler and test gates (and a live request for server tasks), and grades the result pass or fail with a score. If it fails, the agent gets exact repair instructions and tries again. The agent proves its code before you ever see it.
Most AI coding tools generate and hope. They write code, hand it back, and trust that you will catch what went wrong. That works fine for autocomplete. It is not acceptable for an autonomous agent running unsupervised across your codebase. QEL is the layer that makes the agent responsible for its own work: not responsible for trying, responsible for delivering something that compiles and passes your tests.
It is not a test suite you run by hand after the agent finishes. It runs inside the agentic loop, on every write, and it is the same layer described in the verification gap: the distance between how much developers trust AI code and how often they actually check it.
The 5-step verification pass
The label "5 steps" is a simplified view of a system that runs continuously through the agentic loop. Each step targets a different moment where AI-written code can go wrong, from the first plan to the final gate.
- 01
Contract extraction
Before the agent's first call, your prompt is parsed into a machine-checkable contract: which files must exist, which framework is required, which patterns must appear, and which commands should verify the output. Pure regex, under 5ms, no LLM call.
- 02
Checks on every write
After each file write, a lightweight pattern and compile check runs against the contract. Broken imports, missing exports, and structural mismatches get caught mid-loop, while the agent can still fix them.
- 03
Micro-proof gates
Every couple of writes, a real compile command runs (tsc --noEmit for TypeScript, a compile pass for Python) with a short timeout. This catches errors that only appear when multiple files interact, before the agent stacks more code on top.
- 04
Full verification and scoring
When the agent believes the task is done, the full suite runs: compile and test gates, plus an execution proof for server tasks that boots the app and sends one real request to the route. The result is scored across five dimensions (files, patterns, framework, completeness, and proof) and graded pass or fail against a threshold set by the model size.
- 05
Targeted repair
If the score is below the bar, QEL does not just say try again. It hands the agent line-level rewrite and patch instructions describing exactly what is missing or broken, then reruns the gate, up to a bounded repair budget.
Want the full technical breakdown? Read the QEL docs or the mechanics deep-dive.
Why self-verifying code matters
The verification gap
Most AI tools generate and hope: they produce fluent code whether or not it works, then trust you to catch the rest. In Sonar's January 2026 survey of professional developers, 96% did not fully trust that AI-generated code is functionally correct, and fewer than half always check it before committing. QEL closes that gap by making the agent bring evidence.
Autonomous agents need it most
Autocomplete shows you one line at a time. An autonomous agent writes across dozens of files unsupervised, and every step adds room for a missing import or a partial edit that breaks something two files away. Verifying each write is what keeps a long agent run honest.
Proof, not confidence
A model reports done with the same tone whether the code compiles or crashes. QEL replaces that with evidence: it compiles the code, runs the gates, and for a server task it boots the app and sends a real request to the route the task asked for.
It runs on your machine
QEL is part of the local agentic loop. The checks, compiles, and tests run on your hardware with your own LLM. Verification never sends your code anywhere, and it works in air-gap mode too.
Why most AI tools can't prove their code
Generation and verification are different jobs, and most tools only do the first one. A model reports done with the same confidence whether the code compiles or crashes. When the system that wrote the code is the only thing vouching for it, done just means the model stopped typing.
QEL is built on the opposite rule: the verifier does not trust the generator. It runs its own compiler, its own test gates, and a real request against a server route, then scores the result. Human review was supposed to close this gap, but at agent speed it cannot keep up. Making the agent bring evidence can.
It works this way because Bodega One Code was designed local-first. The model runs on your machine through Bring Your Own LLM, so the verification loop runs locally too. It even works with air-gap mode on, where nothing leaves the machine.
Common
questions
How do AI coding agents verify their own code?+
They verify by checking their output against a machine-checkable contract instead of trusting the model's own claim that it finished. In Bodega One Code, the Quality Enforcement Layer (QEL) extracts the required files, framework, and patterns from your prompt, checks every file write against them, runs real compile and test gates, and for server tasks boots the app and sends a live request to the route. If a check fails, the agent gets line-level repair instructions and tries again before the task can be called complete.
What is QEL?+
QEL stands for Quality Enforcement Layer. It is Bodega One Code's automatic verification system, built into the agentic loop. It runs on code-creation tasks without any setup, scores the result across five dimensions (files, patterns, framework, completeness, and proof), and surfaces a pass or fail score in the app. Its job is to make the agent responsible for proving its own work, not just producing it.
Can an AI agent really verify its own code?+
Yes, with one architectural rule: the verifier must not trust the generator. QEL does not ask the model whether it succeeded. It runs independent checks (pattern matches, a real compiler, a test runner, and a live request for server tasks) and scores the result against a threshold set by the model size class. Verification proves the code compiles, matches the contract, and runs. A human still confirms it solves the right problem, so QEL surfaces a clean, scored diff for review rather than auto-approving marginal work.
Does Bodega One Code verify its code automatically?+
Yes. QEL runs automatically after any creation task, with no button to press and no configuration. It activates when your request pairs a creation verb (create, build, generate) with an artifact (files, endpoints, components), and it stays out of the way for plain questions. Everything runs locally as part of the agentic loop, so it works with your own LLM and in air-gap mode.
Make your agent prove it.
Beta is free and open to everyone. Free for personal use. QEL runs on every task, no setup required.