DEV Community: Zhuoli Liang

Lease Buddy: a private lease checker for a friend, with Gemma running on their own laptop

Zhuoli Liang — Sat, 03 Oct 2026 09:45:09 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built this for a friend who is about to sign a 12-month apartment lease: pages of dense legal English, plus an addendum. I can read it with them once, but I won't be there for the next lease, or the renewal letter. And a lease is exactly the kind of document you shouldn't paste into a random website: name, address, rent, signature.

So I built them Lease Buddy: paste a lease (or open a .txt / .pdf), and it gives you:

The short version: rent, due date, late fee, deposit, start and end dates, notice periods, early-termination cost. Every item cites its clause (§3, §13…).
Clauses that contradict each other. This is the part I care about most. In real leases the scary stuff usually isn't hidden; it's scattered. One clause says you need 60 days' notice to avoid auto-renewal, another says 30 days to vacate, and an addendum quietly moves the late-rent cutoff from the 5th to the 3rd.
Dates you can't miss, computed rather than guessed, with a .ics export and 7-day reminders. When two clauses disagree, it uses the earlier (safer) date and shows both.
Questions to send the landlord: each flag (auto-renewal, non-refundable fees, "reasonable notice" with no number, "tenant pays any repair under $250 regardless of cause", one-sided attorney fees) becomes a copy-paste question rather than legal advice.
Ask Gemma. "Can my landlord come in whenever they want?" or "Explain §13 in plain words." Gemma runs in the browser tab or on your own computer, never on a server.

Demo

Live: https://lease-buddy-gemma.vercel.app. Click "Try the sample lease" (a fictional lease with three contradictions planted on purpose). The rule checks are instant and need no model. Then hit Start Gemma to ask questions.

Here's Gemma 4 (E2B, via Ollama on my dev box) answering the question that matters most in this lease. The yellow line comes from the rule checker, not the model. The green line is the code verifying Gemma's answer:

Code

Zhuoli / lease-buddy

Read your lease like a friend who has read a lot of leases. Finds contradictory clauses + key dates; Gemma explains them on your own device.

🏠 Lease Buddy

Read your lease like a friend who has read a lot of leases. Paste a lease (or open a .txt/.pdf). Lease Buddy finds the money, the dates, and the clauses that contradict each other. Then Gemma, running on your own device, explains them in plain words.

Live: https://lease-buddy-gemma.vercel.app · Built for the DEV Hacktoberfest 2026 Weekend Challenge ("Build for a Friend").

Not legal advice. Lease Buddy points at things to ask about. A local tenant-rights group or a lawyer can tell you what the law says where you live.

Why

I built this for a friend who is about to sign a 12-month lease written in dense legal English. The scary parts of a lease are rarely hidden. They're scattered: the renewal clause says one notice period, the "notice to vacate" clause says another, and an addendum quietly changes when rent counts as late…

View on GitHub

Plain HTML + ES modules, no build step, no backend, no API keys. Apache-2.0. npm test runs 25 unit tests (clause splitting, fact extraction, contradiction detection, date math, retrieval, the answer verifier, .ics).

How I Built It

I built it this weekend with an AI coding agent doing a lot of the typing, while I made the calls on scope, tests and the parts below.

The split that made it work: code finds the facts, Gemma explains them.

Deterministic layer (src/lease.js): splits the lease into clauses (including addendum ids like A2), reads number words ("sixty (60) days"), and pulls out typed facts like end_of_term_notice = 60 days @ §13. If two clauses give different values for the same thing, that's a contradiction. Dates are plain date math in UTC.
Retrieval: a tiny BM25 over clauses, plus a few tenant-language synonyms ("moving out" → vacate / non-renewal). It's contradiction-aware: if a retrieved clause is part of a contradiction, the clause that contradicts it gets pulled in too.
Gemma only sees those clauses, plus a note from the checker listing the contradiction, and is told to cite [§x] after each fact.
Verifier: every number in Gemma's answer must appear in a clause it was shown (and in the clause cited in that sentence), every [§x] must be real, and if a contradiction is in play, both sides must be mentioned. Otherwise the answer gets a ⚠️ that says exactly what's off.

Two ways to run Gemma, both on hardware you control:

In the browser: gemma-3-1b-it (ONNX) via Transformers.js in a Web Worker. WebGPU (q4f16, or q4 when the GPU lacks fp16 shaders) with a CPU/WASM fallback (int8). About a 0.8–1 GB one-time download, then cached.
Ollama on your computer: ollama pull gemma4:e2b, allow the site's origin with OLLAMA_ORIGINS, and the page streams from localhost:11434.

I measured it instead of eyeballing it. npm run gemma:check runs the real prompts against the sample lease and saves every answer to results/ (all on CPU):

Model	Q&A answers passing the checker	Clause explanations passing	Same 3 contradiction questions without the checker's hint
Gemma 4 E2B (Ollama)	7/7	3/3	2/3
Gemma 3 1B (the in-browser model)	5/7	2/3	1/3

Three things I learned:

Small models answer from one clause. Without the hint, Gemma 4 answered "how much notice before moving out?" with "at least thirty (30) days' written notice [§14]". That's true, but it skipped §13's 60-day non-renewal deadline, which is the one that locks you into another year. The system prompt already said "if two clauses disagree, say so and cite both", and that wasn't enough. When the checker's note naming the specific contradiction was added, it cited both.
The verifier earns its keep on the 1B model. It caught Gemma 3 1B citing numbers to the wrong clause ("thirty days … [§13]"), inventing a clause id (§A9), and turning "sixty (60) days" into "six months".
It can't check meaning, and I'd rather say so. 1B once said "the lease doesn't allow you to bring a cat" when the clause says pets need written consent. That's why each answer shows the exact clauses Gemma saw, why the summary, contradictions and dates come from code, and why the app labels the 1B option "small, sometimes cites the wrong clause" and recommends Gemma 4 for answers.

Also: the first in-browser run crashed with "Program Sub requires f16 but the device does not support it". Lots of GPUs don't expose shader-f16, so the worker now checks the adapter, picks q4 instead of q4f16, runs a 2-token smoke test, and falls back to the CPU if the GPU path still fails.

Why Does Open Innovation Matter?

Because of what a lease is: legal name, address, rent, sometimes income and a signature. Uploading that to someone else's server to get it explained is exactly the wrong move. With an open-weight model:

The document never leaves the device. The site is static files on Vercel. Gemma runs in the tab (Transformers.js) or on your own machine (Ollama). There's no server I could log to, even by accident.
It costs nothing to run, for my friend or for me. No API key, no per-token bill, no account.
I could pick the model size to match the job. A 1B model that loads in a browser for a quick private look, or Gemma 4 E2B on a laptop when you want answers you can lean on. The same prompts and the same verifier work for both, and I could measure both.
The open stack let me fix the hard part. Swapping models, reading their failure modes in results/, and adding a verifier around them is how the "answers from one clause" problem got solved. A closed API would have given me a nicer-sounding answer with the same blind spot.

Not legal advice: Lease Buddy tells you what to ask. For what the law says where you live, a local tenant-rights group is the right call. Next step: going through my friend's real lease with them.

Prize Categories

Best Use of Gemma: Gemma 3 1B runs fully in the browser via Transformers.js (WebGPU/WASM), and Gemma 4 E2B runs locally through Ollama. Both are wrapped in contradiction-aware retrieval and a code verifier, with a measured comparison in the repo.

Fine Print: an agent that knows when the FAQ and the Official Rules disagree

Zhuoli Liang — Sat, 03 Oct 2026 07:51:06 +0000

This is a submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content

What I Built

Fine Print reads contest rules so you don't miss the clause that disqualifies you.

I enter a lot of hackathons and bounties. The rules for one contest are never on one page. There's a landing page, an FAQ, a contest-rules page, and the platform's general Official Rules, and they drift apart. This very challenge is a good example. Its own pages disagree in ways that matter:

When does the winner paperwork clock start? The FAQ gives you 7 business days "following the date of your first email notification". The MLH Official Rules say "following the date of first attempted notification", and add: "Failure to comply with these deadlines may result in forfeiture of the prize." Under the Official Rules, an email sitting in your spam folder has already started the clock. And the Official Rules govern: "In the event of a conflict between these Official Rules and the applicable Contest Announcement Page, the Official Rules will govern and control."
Who is "Sponsor"? The landing page says "Sponsored by Sanity". The contest-rules page says "Sponsored by Major League Hacking PBC Inc ("Sponsor")". The employee exclusion is written against Sponsor. Can a Sanity employee enter? The rules don't say. Fine Print says exactly that and tells you to ask, instead of guessing.
Can I reuse a project? The FAQ says riffing on prior work is encouraged. The Official Rules require that "development of your Entry was started during, and not prior to, the Entry Period".
"Submissions due: October 04, 2026" is 2:59 PM on October 5 in Beijing.

Tell Fine Print who you are (country, time zone, age, employer, whether you use AI, whether an agent submits for you). Then ask a plain question. The offline results include clause IDs and a tool trace with source quotes and URLs. Model-generated citation correctness is not yet automatically verified.

The local snapshot covers three contests: this one, the DEV Kaggle Benchmarking Challenge, and a Superteam Earn bounty (which turns out to be HUMAN_ONLY, so an agent can draft for you but not submit).

Demo

Live app: https://fine-print-opal.vercel.app
Shareable demo questions:
Studio: https://fine-print.sanity.studio/ (sign-in required; the ⚠️ Open conflicts desk item is the review queue)

Code

https://github.com/Zhuoli/fine-print

Clone it and run npm install && npm run seed:build && npm run dev. It works with no accounts at all: GROQ runs locally via groq-js over the same seed, the Context tools fall back to same-named local shims, and with no LLM key a deterministic planner calls the same tools.

How I Used Sanity

The content model is the product. Rules are prose, but what an entrant needs is computation: comparing instants, ranking sources, checking a country against a list. So every rule lives in Sanity twice: once verbatim (for citation), once normalized (for code).

ruleSource: a page, its kind (officialRules / contestRules / landingPage / listing), a precedenceRank, and the exact sentence that establishes precedence.
clause: a topic, a verbatim quote, a normalized JSON value ({"minAge":18}, {"instant":"2026-10-05T06:59:00Z"}, {"excludedCountries":[…]}), a reference to its source, and contests[]. One clause in the shared MLH Official Rules binds every DEV contest, so I fix it once.
conflict: two or more claims[] (references to clauses) side by side, status, winningClaim, resolvedBy (precedence / precision / needsHuman), and a rationale.
contest: the close instant and the close as written, the source time zone, tracks with winners per path, and a payout timeline (business-day windows with their anchors).
organizer: legal sponsor vs. brand sponsor, because "Sponsor" in the rules isn't the logo on the page.

In the Studio, the first item in the desk structure is ⚠️ Open conflicts, a review queue of contradictions nobody has decided yet.

Sanity Context: one endpoint over the full dataset (no Knowledge Base).

The live app is wired to the project-level Sanity Context MCP endpoint for the whole production dataset, in GROQ mode with dataset embeddings enabled:
https://api.sanity.io/v2026-03-03/context/mcp/9wt4tu94/production?embeddings=true.
The server connects to it with a read-only Viewer token kept in a server-side environment variable. tools/list returns initial_context, groq_query, schema_explorer, and array_field_reader. Embeddings cover { title, name, topic, quote, note, rationale, closesAsWritten }. So semantic ranking works through the MCP: *[_type=="clause"] | score(text::semanticSimilarity("when is the prize money paid")) ranks clause.sanity.prize.rules, clause.tg.payout, and clause.official.notify first. With an LLM configured, the agent gets the schema overview from initial_context and uses groq_query to follow references. A typical call is one contest, its sources ordered by precedence, every clause that references() it, and every conflict with its claims dereferenced.

About Knowledge Bases, honestly: the Knowledge Bases option isn't shown in the dashboard for my Free-plan project, so I couldn't build one. The challenge page says: "Knowledge Bases are in beta and currently index up to 150 documents. Design for that budget, or point your agent at your full dataset through a Context MCP endpoint with embeddings enabled. Both count for Path One." Fine Print takes the second option. kb/knowledge-base.md holds the KB setup (dataset query, website sources, file bundle, standing instructions) that I'd apply once access is available. The app has a knowledge_base_read slot that currently falls back to a local shim over the verbatim snapshots in /sources.

What the public demo actually runs: the deployment has no paid LLM key. So the live demo uses the deterministic planner. It calls the same tools, and they run GROQ directly against the live Content Lake (9wt4tu94/production). The Context MCP is configured and verified, but the planner doesn't call the MCP tools itself. Add ANTHROPIC_API_KEY or OPENAI_API_KEY and the model plans over the MCP tools instead.

What the agent does with it. The model is never allowed to do date math or eligibility logic in its head. It calls five deterministic tools: check_deadline, check_eligibility, cash_timeline, submission_checklist, and source_conflicts. Each runs GROQ against Sanity and returns verdicts carrying clause ids. The system prompt requires a [clause.*] citation on every factual sentence, and requires the agent to say "the rules don't settle this" whenever a conflict is open.

A keyword search would return "October 04" and "seven (7) business days". Answering "I'm in Beijing, when must I submit, and if I win, when is my W-9 due and when does the money arrive?" takes the instant, the zone, the precedence ranks, and the anchored business-day windows. Fine Print converts the submission instant to Beijing time, but refuses to invent a cash date: winner selection is not recorded, paperwork is due 7 business days after first attempted notification, and delivery depends on acknowledged acceptance of completed paperwork.

Conflicts are modeled by hand (no KB build)

Without a Knowledge Base build, there are no machine-raised Issues to compare. The five conflict documents in the dataset are modeled by hand, each with side-by-side claims, a winning claim, and a rationale. Comparing them with a KB build's Issues is the first thing I'd do once access is available.

Honest limitations

The seed is curated: three contests and about 30 clauses. Extracting clauses from a new rules page is still a manual (AI-assisted) step. The next step is a Sanity Function that drafts clause documents from a new ruleSource for a human to approve.
Business-day math skips weekends but not public holidays.
The Kaggle challenge's landing page gives a date with no time. Fine Print says the time is unknown instead of assuming 11:59 PM PDT.
This isn't legal advice. Where the rules are silent, the agent says so.

Sanity Project Details

Project ID: 9wt4tu94
Dataset: production (60 documents, imported from seed/production.ndjson)
Studio: https://fine-print.sanity.studio/
Context MCP: https://api.sanity.io/v2026-03-03/context/mcp/9wt4tu94/production?embeddings=true (dataset embeddings enabled; needs a read token)
The dataset's visibility is public, but document IDs are dotted (clause.official.clock), and Sanity doesn't serve those to anonymous queries. So the app reads with a server-side Viewer token. To browse without an account, use npm run seed:build and read seed/production.ndjson, which is the exact imported content.

Reproducible offline evidence

Run npm test with no credentials. It checks deadline boundaries, unknown eligibility, request validation, payout-anchor uncertainty, seed references, and a counterfactual: keeping the quoted prose unchanged while changing the normalized minimum age changes the verdict. This demonstrates dependence on structured facts, but is not evidence of a live Context call. npm run check:mcp checks the live Context endpoint.

Agent Session

I built this with an AI coding agent. I wrote the brief and the content model decisions, and checked every quoted clause against the source pages. The agent wrote most of the code.