Briefstamp: a receipt for the website handoff

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

A freelancer friend of mine once took a ₹8,000 website gig. After he delivered, the client made him add extra things that were never in the brief. He had nothing to point at to show what was actually agreed. That's the gap Briefstamp fills.

Briefstamp is the receipt for that handoff. Paste the client's brief, approve the checks it proposes, and a real browser tests the site. You get a report showing what matches the agreement, what fails, and what still needs a human call. An approved checklist doesn't guarantee payment, but it draws a clear line between what was agreed and what is extra.

The rule: the model only proposes checks. A human approves them, a real browser observes the site, and code decides pass or fail.

Who pays: freelancers and small studios who hand over websites. My pricing idea is ₹499 per handoff, a guess I still need to test.

Demo

Live app · Judge guide · MP4 backup

One real run, on October 16:

1. Brief: Six explicit homepage requirements: the exact heading "Send the site. Show the proof.", a delivery tagline, a "See the proof" link, image alternatives, mobile fit, and a subjective trust requirement.
2. Proposal: Gemma proposed six typed checks from those six requirements. The subjective requirement remained for human review. Nothing ran yet.
3. Approval: I approved the checks. Unapproved ones are rejected.
4. Audit: Chromium opened the real site: five passes, one unverified requirement.
5. Report: Audit results and screenshot references were saved to Tiger Postgres. The exported report included the actual screenshots and observations for the client.

Latest hosted run, October 18: the workspace now leads with delivery readiness and a Review open items button that jumps to whatever still needs a human. An anonymous run on the final deploy returned 5 passed, 0 failed, 0 blocked, 1 manual, and the button selected the manual item. Final screenshot

To show the checks aren't rubber stamps, I changed the expected heading on purpose. The audit failed, as it should. Full receipt

Optional: public evidence agent

The main demo works without this. If you want to see the agent, open the evidence walkthrough, approve its six labelled template checks, run Chromium, then consent to the model/search step. Gemma picks bounded tools (saved failures from Tiger, a SerpApi search) and cites what they returned; it can't change browser results. No token needed.

Providers can fail: of four retained public attempts, one completed, two returned Google HTTP 500 and one hit a search timeout. The shared allowance is 100 runs total, six per hour and one per browser session, ending October 20, 2026 at 00:00 UTC, and failed reservations stay spent. Public receipts · Allowance readback

Code

Public MIT repository. The final deployed source passed 1,467 TypeScript tests across 58 files, 27 Python tests, the production build and real browser audits. CI run · Week 2 upgrade receipts

How I Built It

The model only proposes. It never writes a browser script and never decides pass or fail.

Gemma proposes typed checks through Mastra, I approve them, Chromium observes the site, and Tiger saves audit results and screenshot references; the downloadable report embeds the screenshots. Temporal recovery was proven locally and in CI, then on October 18 on the live Render host after a worker restart. A second native Gemma agent selects saved failures from Tiger and a SerpApi search, then cites actual returned facts. Backboard's protected proof recovered saved results. ElevenLabs generated a synthetic counts-only audio sample; it decoded successfully, but its audible wording has not been independently checked.

Why Does Open Innovation Matter?

Open weights let me run Gemma locally and fine-tune a small Qwen model for this one job, while keeping the browser runner independent of any model host. A freelancer's client data doesn't have to live with one AI vendor.

My First User

The friend with the ₹8,000 gig, Priyanshu, tried Briefstamp and told me he can pay for it. No price was named, and that's one person, not validation: I haven't tested a price with him or watched him use it on a real handoff. Notes

Prize Categories

Each entry below links its proof. The three I built deepest come first. Awards are the judges' call.

Best Use of Tinker

A tool priced per handoff lives or dies on what each run costs. So I used Tinker to LoRA fine-tune Qwen3.5-4B for one job: turning a client's brief into checks a browser can run. Then I tested it against zero-shot and few-shot prompts on the same 24 held-out briefs.

Same 24 briefs	Zero-shot	Few-shot	Tinker LoRA v1	Tinker LoRA v2 (Oct 18)
Valid structured output	0/24	24/24	24/24	24/24
Matched the reference	0/24	23/24	22/24	24/24
False passes on broken pages	n/a	0/19	0/18	0 (20/20 browser pairs correct)
Mobile-overflow checks right	0/4	3/4	4/4	4/4
Input tokens	5,097	16,737	5,097	5,097

The format lives in the weights instead of a long prompt, so both fine-tunes need 69.55% fewer input tokens than few-shot. v1 missed two image-alt-text checks (22/24). So on October 18 I trained exactly one more LoRA with 48 extra synthetic examples (108 total, 28,620 training tokens), kept the held-out 24 byte-for-byte identical, and ran one evaluation. v2 matched all 24, beating few-shot, with 0 inappropriate abstentions. Each of its 20 executable plans passed the healthy page and failed the broken one in real Chromium, and 4 cases were correctly left for a human.

Cost per handoff: about $0.00015 inference, or $0.0012 including the whole training run spread over those 20 successful synthetic handoffs. These are token-price estimates, not an invoice. The grant balance moved $9.18 → $9.15. Honest caveats: the 24 briefs were already used during development, so this isn't a fresh independent test, and v2 is slower than few-shot (5.3s mean).

It isn't just a notebook result. On October 15 a Tinker checkpoint of the same model served a live proposal on Render: six checks from 260 input / 249 output tokens. Real Chromium then audited a healthy page (5 pass), a deliberately broken one (3 fail) and the restored page (5 pass again). That run used v1. On October 18 the v2 LoRA served a live proposal on Render too: HTTP 200, six unapproved checks waiting for approval, 509 tokens, 7.6s. It was a separately budgeted one-request allowance, so hosted Tinker is switched off again now that it's used. Hosted v2 receipt · Hosted v1 receipt · v2 evaluation and cost · Training runs and math

Best Use of Temporal

A receipt is worthless if a crash makes the browser run twice, or not at all. Temporal wraps every step of the evidence agent (both Gemma turns, the Tiger lookup and the SerpApi search) as its own activity, with bounded retries. Then I tried to break it:

What I injected	What Temporal did
Gemma returns HTTP 500	Retried once, then succeeded
SerpApi times out	Retried once, then succeeded
kill -9 on the worker mid-run	New worker resumed the same run; the 3 finished steps were not repeated
Temporal server and worker both restarted mid-audit	Same workflow resumed; the browser ran exactly once
Bad request (HTTP 400)	Failed fast, no retry
HTTP 500 three times	Stopped after 3 attempts, no answer invented

Every attempt count comes from Temporal's own event history, not my logs.

Now on the live host too (October 18). On the free 512 MiB Render service, a real workflow (Gemma selection, Tiger retrieval, SerpApi search, Gemma summary) ran with the worker restarted right after the Tiger step. It resumed the same run, each activity completed exactly once, and the one deliberate retry happened before any model call. It used 2,583 Gemma tokens and seven validated citations, and the container peaked at 359.9 MiB of 512 MiB. The limit: this proves worker recovery on the same host. A Render redeploy or spin-down can still wipe its SQLite. Hosted receipt

Local event histories · Browser recovery run

Best Use of Mastra

Mastra runs the two moments where Briefstamp has to be trusted.

1. A human approves before anything runs. Gemma proposes checks, and a Mastra workflow suspends until a person approves them, then resumes and hands the approved plan to the browser. An unapproved audit is refused (HTTP 409). Suspend/resume run

2. An agent explains what failed, with sources. After the audit, a Mastra Agent running Gemma decides for itself which tools it needs. In the hosted run it took two model turns, picked two tools on its own (failure_history from Tiger, search_visibility from SerpApi) and wrote a summary with seven citations, all validated (1,794 input / 787 output tokens). The agent runs as an isolated Mastra worker on Render, and Sentry traced all five of its spans.

October 18, natively on the live host: the briefstamp-explicit-approval workflow suspended for approval, resumed on a controlled automated owner approval (not a client sign-off), suspended again while real Chromium ran, then finished with 2 passed, 3 failed, 1 manual. All five screenshots and the report were downloaded. Not everything worked. Saving that receipt to Tiger failed and the cause isn't found yet. A separate agent run picked both tools correctly, then its summary call got HTTP 500 from the provider. I kept both failures instead of retrying. Approval run · Agent failure

The design rule: Mastra can explain an audit, but it can never change the result.

Best Use of Gemma

Gemma does the one job a freelancer can't skip: turning a client's plain-English brief into checks a browser can actually run. From six homepage requirements, hosted gemma-4-26b-a4b-it proposed six typed checks using 389 input and 296 output tokens. It sent the one subjective requirement ("feels trustworthy") to human review instead of faking a test for it. Nothing runs until a person approves, and Gemma never decides pass or fail. Gemma also powers the Mastra agent above. Because it's open-weight and free to call here, a ₹499 handoff isn't eaten up by model costs. Proof

Best Use of Render

Everything a judge touches runs on Render's free tier: the interface, the API and an isolated Mastra worker. Open the live URL, approve an audit, watch the screenshots come back and download the report, with nothing to install. Spent demo runs are stored in Tiger, so a redeploy can't quietly reset the limits. Deployment proof · Hosted desktop and mobile run

Best Use of Tiger Data

Tiger is Briefstamp's memory. Every audit, its results and its screenshot references go into Postgres. Past failures are also stored as pgvector embeddings, so the agent can ask "have we seen this before?" One SQL query mixes keyword and meaning-based search. Ask about "sideways panning on smartphones" and it still ranks the old mobile-overflow failure first, with a cosine score of 0.378 that matches an independent calculation. Limit: today it supports three fixed query vectors, not any free-text question. Migration and scores

Best Use of SerpApi

A handoff isn't finished if the client can't find their own site. Briefstamp adds an approved search_presence check: SerpApi searches for the page and confirms the expected title appears at the exact URL the client owns. On the real run, the owned page came back at position 1, while the search for the demo site returned zero. Honest caveat: I picked the positive target from an earlier search, so this is a control test, not a benchmark, and zero results doesn't prove a site was de-indexed. Responses and receipts

Best Use of Sentry Agent Tracing

Sentry showed me where a freelancer's wait actually goes. A proposal took 23.3 seconds, but generation was only 7.6 seconds of it. Without the trace I'd have blamed the model for all of it. Trace

A real hosted run traced the whole agent end to end: two Chromium spans and five Mastra spans, covering the root, two Gemma calls, the Tiger lookup and the SerpApi search. The dashboard check confirmed both trace IDs and the model latency. One gap: token counts show up in the provider receipts (1,801 in / 596 out) but not in Sentry's attributes yet.

Best Use of GitHub Copilot (GitHub Actions)

Every push re-proves the core promise in CI. The workflow audits a healthy site, a deliberately broken one, then the fixed one, all with the same approved plan: 5 passes → 4 failures → 5 passes, with screenshots and reports uploaded. Workflow · Run

Best Use of Backboard

Backboard lets a freelancer ask "what failed last time?" without digging through old reports. In a hosted run, it retrieved six saved audit facts, and Gemma answered with three exact failure claims backed by six citations (2,127 input / 627 output tokens). It correctly found the saved mobile-overflow failure. A separate checker confirmed every claim against the stored facts. It reports what failed; it doesn't claim anything was fixed.

Also used, not entered: ElevenLabs turns the result counts into a 23-second spoken summary (listen), but it's a synthetic demo, so I'm not entering it. None of Entire, .tech, Arduino, TabPFN, DigitalOcean or MongoDB Atlas has full evidence here either.

What It Can't Do Yet

• The public demo audits the Briefstamp homepage and one sample site, not any URL you paste in. My approval of a plan isn't the client's sign-off yet; that's the next thing to build.
• The demo video uses labelled templates. The real Gemma run is separate, dated evidence, and it wasn't clean first time: an HTTP 500 and an invalid-JSON reply came before the success, and both are kept.
• The new Tinker LoRA (24/24) served one budgeted live proposal and is off again. Its 24 test briefs were seen during development, and nobody has hand-checked its synthetic training examples.
• Hosted Temporal recovery survives a worker restart, not a Render redeploy or spin-down.
• The Mastra, Backboard, Sentry and ElevenLabs proofs are one-off runs I triggered, not features every visitor gets. I haven't listened back to check the ElevenLabs audio.
• Everything runs on free tiers and trial credits that end around October 20, so the hosted extras may switch off after judging.

Full limitations and funding details

What's Next

Watch real freelancers use it on real handoffs, and find out whether ₹499 is a price they'd pay. If you freelance and want to try it on your next delivery, reach out.

AI helped with coding, testing and drafting. Recorded approvals include automated verifier/browser actions under my authorization; independent client acceptance is not claimed.