DEV Community: Updesh .

RedactProof & Review: Zero-Cloud Contract Auditing for Freelancers

Updesh . — Mon, 19 Oct 2026 05:34:12 +0000

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

What I Built

RedactProof & Review is an offline, privacy-first desktop utility and agentic auditor designed specifically for freelance paralegals, contract specialists, and boutique agency owners.

The Problem It Solves

Freelancers and legal contractors frequently review Master Service Agreements (MSAs), Statements of Work (SOWs), and Non-Disclosure Agreements (NDAs). While commercial AI systems can summarize legal contracts quickly, uploading confidential client materials, proprietary rates, trade secrets, and personal identifiable information (PII) directly to public cloud APIs routinely breaches non-disclosure agreements, data privacy regulations (GDPR, CCPA), and professional privilege.

Who Would Pay for It

Freelance Paralegals & Legal Ops Consultants: Professionals who bill $50–$120/hr for manual first-pass contract redlining.
Agency Owners & Solo Contractors: Independent operators who lack in-house counsel and frequently sign one-sided vendor agreements without understanding the fine print.

The Value Proposition

Instead of spending 45 minutes manually hunting down predatory clauses or risking breach-of-contract penalties with cloud AI, RedactProof runs a two-tier local pipeline in under 15 seconds:

Deterministic PII Sanitization: Strips names, emails, phone numbers, tax IDs, and billing amounts locally before any semantic evaluation occurs.
Local Risk Auditing: Flags asymmetric termination terms, unlimited liability, overreaching IP forfeiture, non-competes, and late-payment windows (>30 days), producing an actionable risk scorecard with plain-English warnings.

Target pricing is positioned as a $79 one-time lifetime license or a $15/month flat subscription—cheaper than a single billable legal hour, with zero marginal token costs.

Code

Updesh413 / RedactProof

🛡️ RedactProof & Review

Zero-Cloud, Privacy-Preserving Contract Redaction & Predatory Clause Risk Scorer
Built for freelance paralegals, solo legal consultants, and boutique agencies.

🌟 Overview & Core Value Proposition

Freelancers and boutique agencies routinely sign master services agreements (MSAs) and consulting contracts that hide aggressive, one-sided terms. Sending these confidential draft agreements to public cloud LLM APIs (like OpenAI or Anthropic) introduces significant compliance liabilities and data leakage risks.

RedactProof & Review eliminates this trade-off by operating with a 100% zero-cloud, air-gapped architecture:

Stage 1 (Deterministic Redaction Engine): Scrubs all emails, phone numbers, SSNs, Employer Identification Numbers (EINs), and dollar amounts into normalized tokens ([REDACTED_EMAIL], [REDACTED_PHONE], [REDACTED_SSN], [REDACTED_EIN], [REDACTED_AMOUNT]).
Stage 2 (Local Structured Risk Audit): Passes only the scrubbed contract into a local model (llama3.2:3b) running on your own workstation via Ollama, outputting strict structured JSON via Pydantic.

🎯 Target

…

View on GitHub

How I Built It

Local Inference via Ollama (llama3.2:3b): Chosen for its lightweight 2.0 GB memory footprint and fast execution on consumer hardware (CPU or low-tier discrete GPU). Running llama3.2:3b locally allows complete offline operation without internet connectivity.
Structured Output via Pydantic: Configured using Ollama's grammar-constrained sampling (format=AuditReport.model_json_schema()). This guarantees that llama3.2:3b returns strictly structured JSON matching risk metrics, clause classifications, and citations without hallucinating invalid schema tags.
Dual-Engine Processing: Deterministic regex handles high-liability sensitive patterns (SSNs, phone numbers, currency figures) instantly to keep the context window compact and clean, freeing the model to focus purely on legal semantic reasoning.
Frontend: Built with Streamlit for a fast drag-and-drop web UI and Rich for clean terminal diagnostics.
Agent Harness & Workflow: Developed using the Antigravity CLI to scaffold, test, and package the core modules, tracked end-to-end via DevRelay.

Why Does Open Innovation Matter?

Open-source AI is the foundational feature that makes this side hustle commercially and legally viable:

Air-Gapped Privacy as a Differentiator: Closed cloud models (OpenAI, Anthropic) process sensitive text on remote servers. For enterprise and legal freelancers bound by strict client NDAs, a cloud call is often an automatic contract violation. Open-weight models running on-device provide a verifiable zero-cloud guarantee: the software works seamlessly even when Wi-Fi is physically disabled.
Zero Marginal Costs = Sustainable Flat Pricing: Closed APIs charge per-token, squeezing developer margins and forcing subscription models with usage caps. Running open-weight models locally incurs zero token expenses. Every dollar earned from a license is 100% gross profit.
Deterministic Reproducibility: Closed APIs undergo continuous backend updates and prompt-weight drift, which can abruptly break fragile extraction pipelines. Pinning a quantized local model version guarantees consistent evaluations indefinitely.

My Agent Session

RedactProof & Review: Zero-Cloud Privacy Contract Redaction & Risk-Scoring

You

Start recording this build session so we can save and embed our full transcript into our DEV submission post at the end.

Agent

Confirmed session tracking active. Verified local workspace environment and prepared DevRelay session preservation pipeline.

You

Goal: Build a zero-cloud, privacy-preserving contract redaction and risk-scoring tool called 'RedactProof & Review' for freelance paralegals and boutique agencies.

Core Constraints:
1. Use Ollama running locally on this machine with llama3.2:3b (no remote cloud LLMs).
2. Implement two-stage processing: Stage 1 deterministic regex/heuristic PII scrubber; Stage 2 structured Pydantic extraction via local Ollama.
3. Target 5 risk categories: Unilateral IP Assignment, Aggressive Non-Competes, One-Sided Indemnification/Unlimited Liability, Extended Payment Terms, Asymmetric Termination.
4. Deliverables: redact_engine.py, app.py (Streamlit), requirements.txt.
5. Synthetic test_contract.txt with 4-5 predatory clauses and sample PII. Verify end-to-end.

Agent

▸ run_command

Output

ollama list: verified llama3.2:3b present and ready on local GPU

▸ run_command

Output

pip install ollama streamlit: installed required dependencies

▸ search_dev_to_semantic

Output

Identified DEV Community Wisdom on JSON Schema field ordering for local constrained decoding

▸ write_to_file

Output

Created requirements.txt and test_contract.txt with realistic predatory clauses and PII

▸ write_to_file

Output

Created redact_engine.py with Stage 1 regex scrubber and Stage 2 Ollama Pydantic structured risk audit

▸ run_command

Output

Executed CLI audit: 13 PII items redacted; scored 8/10 Critical Risk across all 5 predatory clauses

▸ write_to_file

Output

Created app.py (Streamlit UI with side-by-side diff and risk meter) and README.md

▸ run_command

Output

Initialized git repository and committed all project deliverables

Built RedactProof & Review end-to-end. Stage 1 scrubbed 13 sensitive PII tokens (emails, phones, SSNs, EINs, amounts) with zero leakage. Stage 2 accurately flagged all 5 predatory clauses with evidence-first schema ordering, plain-English paralegal explanations, and balanced redlines.

You

remove the Export & DEV Embed section from the UI, it should not be there

Agent

▸ replace_file_content

Output

Removed Export & DEV Embed tab and section from app.py

▸ replace_file_content

Output

Updated README.md feature list

▸ run_command

Output

Recompiled app.py cleanly and committed change to git

Removed the Export & DEV Embed section from app.py. The UI now cleanly focuses on the three core tabs: Risk Scorecard, Side-by-Side Redaction Diff, and Flagged Clauses & Redlines.

You

submit_agent_session

Agent

▸ submit_agent_session

Output

Submitting sanitized, normalized session transcript to DEV via DevRelay

Submitting session to your DEV profile for native Liquid embedding in your hackathon/DEV submission post.

TrailWhisper: Offline Audio Bird & Habitat Guide

Updesh . — Sat, 10 Oct 2026 09:09:51 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

TrailWhisper is an offline bioacoustic audio guide designed to get hikers, birdwatchers, and nature walkers off their screens and into the wild.

Most nature identification apps pull you into your phone: you stop on the trail, wake the screen, open an app, snap a photo, and read long text entries. TrailWhisper turns that paradigm inside out. It runs continuously in the background on edge hardware (a phone via Termux or a laptop in your pack), capturing ambient audio buffers with an open-source acoustic classifier.

When an active bird call is detected with high confidence, TrailWhisper uses a local, quantized language model to construct a 1-sentence behavioral cue and whispers it directly into your bone-conduction headphones via offline neural TTS (e.g., "Wood Thrush — canopy left, courtship song").

Your eyes stay fixed on the canopy, your hands stay free, and total trail screen-time drops to under a minute per hike.

Code

The project source, ONNX export workflows, and mock test fixtures are open-source on GitHub:

Updesh413 / TrailWhisper

TrailWhisper 🌿🐦

TrailWhisper is a completely offline, real-time bioacoustic listener loop designed for field naturalists, birders, and edge acoustic monitoring. Running entirely locally on consumer hardware without internet connectivity or external cloud APIs, TrailWhisper continuously listens for avian vocalizations, identifies species, crafts concise behavioral cues via an on-device Small Language Model (SLM), and whispers the observation into your ear in real time.

Architecture Overview

                      +------------------------------------+
                      |   Default Audio Input (Microphone) |
                      +-----------------+------------------+
                                        |  (48,000 Hz Mono Stream)
                                        v
                      +------------------------------------+
                      |  audio_listener.py: AudioListener  |
                      |  (Thread-Safe 10s Rolling Buffer)  |
                      +-----------------+------------------+
                                        |  Latest 3s-10s Window
                                        v
                      +------------------------------------+
                      |   classifier.py: Bioacoustic ONNX  |
                      |     (BirdNET V2.4 / V2.5 ONNX)     |
                      +-----------------+------------------+
                                        |  Species & Confidence
                                        v
                            [ Confidence > 0.75 ? ]
                                   /          \
                            No    /            \  Yes
                                 v              v
                           (Continue)   +------------------------------------+
                                        | cue_generator.py: SmolLM2-1.7B GGUF|
                                        |  (Strict 1-sentence, < 12 words)   |
                                        +-----------------+------------------+
                                                          |  Synthesized Cue Text
                                                          v
                                        +------------------------------------+
                                        |    tts_player.py:

…

View on GitHub

How I Built It

TrailWhisper runs entirely without internet access using a lightweight pipeline built on open-weight models and local runtimes:

Audio Perception: A converted BirdNET bioacoustic classification model compiled to ONNX Runtime, processing rolling 10-second mel-spectrogram buffers via sounddevice with minimal CPU overhead.
Context & Whisper Generation: SmolLM2-1.7B-Instruct (Q4_K_M) orchestrated locally via llama-cpp-python. It takes the detected species, rough time of day, and season to produce a concise 8-to-12 word natural-language cue describing location and song type.
Audio Synthesis: Piper TTS, an open-source neural text-to-speech engine running directly on the CPU, converting text to audio in under 80 milliseconds.
Agent Scaffold: Built with Python asyncio to decouple the continuous audio ingest loop from inference and speech output.

Why Does Open Innovation Matter?

Building for the outdoors exposes the immediate failure modes of closed-source, cloud-dependent AI:

True Offline Autonomy: Deep ravines, state parks, and mountain trails routinely have zero cellular service. Proprietary APIs fail the moment you lose signal; open weights run 100% locally on device.
Real-Time Latency: Cloud API round trips add multiple seconds of network delay. By the time a cloud service transcribes, routes, and answers, the bird has flown away. Local inference achieves sub-second detection-to-ear latency.
Zero Cost & Zero Data Leakage: Leaving a streaming cloud audio pipeline running over a 4-hour hike would rack up massive API fees and drain device batteries via constant 5G radio broadcast. TrailWhisper runs on an airplane-mode device for $0.00 forever, with no environmental audio ever leaving local memory.

My Agent Session

I built and scaffolded TrailWhisper using the Antigravity CLI and tracked the implementation, quantization checks, and dry-run tests with DevRelay:

TrailWhisper: Offline Bioacoustic Bird Listener Loop

You

Build a complete, standalone Python project called "trailwhisper" that runs an offline bioacoustic bird listener loop using open-source tools.

Agent

▸ run_command

Output

sounddevice, onnxruntime, piper-tts installed; test suite executed

Implemented TrailWhisper with clean architecture (src/, models/, tests/, logs/), rolling 10-second audio buffer with sounddevice, ONNX bioacoustic classifier, SmolLM2-1.7B whisper cue generator (<12 words), and Piper TTS offline audio player. Added dry-run/mock mode and 16 unit tests.

FocusFriend: A Voice-First ADHD & Dyslexia Study Companion

Updesh . — Sun, 04 Oct 2026 19:24:34 +0000

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

What I Built

I built FocusFriend, an offline-first, voice-guided study companion designed specifically for my college roommate, Rohan.

Rohan deals with severe ADHD and dyslexia. Whenever exam season arrives, he hits a wall of cognitive fatigue trying to digest dense technical PDFs, lecture slides, and textbook chapters. Reading massive blocks of black-and-white text triggers immediate attention burnout.

FocusFriend flips the script by turning complex study material into conversational, bite-sized spoken lessons. Instead of forcing him to stare at walls of text:

It ingests dense academic PDFs and documentation.
It breaks the concepts down into 2-minute, highly relatable analogies.
It speaks the content aloud using natural, human-like voice synthesis.
It conducts quick, interactive single-question voice checks to keep him actively engaged without overwhelming his working memory.

When I showed it to Rohan with a chapter of Operating Systems notes, his exact words were: "This feels like someone actually explaining the concept to me over coffee instead of my brain fighting the textbook."

Demo

Live Streamlit App: Try FocusFriend Here

Code

Check out the full open-source implementation and instructions to run it locally on GitHub:

Updesh413 / FocusFriend

🧠 FocusFriend: A Voice-First ADHD & Dyslexia Study Companion

Built for the Hacktoberfest "Build for a Friend" Challenge. Designed to eliminate text-fatigue and cognitive overload for students with ADHD and dyslexia by transforming monolithic technical materials into 2-minute analogies and natural spoken audio.

🌟 Key Features

Chunked 2-Minute Cognitive Explanations: Ingests dense PDFs, Markdown, and TXT files, breaking them into bite-sized sections.
ADHD-Tailored System Prompts
- 🚀 The Big Picture (30-second hook): Why the concept matters in engineering/real life.
- 🧩 Everyday Analogies: Concrete metaphors that demystify abstract mechanics.
- ⚡ Bite-Sized Core Breakdown: 3-4 bullet points maximum with bold terms.
- 🎯 1-Question Active Recall: Immediate interactive comprehension check with a collapsible answer.
ElevenLabs Voice Integration
- Warm, calm, and encouraging voice personas (Rachel, Drew, Clyde, Mimi, George).
- Voice stability and clarity tuning.
- Local SHA-256 Audio Caching: Caches synthesized speech under .cache/audio/ to avoid redundant…

View on GitHub

How I Built It

FocusFriend is designed to run locally with low latency on standard consumer hardware (tested on an AMD Ryzen 9 5900HX laptop with an NVIDIA RTX 3060 6 GB GPU).

Open-Source AI Core: Powered locally by Ollama running Meta's llama3.2:3b. At 4-bit quantization, the model consumes only ~2.2 GB of VRAM, running at a blistering 70+ tokens per second directly on the RTX 3060 without touching CPU offloading.
Intelligent Prompt Chunker: Instead of raw summarization, custom prompts translate dense jargon into real-world analogies structured for active recall and ADHD learning patterns.
Document Extraction: Uses pypdf for fast, local, zero-leak text parsing from uploaded course materials.
Audio Synthesis: Integrated the ElevenLabs Python SDK (elevenlabs) to stream warm, calm, human-like speech with virtually zero stutter.
User Interface: Built a clean, focused dashboard with Streamlit, featuring instant section chunking, audio stream playback, and a quick-recall quiz panel.

Why Does Open Innovation Matter?

Open innovation is the backbone of this project:

Student Data Privacy: Course syllabi, unpublished research notes, and personal study files stay entirely on the local machine. Sensitive documents never pass through proprietary training pipelines or closed third-party servers.
Zero Recurring Marginal Cost: A student studying 6 hours a day would blow through cloud token budgets and pay-per-query limits. By utilizing open-weight models (llama3.2:3b), Rohan gets infinite conversational turns and quizzes completely free.
Offline Reliability: Whether studying in a spotty campus basement library or on an airplane, the entire intelligence layer runs 100% locally with zero internet dependency (with fallback audio synthesis options).
Predictable Hardware Fit: Open weights allow precise quantization control (Q4_K_M), letting us guarantee that the model sits neatly inside a 6 GB VRAM budget alongside everyday apps.

My Agent Session

I used the Antigravity CLI agent harness to scaffold, tune the local Ollama integration, and verify the ElevenLabs audio pipeline. The session was captured and tracked using DevRelay:

FocusFriend - Build Session (Hacktoberfest MVP)

You

Start tracking this build session using the DevRelay integration. Keep track of the session ID so we can export it at the end.

Agent

Session tracking initialized. DevRelay session ID 475 assigned.

You

Act as a Principal Full-Stack AI Engineer. Build an end-to-end working MVP for the Hacktoberfest "Build for a Friend" challenge called: "FocusFriend: A Voice-First ADHD & Dyslexia Study Companion"

Agent

Engineered the complete FocusFriend MVP with Ollama local LLM, ElevenLabs voice integration, document ingestion, and test suite.

You

from the UI remove hardware details and also put the env in gitignore so that keys are not pushed to github

Agent

Created .gitignore strictly ignoring .env, .env.*, .venv/, .cache/ audio artifacts, and pycache/.
Verified with git check-ignore that .env is actively ignored.
Updated app.py: Removed hardware specs (Host CPU, GPU name, VRAM stats, temps) from the sidebar and generation progress messages, replacing it with a clean 'AI Engine Status' indicator.
Ran verification test: Ollama daemon and llama3.2:3b responded with a complete local inference in 9.95s.

Prize Categories

Best Use of ElevenLabs