Supervise AI coding agents before they drift.
IQAI Code is a working local prototype for AI-assisted coding supervision: what the agent touched, whether it stayed in scope, what needs review, and whether the final work deserves PASS, CAUTION, or FAIL.
Local AI coding governance for the moment before merge.
IQAI Code is not another copilot. The current prototype acts as a control layer around the coding session: task fence, protected paths, live lane status, receipt verification, and review evidence.
A local supervisor for AI-assisted coding sessions.
It watches saved file changes against a task fence, protected paths, approved plans, and session baseline.
Engineering, platform, AppSec, DevSecOps, and AI governance teams.
Designed for teams adopting Cursor, Copilot, Claude Code, and similar agents with accountability.
Whether the agent stayed in lane.
The dashboard shows touched files, in-lane and out-of-lane paths, protected hits, and live drift status.
Receipts, reports, JSON exports, and PASS / CAUTION / FAIL.
After the slice, Verify compares the agent receipt against Git truth and flags review risk.
AI agents can change many files fast and still say the work is done.
Git can show what changed after the fact. Code review can catch some problems later. IQAI Code focuses on the live session: what the agent was asked, what it touched, whether it crossed the fence, and whether its final receipt matches the actual diff.
The agent edits outside the task.
A small prompt can lead to README edits, config changes, scripts, fixtures, or unrelated files that were never in scope.
Some files should not be touched casually.
Environment files, deployment scripts, auth logic, database migrations, tests, and core project files may require tighter control.
The agent's summary is not always the Git truth.
IQAI Code checks the agent's claims against the actual working-tree diff before the work is trusted.
One screen tells the reviewer what to do now.
The dashboard translates file activity into plain supervision states while the agent works. The labels are designed for fast human control, not for noisy technical logs.
Continue
Saved changes are inside the task fence and no protected path has been touched.
Review
The agent has saved files outside the allowed fence or the approved plan no longer matches the actual session.
Do not continue blindly
Protected core was touched or the hard-stop policy is triggered. The session requires human intervention.
A session-level control layer, not a repo-wide scanner.
IQAI Code works from local session evidence: task, baseline, saved files, fences, protected paths, agent receipt, Git diff, optional Cursor hooks, and deterministic verification.
Task fence
Allowed globs and slice contract define where the agent is supposed to work.
Session baseline
Only changes after start or rebaseline count as session changes.
Protected paths
Do-not-touch paths can trigger STOP when a protected core is modified.
Approved plan
Guided and Strict modes can compare saved files against an approved file plan.
Prompt mirror
Cursor transcript and optional hooks can mirror the user prompt into the dashboard.
Agent receipt
The agent writes what it claims was done in .codetrust/agent_receipt.md.
Git truth
Verify compares receipt claims to the actual Git diff and changed paths.
Security heuristics
Rule-based change-set checks flag secrets, auth weakening, dependency shifts, and other risk patterns.
Start the slice. Watch the work. Verify the receipt.
The prototype workflow is intentionally simple: define the task, watch the session, approve scope where needed, and finish with a deterministic trust check.
Initialize a supervised slice with task text, mode, baseline, contract, and dashboard prompt.
The local feed updates every few seconds while saved changes appear in the working tree.
In Guided mode, the agent can propose a file plan and the human can approve the intended scope.
The agent receipt is compared against Git truth, drift rules, and security heuristics.
The session receives PASS, CAUTION, or FAIL with exportable evidence and report records.
Primary commands
The current engine is a local CLI and dashboard flow.
codetrust start --repo . --task "Edit test file only"
codetrust watch --repo .
codetrust open --repo .
codetrust approve --repo .
codetrust finish --repo .
The control page turns noisy agent activity into review decisions.
The live dashboard is the user-facing prototype surface. It shows what matters now: lane status, what the agent is touching, where it drifted, and what action the reviewer should take.
| Dashboard section | What it means | Why it matters |
|---|---|---|
| Lane status | IN LANE / DRIFTING / STOP with plain-English explanation. | Fast action state for the human supervisor. |
| What should I do now? | Continue, review, or stop depending on current telemetry. | Turns metrics into operational instruction. |
| What is the agent touching? | Changed files, last touched file, recent activity, and lane badges. | Reveals session behavior while work is still happening. |
| In-lane / out-of-lane / protected | Full path lists under the current task fence. | Shows whether the session respected scope. |
| Plan pit wall | Proposed / Approved / Match for Guided sessions. | Compares intended file scope to actual saved changes. |
| Export lap JSON | Per-prompt evidence export. | Creates tuning, audit, and governance records. |
Did the agent accurately describe what changed?
At finish, IQAI Code checks the agent's receipt against Git diff and rule-based heuristics. This creates a slice-level evidence record, not just a chat transcript.
Receipt aligns with Git truth.
The reviewed file changes and claims are consistent enough to proceed through normal review.
Review recommended.
The session may contain weak claims, drift, unclaimed changes, security flags, or missing evidence.
No-go before human repair.
The work should not be merged or trusted until the issue is resolved and the session is rechecked.
Git diff shows change. IQAI Code shows supervised change.
The product is not a scanner, not another AI reviewer, and not a replacement for engineering judgment. It adds session context and deterministic control around the agent's work.
| Normal tool | What it shows | What IQAI Code adds |
|---|---|---|
| Git diff | What changed. | Task scope, protected core, live lane status, and receipt alignment. |
| Code review | Human judgment after the work is ready. | Live supervision while the agent is still working. |
| CI/CD | Checks after push or merge request. | Local session review before the change moves forward. |
| AppSec scanners | Repo or change security findings. | Agent change-set scope plus claims, files, drift, and receipt status. |
| Agent logs | Noisy activity traces. | Verdicts, fences, protected paths, and PASS / CAUTION / FAIL. |
| IDE history | Editor-level edits. | Task fence, session baseline, dashboard, and exportable evidence. |
Working prototype today. Enterprise product still ahead.
The current Code Trust engine demonstrates the core local control loop. It is a real prototype, not a packaged enterprise product. The roadmap is the path from local tool to team deployment.
Local dashboard and deterministic session checks.
Team policies, CI gates, signed receipts, and deployment packaging.
The broader market problem is already visible.
AI coding adoption is accelerating. The source-backed evidence page covers public warning lights, AI-generated code security risk, technical debt, agentic control gaps, and review burden.
Stack Overflow's 2025 survey shows AI coding tools are already mainstream.
Veracode found AI-generated samples introduced OWASP Top 10 vulnerabilities in 45% of tests.
CodeRabbit reported AI-generated PRs produced about 1.7x more issues than human PRs in its study.
Before AI code is trusted, the session should be reviewable.
IQAI Code watches the agent while it works and checks the truth when it finishes: scope, paths, claims, diff, risk, and receipt.