Vera Continuity

• 

  Vera Continuity: a verified, fail-closed continuation engine for interrupted AI-agent workflows.

• 

  A corrupted saved action targets a protected test path, demonstrating the unsafe state Vera must detect.

• 

  The five-stage pipeline detects drift, repairs a candidate, verifies it independently, and commits a safe checkpoint.

• 

  The store contains a verified state, checkpoint, and receipt. The returned next action remains unexecuted.

• 

  All 77 regression, adversarial, CLI, and release-readiness tests pass with no third-party dependencies. 06.png

• 

  Codex with GPT-5.6 assisted the build and final audit: VERIFIED, COMMITTED, 77/77 tests, and audit 6/6.

Inspiration

Long-running AI agents are increasingly capable, but interruptions and context loss create a subtle reliability problem. Restoring the latest checkpoint does not prove that the objective, invariants, completed steps, or next action are still valid.

We built Vera Continuity around one principle:

Never continue from an unverified state.

Continuation should be earned through verification, not assumed from the most recently saved state.

What it does

Vera Continuity is a fail-closed continuation engine for interrupted AI-agent workflows.

It compares saved operational state with an explicit task contract and detects objective drift, missing invariants, protected-path violations, and completed/pending step conflicts.

Repairable findings produce deterministic operations applied only to an isolated candidate copy. An independent verifier then checks source integrity, operation accounting, contract compatibility, continuation safety, repair scope, and drift closure.

Verified candidates receive a SHA-256-linked checkpoint and receipt. Rejected candidates roll back, while unresolved cases stop with the resume gate closed.

The bundled demo catches an unsafe instruction to delete a protected test and replaces it with a safe inspection of the application implementation. Vera opens the resume gate only after verification and deliberately does not execute the returned next action.

How we built it

Vera Continuity is implemented in Python 3.10+ using only the standard library.

Frozen dataclasses represent task contracts, operational states, drift findings, repair plans, execution results, verification results, checkpoints, receipts, and rollback records.

The recovery pipeline follows five explicit stages:

1. Detect and classify drift
2. Build a deterministic repair plan
3. Apply repairs to an isolated candidate
4. Independently verify the candidate
5. Commit a checkpoint and receipt, roll back, or stop

Persistence uses a locked JSON bundle written through a same-directory temporary file and committed with atomic os.replace. The CLI provides human-readable and machine-readable JSON output.

Human decisions defined the problem, product scope, invariants, protected paths, candidate-copy repair rule, and fail-closed outcomes. Codex with GPT-5.6 accelerated implementation, test generation, integration, and review.

Each major engineering increment was compiled, executed, regression-tested, and accepted in a separate dated Git commit. Codex also helped identify a receipt serialization mismatch before the storage layer was finalized.

Challenges we ran into

The main challenge was preventing the repair system from becoming another source of unsafe mutation.

We addressed this by keeping the source state immutable, restricting repairable fields, accounting for every operation, detecting undeclared candidate changes, and refusing finalization when artifact links or digests disagree.

The second challenge was making uncertainty safe. Unresolved or unverifiable states therefore never become resumable checkpoints.

Accomplishments that we're proud of

• Complete detect, plan, repair, verify, and commit/rollback pipeline
• Deterministic repair plans and decision traces
• Candidate-only atomic repair execution
• Independent six-check verifier
• Integrity-linked checkpoints and receipts
• Fail-closed rollback and unresolved-stop outcomes
• Atomic and idempotent JSON persistence
• Runnable CLI with JSON output
• 77 regression, adversarial, CLI, and release-readiness tests
• No third-party Python dependencies

What we learned

Reliable continuation is not primarily a memory problem. It is a state-validity problem.

Explicit contracts, immutable source states, independent verification, and auditable finalization make interrupted agent workflows safer to resume and easier to debug.

What's next for Vera Continuity

Future versions can connect the verified resume gate to Codex and other agent runtimes, add signed receipts, and support policy adapters for repository, testing, and deployment environments.

The core boundary will remain unchanged: verification decides whether continuation is allowed; it never silently performs the next action.

Built With

• cli
• codex
• git
• github
• gpt-5.6
• json
• openai
• python
• sha-256
• unittest