The project layer for AI coding harnesses
Run Strata19 from a desktop app, IDE, CLI, or TUI. Your harness gives the agent tools; Strata19 gives it a project—durable code context, specifications, work, routines, approvals, checkpoints, and evidence.
The problem
A coding conversation can see files and follow instructions. It does not automatically inherit durable project state, accepted intent, work history, or evidence that the requested outcome was reached.
of AI-built projects never reach real users
Aggregate across major AI app-building platforms, 25M+ users — not an edge case.
say AI assistants miss relevant context when refactoring — Qodo, 2025
Past a certain size, quality collapses — the agent can't hold your architecture, your conventions, or what changed five files away, so it guesses.
Closes with
A persistent map of the codebase that survives past any single context window — not rebuilt from scratch every session.
of developers always check AI-generated code before committing it — Sonar, 2026
Without an explicit, checkable definition, an agent stops when the code compiles — not when it's actually correct. The gap surfaces later, usually in production.
Closes with
A definition of done that's checked deterministically — not asserted by the same model that wrote the code.
of requirements never make it into a written spec
Decisions, constraints, and prior findings live outside the files. Past a few thousand lines, an agent reading only source code is reading half the project.
Closes with
A reference layer outside the code — specs, decisions, prior findings — that's actually queryable.
more issues in AI-authored code than human-written code — CodeRabbit, 470 real PRs, 2025
Mock data, stubs, and quietly duplicated logic all compile clean. Gaps like these don't show up until they've compounded into a much bigger one.
Closes with
Verification that runs after every change, independent of the agent's own claim that it's finished.
What shipping without these looks like
Strata19 is built around exactly these four requirements.
The project environment
AGENTS.md, CLAUDE.md, .cursorrules — however many you keep, they only ever carry instructions. Strata19 holds the evolving project once, on your machine: what exists, what is intended, what work is open, what changed, and what the available evidence supports. It exposes that state through one MCP tool surface while making host-specific limits explicit.
One portable MCP foundation
Where am I, what’s next
Symbols, routes, call paths
What breaks if I touch this
What it should do, binding
Research, decisions, and context
Real gaps, with file and line
In flight, blocked, or done
Routines that run, pause, resume
Proof it landed, not a claim
Understand the code, understand the intent, and move the work without rebuilding the project from chat history.
Real host evidence today. Cursor, Gemini CLI, Copilot, Windsurf, and other MCP templates remain planned.
Code Intelligence
Import graphs and call graphs are only the start. Strata19 adds the project layer AI-generated code needs: relevant code relationships, detectors tuned to how agents fail, specifications, findings, and evidence with explicit limits. Where a detector is unmeasured, it says so.
22 automatic checks and 9 on-request checks — all shipped in the plugin.
Finds source files that no import, route, test, or configuration entrypoint reaches.
Finds repeated code blocks across the project.
Finds unfinished code such as TODOs, empty bodies, and not-implemented errors.
Finds missing environment templates, malformed package files, and missing standard commands.
Finds catch handlers that silently discard failures instead of preserving or escalating them.
Finds an unprotected endpoint beside guarded endpoints under the same route prefix.
Finds when accepted project standards no longer match the configuration that established them.
Maps infrastructure files and reports recognized inputs the analyzer could not resolve.
Finds exported symbols that no other project source imports.
Finds files unreachable from the application entrypoints.
Finds background jobs and scheduled tasks that are defined but never registered.
Finds groups of modules that import each other in a cycle.
Finds branches and statements that cannot execute.
Finds function bodies that remain duplicates even after identifiers are renamed.
Finds routes registered to handler names that do not exist.
Finds a sensitive handler without the permission check used by its siblings.
Finds production source importing testing libraries.
Finds functions that appear complete but do no meaningful work.
Finds configuration that points to a missing script, file, or environment variable.
Finds specified endpoints or entities with no corresponding implementation.
Finds implemented entities or endpoints whose fields disagree with the specification.
Finds reachable routes missing from an already documented API namespace.
Traces request-controlled input into shell command execution.
Ask the plugin to run: run_native_security_analysis
Traces request-controlled input into dynamically constructed database queries.
Ask the plugin to run: run_native_security_analysis
Finds request-controlled URLs used for server fetches or redirects.
Ask the plugin to run: run_native_security_analysis
Finds request-controlled filenames used as unrestricted filesystem paths.
Ask the plugin to run: run_native_security_analysis
Finds unescaped request-controlled text written into HTTP responses.
Ask the plugin to run: run_native_security_analysis
Finds request-controlled input passed into dynamic JavaScript execution.
Ask the plugin to run: run_native_security_analysis
Compares revisions for removed or changed exports and names the affected callers.
Ask the plugin to run: get_breaking_change_risk
Reports which checkable promises in a file are proven, disproven, or limited by verification coverage.
Ask the plugin to run: get_proof_certificate
Compares a work item’s declared scope with the files the work actually touched.
Ask the plugin to run: verify_implementation
Every listed check ships in the Strata19 plugin. Automatic checks run from their owning verification paths; on-request checks run when you invoke the corresponding analysis. Results report their own scope and coverage instead of implying that an unavailable analysis passed.
Spec-native
Spec-driven development had the right idea and one fatal habit: the spec is written for a feature, then frozen at kickoff while the code walks away from it. Strata19 keeps one project-wide specbook, and the distance between it and your code is what tells you what to build next.
Spec-driven
Spec-native
The change
Spec-driven
payment-reminders-spec.md
requirements
design
tasks ☐ ☐ ☐
A file, on its own. Where it fits in the system, the model infers.
Spec-native
Orange is specified and not built. That is the queue — and because it sits in the tree, you can see what it belongs to.
What the agent gets with it
Spec-driven
Spec-native
Definition of done
Spec-driven
A ticked box. The thing that did the work also decides it is finished.
Spec-native
A criterion linked to the code or test that satisfies it — re-checked, and able to regress on its own when the code moves. Requirements nothing covers are named, not passed.
None of this is required. Strata19 indexes your repository and finds real work the moment you install it — no specbook, no process to adopt. The specbook is what you turn on when you want the gap between intent and code to be something the system can see.
ORCHESTRATE WORK
Describe a recurring practice in conversation and Strata19 can guide the assistant to draft a routine. A finding or request then becomes structured work with provenance, scope, and success criteria. One local queue holds it, and publishing, starting, and completion remain decisions a person can review.
and all three produce the same thing
Promoted with the file, the line, and the evidence still attached.
You log it — or the model logs it mid-conversation, through the same tool.
Describe recurring work to your assistant, then review the routine it drafts before publishing or starting it.
work · unguarded endpoint in handler.ts
from GC-08 · handler.ts:42
scope src/api/handler.ts
done route is guarded, test covers it
Evidence
Shipped deterministic checks run across the project, and the verdict is computed from what they find — not from anyone's summary. Name a checkpoint and that finding set becomes the line you measure from, so the next run is a comparison against a recorded state rather than a claim.
Each check reports what it actually is. The dead-code pass tells you to its face that it is a heuristic and not a real reachability proof — because a number you cannot interpret is worse than no number.
against checkpoint #c-1204
Findings are content-addressed, so the comparison is an exact set operation rather than a guess. Note what the middle row does and does not say: five findings are gone from the set. Proving each one was repaired is a different claim, and this is not it.
And what it will not tell you
Words like verified, proves, or guarantees are stripped out of local-tier output before it ever reaches you.
Nothing here runs your suite, so it will never report that 132 of 132 tests passed.
The change surface is a list of files. It does not tell you 48 lines were added.
Where an analysis needs the hosted graph, it reports not computed — rather than returning zero and letting you read that as clean.
A tool that will not overstate what it checked is the only kind whose green result means anything.
Pricing
Free Local gives you durable project intelligence on your machine. Connected and Pro add synchronization, the web app, managed inference, and routines when they launch.
For individual developers
$0
Durable project intelligence on your machine. No account or source upload required.
For synchronized project state
$49/mo
Cloud synchronization and the connected Strata19 web app.
For managed execution
$99/mo
Connected project intelligence with managed routines.
For client work
$499/mo
A separate operating surface for organizations and client projects.
For organizational requirements
Custom
Governance, deployment, and support designed around your requirements.
Quick install
No account. No backend. No source upload. One command and your project is graph-indexed.
Add to your agent config:
{
"mcpServers": {
"strata19": {
"command": "npx",
"args": ["@strata19/mcp"]
}
}
}Restart your agent. It auto-indexes your repo on first connection.