Project Info

Signoff: Verified delivery for coding agents

This project did not submit a demo video on Devpost.

Inspiration

Coding agents are getting good at producing code, but they are still too willing to declare themselves “done.” We wanted a workflow where a user does not have to babysit an agent conversation or manually reconstruct whether the final PR actually satisfied the request. Signoff came from a simple belief: a coding agent should not be able to move the goalposts after it starts working, and it should not certify its own output. The user should approve the definition of done first, then review proof instead of vibes.

What it does

Signoff is verified delivery for coding agents. From ASI:One, a user asks for a bounded Next.js task. Signoff turns that request into a frozen completion contract with objective, machine-checkable criteria. After the user approves it, Signoff authorizes a Stripe test-mode payment, delegates implementation, opens a GitHub PR, runs independent Browserbase verification against the finished preview, and returns a deterministic verdict. The result can be satisfied, not_satisfied, or verification_error. Payment is captured only after the accepted checks pass. If the app builds but fails an agreed criterion, like horizontal overflow on mobile, Signoff refuses to sign off.

How we built it

We built Signoff as an ASI/Agentverse-facing uAgent backed by a TypeScript/Bun control plane. The Python uAgent handles the chat flow: drafting the contract, showing acceptance criteria, freezing the approved scope, and reporting status and proof back to ASI:One. The backend uses Hono, Zod, and Bun to manage jobs, contract hashing, verification state, proof bundles, and API routes. Contracts are canonicalized and hashed so repair attempts keep the same definition of done. A deterministic verdict policy checks required evidence, commit SHA consistency, and criterion results. For execution, Signoff targets a known Next.js demo repo, creates signoff/... branches, applies or delegates changes, runs builds, opens draft PRs with Octokit, and starts a preview through Cloudflare. Browserbase plus Playwright-core runs the frozen criteria in a real browser, captures screenshots, records replay links, and returns structured observed values. Stripe Checkout uses manual capture so the payment authorization is captured only after verified completion. The proof page packages the contract hash, PR, commit SHAs, Browserbase results, timeline, screenshots, verdict, and payment state into one reviewable artifact.

Challenges we ran into

The hardest part was keeping the product honest. It is easy to say “AI verified the work,” but much harder to define what proof means, what evidence is trusted, and what happens when evidence is missing. We had to separate subjective quality from objective acceptance criteria. We also had to make ASI central instead of treating it as a thin router. The important product moment is not just starting a backend job; it is the ASI-visible lifecycle of intent, contract, approval, proof, verdict, and refusal when needed. Browser automation and live infrastructure added the usual demo sharp edges: Browserbase session limits, preview timing, GitHub credentials, payment state, and runner setup. The red path mattered as much as the green path, so we built prepared success, failure, repair, verification-error, and SHA-mismatch runs.

Accomplishments we're proud of

We are proud that Signoff fails closed. A build passing is not enough. A PR existing is not enough. Screenshots alone are not enough. The deterministic policy requires every frozen criterion to have usable machine evidence, and it blocks merge/payment eligibility when the runtime commit does not match the implementation commit. We are also proud of the repair loop. A failed attempt can be sent back under the same contract, but the executor cannot rewrite the acceptance criteria. The final successful repair only passes after all criteria are rerun. Most of all, we like the product shape: “Delegate the task. Review the proof, not the conversation.”

What we learned

We learned that verification is mostly about boundaries. The executor should edit code, but it should not hold payment credentials, verifier authority, or release authority. Browserbase should measure the browser, but deterministic policy should decide the verdict. ASI should own the contract and explain the decision to the user. We also learned that failure demos are more persuasive than happy paths. The moment Signoff says, “I can’t sign off because scrollWidth=927 and innerWidth=390,” the product becomes clear.

What's next

Next, we want to generalize Signoff beyond the prepared Next.js demo path. That means stronger repo survey, broader criteria generation, more framework support, production-grade sandboxing, GitHub App installation flows, durable Redis-backed timelines, and tighter Sentry release-scoped runtime gates. Longer term, Signoff could become the delivery layer for coding agents: fixed contracts, independent verification, proof bundles, repair attempts, and outcome-based payment across many agent executors. The agent can write the code, but Signoff decides whether it was actually delivered.

Signoff

Verified software delivery through ASI:One.

Signoff lets a technical user delegate a bounded Next.js task without supervising a coding agent step by step. From chat, it drafts objective completion criteria, quotes the task, waits for approval, runs the executor, verifies the finished PR in Browserbase, and signs off only when the frozen checks pass.

The core promise:

Delegate the task. Review the proof, not the conversation.

Install

bun install

Python dependencies for the ASI/Agentverse broker:

python3 -m venv .venv
. .venv/bin/activate
pip install -r agentverse/requirements.txt

Configure

Copy .env.example to .env and fill in the services you want active. The scaffold works without Redis, Browserbase, Sentry, GitHub, or the executor webhook, but those integrations will be marked as skipped. Stripe is required for the hackathon payment demo.

Run the orchestrator

bun run dev

Run the ASI broker

. .venv/bin/activate
python agentverse/signoff_agent.py

Test locally

curl -X POST http://localhost:8787/jobs \
  -H 'content-type: application/json' \
  -d '{"goal":"Improve the mobile dashboard layout in the demo Next.js repo","previewUrl":"https://example.com"}'

Open the returned artifacts.proofPageUrl to inspect the proof page. Approve the contract in ASI, authorize the Stripe test payment, then review the PR, replay, screenshots, and criterion-level verdict when the job finishes.

Analysis

Compare with all teams

View

Metric

grahamwinter
6
Cursor
6

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

PythonIn code
RedisIn code
TypeScriptIn code

3 of 3 appear in the indexed code.

AI coding agents

Claude CodeConfig
CursorConfig · Commits

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

241 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.