Control loop first, proof underneath
CARVES gives AI work project memory, progression, and review.
The public model is simple: keep the project goal visible, move through a bounded plan, preserve the project memory needed for the next step, require evidence after execution, and let the human decide whether the result can continue. Guard, Handoff, Audit, Shield, and Matrix are the local proof chain underneath that loop.
Progress
Stable project progression architecture.
CARVES gives AI work a repeatable path: goal, bounded card, plan, evidence, review, and next step. This is the structure that keeps a project moving instead of drifting through chat.
A project should not end up as a long chat transcript; it should keep moving with goal, plan, evidence, review, and next step visible.
Memory
Long project memory for large work.
CARVES keeps the project story durable: what the goal is, what boundaries were set, what was tried, what evidence exists, what decisions were made, and what the next session must know.
This is engineering continuity memory, not a universal memory database. The point is to avoid restarting large work from zero.
Proof
Evidence before confidence.
CARVES pushes results back through inspectable evidence so the human can review what happened instead of trusting a fluent completion message.
A result is not complete just because the agent says so; it should come back with inspectable evidence.
Control
Human authority stays explicit.
The agent can help execute, but CARVES keeps accept, reject, and replan as visible human control points.
AI can execute, but acceptance, rejection, and replanning remain human decisions.
Goal
Direction and final review stay human-held.
The human keeps the goal, decisions, and acceptance points visible instead of letting a long chat silently drift.
Plan
The plan comes before execution.
A short plan turns the goal into bounded steps so the workflow moves by intent instead of improvisation.
Evidence
Results need proof before trust.
A result should return with enough evidence for the human to inspect it before accepting it.
Review
Human acceptance remains the gate.
Review decides whether a result is accepted, rejected, or sent back for another plan.
Technical proof layer
The module chain sits below the workflow.
These modules are still important, but they are not the first thing a new user has to understand. They explain why CARVES can keep evidence, handoff, local self-checks, and composition proof inspectable.
Guard
CARVES Guard: Patch admission gate.
Checks AI-generated patches before they enter review or merge.
Guard reads the git working tree, applies local policy checks, and returns allow, review, or block without pretending to be an operating-system sandbox.
Open GuardHandoff
CARVES Handoff: Session continuity packet.
Writes an inspectable packet for the next human or agent.
Handoff preserves the current objective, completed facts, remaining work, must-not-repeat notes, and next-session guidance in a local JSON packet.
Open HandoffAudit
CARVES Audit: Evidence discovery layer.
Discovers local Guard and Handoff evidence without mutating either source.
Audit reads local decisions and packets, produces summaries and timelines, and emits conservative shield-evidence.v0 for Shield.
Open AuditShield
CARVES Shield: Local self-check and badge.
Evaluates shield-evidence.v0 into Standard G/H/A, Lite score, and a local badge.
Shield answers whether a repository can show bounded, handed-off, and auditable AI-assisted code work using summary evidence.
Open ShieldMatrix
CARVES Matrix: Composition proof lane.
Orchestrates the local Guard -> Handoff -> Audit -> Shield proof chain.
Matrix proves that the four peer products compose in a normal git repository and records a summary-only artifact bundle.
Open MatrixHuman review remains the gate.
Matrix records local composition proof. It does not decide that a patch should merge, certify a project, rate an AI model, or prove semantic correctness. The technical proof layer supports the console; it does not replace the human control point.