I Built a Local AI That Stops Freelancers Doing Free Work!

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

What I Built

ScopeGuard is a scope-creep guard for freelancers. It reads your signed agreement and a client's message, and tells you what you're about to do for free.

Every freelancer knows the message: "Looks great! Could you also add a mobile version, and one more round on the colours?" Saying yes is easier than digging out the contract, so the unbilled hours pile up.

You paste the client's message, and ScopeGuard splits it into separate requests and marks each one:

• Covered: the agreement includes it.
• Excluded: the agreement rules it out or limits it, with the clause quoted and highlighted in your contract.
• Not covered: nothing in the agreement mentions it.

For anything billable it shows an hours range, a price at your hourly rate, and a draft change order to send. You then quote each item or waive it as goodwill, and a ledger tracks both and exports to CSV for your invoice.

Who would pay for it: solo designers, developers, writers and photographers who bill by the hour or by the project. One caught afternoon of unbilled work pays for a tool like this, and it costs nothing to run per message.

Demo

The video walks through a sample client, Jay Creationz, with a contract and a message that asks for a third revision round, a mobile app and a smaller logo.

Code

JayanaGunaweera01 / scope-guard

I Built a Local AI That Stops Freelancers Doing Free Work!

ScopeGuard

A scope-creep guard for freelancers. It reads your signed agreement and your client's message with an open model on your own laptop, shows what you are about to do for free, and drafts the change order.

Watch the demo: https://youtu.be/MQqcnGHszRc

A client writes "great! Could you also make it work on mobile, and one more round on the colours?" and you say yes because checking the contract is tedious and the ask feels small. Over a project that is hours of unbilled work ScopeGuard checks every message in seconds.

1. Add a client: paste the agreement, set your rate and a goodwill threshold.
2. Paste the client's message.
3. Get, per request: covered, excluded (with the clause quoted and highlighted in your contract), or not covered, with an hours range, a price, and a draft reply.
4. Quote it or Waive it as goodwill. The ledger shows what you quoted…

View on GitHub

How I Built It

• Model: an open-weight Gemma 4 model (gemma4:e4b by default) served locally by Ollama. The model is one environment variable, so any Ollama model that supports JSON schema output can replace it.
• Constrained output: each call passes a JSON Schema to Ollama's format option, so decoding is constrained and the reply always parses.
• App: a small FastAPI app bound to 127.0.0.1, with records in one readable JSON file. The only network call is to local Ollama.

The core idea is the model proposes, plain Python decides. A chatbot can invent a clause or botch the maths, and either would cost a freelancer money. So core.py enforces these rules, and the 14 tests cover them:

• A clause must be real. Every "covered" or "excluded" verdict has to quote the contract, and code searches for that quote in your text, ignoring case, punctuation and line breaks. If it isn't there, the verdict is downgraded to "needs you" and the fake quote is discarded.
• Silence is not exclusion. If no clause speaks to a request, it's shown as "not covered", never as "the contract forbids it".
• The model never writes a number. Hours are its estimate, shown as a range. Prices are hours × your rate, computed in code, and an opening line containing a digit is replaced.
• Small asks stay human. Billable requests under your goodwill threshold are flagged so you can be generous on purpose, and waiving is recorded.

The reply to the client is assembled only from verified parts.

Why Does Open Innovation Matter?

• Privacy is the product. Agreements are often under NDA, and client emails contain their plans and budgets. A freelancer can't paste those into a hosted API and stay within their own contracts. With an open model on the laptop, nothing is uploaded.
• The economics only work at zero marginal cost. The point is to check every message, including the small ones where creep hides. With per-token pricing people ration usage and miss the ten-minute asks that add up. Locally it's free after the download.
• A small model is enough. Schema-constrained decoding plus code verification means a model in the 4B class can be trusted on this task, where a bigger unverified one could not.
• No lock-in. A pricing change or deprecation at a hosted vendor can't break a tool people use to get paid.
• Room to specialise. Clause language differs by trade (photography licences, retainers, SaaS SLAs). Open weights can be tuned on exactly that, while a general API treats every contract alike.

Prize Categories

• Best Use of Gemma. Gemma 4 (E4B, with E2B as a fallback) runs locally through Ollama