DEV Community: Anthony

Founder Signal: A Local, Evidence-Backed Commitment Ledger for Founders

Anthony — Mon, 26 Oct 2026 05:08:47 +0000

This article is submitted for the **Hacktoberfest Open-Source AI Challenge: Week 3 (Slow and Steady).

Target Categories: **Overall Winner, **Best Use of Gemma, **Best Use of MongoDB Atlas.

1. The Real-World "Sloth" Problem: Commitment Drift

October 20 was International Sloth Day. Sloths understand something fundamental about energy conservation: they move at their own pace, avoid wasted motion, and let the world come to them.

Early-stage founders, on the other hand, do the exact opposite. We drown in operational motion. Every day brings a barrage of accelerator emails, co-founder syncs, investor requests, and forwarded meeting notes:

"I'll send the updated pitch deck by Friday morning."
"We should review the contractor's contract on Tuesday."
"Sarah mentioned she needs the revised financial projections by Monday at 2 PM."

Three days later, a follow-up email moves the deadline from Friday to Monday. Another message asks if anyone followed up on the investor introductions.

Without automation, staying on top of this is an exhausting cognitive tax. Founders end up constantly rereading email threads, copying fragmented tasks into todo apps, manually checking dates, and worrying that a promised deliverable slipped through the cracks.

Founder Signal fixes that by automating the tracking overhead completely. You channel your inner sloth: the system quietly ingests your inbound communications, extracts promises and deadlines, reconciles changes against your ledger, and delivers a tiny, high-conviction morning briefing.

The agent proposes; you confirm. You only expend energy when a real decision is required.

2. What I Built: Founder Signal

Founder Signal is a local-first, evidence-backed commitment extraction and reconciliation ledger designed specifically for founders.

Unlike typical chatbots or simple summarizers that produce vague bullet points, Founder Signal anchors every extracted commitment to verbatim source text and reconciles new information against existing promises.

journey
    title The Founder Experience with Founder Signal
    section 1. Passive Intake
      Receive accelerator update or meeting note: 5: Founder
      Heartbeat or folder watcher detects file: 5: Founder Signal (Himalaya)
    section 2. Evidence-Backed Extraction
      Extract promises, owners, and deadlines: 5: Founder Signal (Gemma)
      Anchor each commitment to verbatim source quote: 5: Founder Signal
    section 3. Deterministic Reconciliation
      Detect moved deadline (Friday -> Monday): 5: Founder Signal (Reconciler)
      Propose ledger update without silent overrides: 5: Founder Signal
    section 4. The Lazy Payoff
      Review 4-lane Morning Cockpit Briefing: 5: Founder
      1-tap confirm or dismiss: 5: Founder

The 4-Stage Pipeline:

Passive Ingestion:
- Drops incoming email text, voice-note audio (.mp3, .wav), or meeting transcripts into a local inbox folder.
- An automated background heartbeat pulls new emails directly from configured email accounts (e.g., Zoho, Gmail) via the CLI.
Deterministic & Open-Weight Extraction:
- Parses commitments, owners, due dates, decisions, and follow-ups.
- Every single commitment is anchored to verbatim evidence quotes.
Smart Reconciliation (The Real Differentiator):
- If an email moves a deadline from Friday to Monday, Founder Signal identifies the existing commitment, flags the change, and stages the update.
- Retains both source quotes so the founder always knows why a date shifted.
The Cockpit Briefing:
- Synthesizes the ledger into four crisp priority lanes:
  - ⚡ Do Now: High-priority obligations due today or overdue.
  - 🗓️ Coming Up: Upcoming deliverables scheduled within the next 7 days.
  - ⏳ Waiting On Someone: Promises made by external counterparties (co-founders, investors, contractors).
  - 🔍 Needs Clarification: Commitments missing explicit assignees or concrete deadlines.

3. Architecture & Tech Stack

Founder Signal was engineered with privacy, reliability, and modularity at its core.

graph TD
    Sources[Inbound Sources: Email, Voice Notes, Transcripts] --> Watcher[Inbox Watcher & Heartbeat Service]
    Watcher --> Extractor{Extractor Engine}

    subgraph AI Inference Layer
        Extractor -->|Local-First Open-Weight| Gemma[Google Gemma via Ollama]
        Extractor -.->|Offline Fallback| RuleEngine[Deterministic Regex/Rule Extractor]
    end

    Extractor --> Reconciler[Commitment Reconciliation Engine]
    Reconciler --> Ledger[(Ledger Backend)]

    subgraph Data Layer
        Ledger --> Mongo[(MongoDB Atlas Cloud Cluster)]
        Ledger -.-> SQLite[(Local SQLite zero-config)]
    end

    Ledger --> Web[Editorial Cockpit Dashboard]
    Ledger --> Hermes[Hermes Agent Skill Endpoint]

Stack Highlights:

Core LLM: Gemma open-weight model (gemma4:e2b-it-qat) running locally via Ollama. No sensitive pitch decks or private investor correspondence ever leave the founder's machine.
Ledger Storage: MongoDB Atlas (pymongo) for durable, scalable cloud storage of sources, extracted commitments, and reconciliation audit trails, with an offline SQLite fallback.
Email Ingestion: Native integration with the Himalaya CLI and Linux systemd user service running a reliable 15-minute background heartbeat.
Web Interface: Lightweight editorial cockpit UI rendered with Flask, featuring a high-contrast attention-first layout in warm ivory, spruce teal, and amber.
Hermes Agent Integration: Exposes a standard Hermes-compatible skill protocol (GET /skills/founder-signal/manifest and POST /skills/founder-signal/invoke).

4. The Lazy Payoff: Time & Effort Saved

How much time does this actually save?

Weekly Activity	Manual Status Quo	With Founder Signal	Effort Saved
Rereading email threads for deliverables	10–20 mins/wk	0 mins (automated)	10–20 mins/wk
Copying tasks & dates into notes/todo apps	5–10 mins/wk	0 mins (automated)	5–10 mins/wk
Spotting moved deadlines & resolving conflicts	5–15 mins/wk	1 min (review proposals)	4–14 mins/wk
Preparing daily priorities & follow-ups	5–10 mins/wk	1 min (scan Cockpit brief)	4–9 mins/wk
Total Cognitive Overhead	~25–55 minutes/wk	~2 minutes/wk	~23–53 minutes/wk

Estimated time saved: 25–55 minutes per week of tedious administrative chore time. More importantly, it completely eliminates the low-level anxiety of wondering "Did I forget something I promised in that email thread on Thursday?"

5. Live Demo & How to Run It

To make testing instant and completely safe for hackathon judges and readers, Founder Signal includes an automated demo script that runs in an isolated temporary database (never touching your local data), executing the full ingest → extract → reconcile → brief → voice note → Hermes agent flow in seconds:

git clone https://github.com/AnthonyASBaptiste/founder-signal.git
cd founder-signal
pip install -r requirements.txt
cp .env.example .env

# Standard offline demo (isolated temp DB, rules engine)
FOUNDER_NAME=Anthony bash demo/demo.sh

# Or run with local Gemma open-weight LLM inference:
bash demo/demo.sh --gemma

# Or run with MongoDB Atlas cloud ledger:
bash demo/demo.sh --mongodb

What the demo script executes:

Initial Ingestion: Ingests an authentic accelerator update email (demo/samples/accelerator-update.txt), extracting commitments with verbatim evidence into an isolated temporary database.
Reconciliation & Deadline Drift: Ingests a schedule adjustment (demo/samples/schedule-change.txt), demonstrating how reconciliation detects Sarah's deck deadline moving from Friday to Monday and stages a proposed update.
Commitment Confirmation: Applies the proposed change with --apply and outputs the updated morning cockpit briefing.
Local Voice Transcription: Ingests voice note audio or transcript notes (demo/samples/voice-memo-investor-sync.txt), converting verbal promises into ledger records.
Live Hermes Agent Skill Invocation: Starts the background Hermes skill HTTP server, tests GET /skills/founder-signal/manifest and invokes POST /skills/founder-signal/invoke to produce a JSON morning briefing directly consumable by autonomous agents.

👉 Source Code: github.com/AnthonyASBaptiste/founder-signal

6. Why Open Innovation Matters

For a founder or executive, privacy and confidentiality are non-negotiable.

A commitment ledger contains the lifeblood of a startup: unannounced product launch targets, runway discussions, confidential investor introductions, contract disputes, and sensitive customer commitments. Uploading this continuously to proprietary commercial cloud AI models introduces serious data sovereignty and privacy risks.

Open innovation provides the ideal architecture:

Zero Data Egress: Using open-weight models like Google Gemma running locally, all document parsing and semantic reasoning happen in local RAM. Not a single token is transmitted off-device.
Cost Predictability: Offline inference costs $0/month. There are no surprise monthly API bills, token limits, or sudden tier changes.
Auditable & Resilient: The deterministic rule fallback guarantees that even if an AI service is unavailable or an API key expires, the core ledger extraction and reconciliation continue functioning seamlessly.

7. Prize Categories Entered

[x] Theme: Slow and Steady — Rewards laziness by automating commitment capture and date reconciliation so founders can conserve energy and focus purely on high-leverage execution.
[x] Best Use of Gemma — Uses Google's open-weight Gemma (gemma4:e2b-it-qat) via Ollama as the local-first intelligence layer, achieving fast, private, and deterministic JSON extraction without data leaks.
[x] Best Use of MongoDB Atlas — Uses MongoDB Atlas as the production multi-collection ledger (sources, commitments), providing high-availability cloud storage, flexible schema handling for evolving metadata, and sub-millisecond query indexing.

TenderLens: Turning WhatsApp & Gemma into an Autonomous Bid Assistant for Contractors

Anthony — Mon, 19 Oct 2026 02:33:20 +0000

This article is submitted for the **Hacktoberfest Open-Source AI Challenge: Week 2 (Side Hustle).

Target Categories: **Overall Winner, **Best Use of Render, **Best Use of Gemma, **Best Use of Temporal.

1. The Real-World Side Hustle Problem

In Trinidad & Tobago (and throughout the Commonwealth Caribbean), billions of dollars in state contracts are awarded annually under public procurement laws. Small and medium contractors—plumbers, HVAC technicians, electrical contractors, janitorial services—desperately want these jobs.

Yet, over 60% of bids from small contractors get disqualified before technical evaluation begins.

Why? Not because their prices or craft are inadequate, but because of administrative bureaucracy and silent lead-time traps:

The Starting Point is Paper, Not Portals: Contractors don't browse clean procurement APIs. They spot a tender notice printed in the Sunday Guardian, Express, or Newsday newspaper, or see a screenshot forwarded in an industry WhatsApp group.
The 10-Day Statutory Bottleneck: In Trinidad & Tobago, obtaining a Board of Inland Revenue (BIR) Tax Clearance Certificate or VAT Clearance takes 5 to 10 business days. A National Insurance Board (NIS) compliance certificate takes 3 to 5 business days. If a contractor starts gathering documents in the final week before closing, they have already lost.
The Hidden Logistics Clauses: State agencies (like WASA or UDeCOTT) routinely require bidders to attend a mandatory site visit—but require registering representative names and ID numbers at least two (2) business days in advance. Miss that registration cut-off, and you are disqualified on the spot.

Contractors are busy on job sites. They don't need another generic PDF summarizer that tells them what they already know. They need proactive follow-through.

2. What I Built: TenderLens

TenderLens is an open-source AI tender readiness and follow-through assistant that lives right in the contractor's WhatsApp.

Instead of waiting for the contractor to remember deadlines, TenderLens actively drives the bid process from the first Sunday morning newspaper clipping through to final bid package assembly.

journey
    title The Contractor Journey with TenderLens
    section 1. Notice Discovery
      Spot tender in Sunday newspaper: 5: Contractor
      Snap photo to WhatsApp: 5: Contractor
      Extract dates, ref & package instructions: 5: TenderLens (Gemma 2)
      Auto-draft package request email to agency: 5: TenderLens
    section 2. Site Visit & Early Milestones
      Alert 2 days before Site Visit registration: 5: TenderLens (Temporal)
      Contractor confirms site visit registered: 4: Contractor
    section 3. Full Bid Intake
      Forward downloaded RFP PDF / upload bundle: 5: Contractor
      Extract BIR/NIS/VAT & Bid Bond checklists: 5: TenderLens
    section 4. Proactive Follow-Through
      Scheduled check-ins on outstanding statutory docs: 5: TenderLens (Temporal)
      Escalate approaching submission deadline: 5: TenderLens
      Bid successfully submitted on time: 5: Contractor

3. How It Works (The 4-Stage Workflow)

Stage 1: The True Entry Point — The Newspaper Ad

A contractor snaps a photo of a newspaper notice (like the authentic WASA tender notice below) and forwards it to TenderLens on WhatsApp.

TenderLens extracts:

Procuring Entity: Water and Sewerage Authority (WASA)
Ref No: W.T.C. - 40/2026
Line of Business: 72102100 - Pest Control
Crucial Deadlines: ITT publication, Mandatory Pre-Bid Site Visit (August 4 @ 10:00 AM), 2-day advance attendee registration notice, queries deadline, and closing deadline (August 26 @ 2:00 PM).
Immediate Action: Automatically drafts a formal document request email addressed to purchasingandstores@agency.gov.tt for Oracle ERP issuance.

Stage 2: Full RFP Compliance Matrix

Once the contractor receives access to the 50–100 page RFP package, they forward the document or drop it onto the TenderLens secure upload portal.

TenderLens scans the document and isolates every mandatory clause with exact page citations:

Valid BIR Tax Clearance (Page 3 — ⚠️ 5-10 day lead-time warning)
Valid NIS Compliance Certificate (Page 3 — ⚠️ 3-5 day lead-time)
VAT Clearance Certificate (Page 3)
Bid Security / Tender Bond of TT$50,000 (Page 4)
Mandatory Site Visit Certificate (Page 2)

Stage 3: Proactive Follow-Through (The Differentiator)

Deterministic code, not LLM memory, controls follow-through. Using Temporal durable workflows, TenderLens maintains a multi-week timer loop.

If the contractor hasn't confirmed their BIR certificate with 10 days to go, TenderLens initiates a proactive WhatsApp check-in:

"TenderLens Check-in for W.T.C. - 40/2026: Your BIR Tax Clearance Certificate is still marked as outstanding. IRD typically requires 5–10 business days for processing. Have you submitted your application? Reply: Done, Waiting on IRD, or Need help."

When the contractor replies "Waiting on IRD", the Temporal workflow updates state and reschedules the next check-in.

4. Architecture: Why Open Innovation Matters

Tender preparation requires commercial confidentiality. Contractors are handling sensitive pricing, tax clearance documents, banking credentials, and proprietary methodology. Uploading these indiscriminately to closed, multi-tenant proprietary chatbots raises serious privacy and data ownership concerns.

By building on open-source AI and open-weight models, TenderLens keeps costs predictable and guarantees data sovereignty.

graph TD
    User([Contractor on WhatsApp]) <-->|Images, PDFs, Messages| Bridge[WhatsApp Cloud API Gateway]
    Bridge <--> Agent[TenderLens Agent Core]

    subgraph Core Engine [Render Hosted Services]
        Agent <--> Tools[TenderLens Procurement Tools]
        Tools --> AdParser[Tender Notice Image Parser]
        Tools --> EmailDrafter[Procurement Request Email Drafter]
        Tools --> PDFParser[Full RFP Compliance Parser]
        Tools --> TemporalClient[Temporal Workflow Client]

        TemporalClient <--> TemporalWorker[Temporal Worker & Workflows]
        TemporalWorker --> DB[(Managed PostgreSQL)]
    end

    subgraph AI Inference Layer
        Agent <--> Gemma[Google Gemma 2 Open-Weight LLM]
    end

    TemporalWorker -->|Scheduled Proactive Check-ins & Alerts| Bridge

The Stack Breakdown:

LLM Engine: Gemma by Google — open-weight inference handling dense procurement clauses, date reasoning, and multilingual local nuance.
Agent Harness: TenderLens Agent function-calling patterns with 6 registered procurement tools.
Orchestration: Temporal Durable Workflows (TenderFollowThroughWorkflow) managing multi-week timers, signals, and queries that survive server restarts.
Hosting & Database: Render Blueprint (render.yaml) automating deployment of the FastAPI Web Gateway, Temporal Worker, and Managed PostgreSQL database.
Security: HMAC-SHA256 Signed Magic Upload Tokens with short TTL for secure drag-and-drop uploads of packages >100 MB.

5. The Commercial Side Hustle Hypothesis

Offer	Experimental Pricing	Who Buys It
Single Tender Readiness Report	TT$150–$250 (~$25–$35 USD)	Small contractors bidding once or twice a year
Active Bid Tracking & Proactive Reminders	TT$350–$500 (~$50–$75 USD)	Subcontractors entering critical government tenders
Monthly Unlimited Tender Retainer	TT$800–$1,200/mo (~$120–$180 USD)	Active civil, electrical, or facilities contractors

In conversations with local contractors in Trinidad, missing a single TT$250,000 maintenance contract because an administrative certificate expired costs thousands of times more than a TT$350 readiness check.

6. Live Interactive Demo (Test It Yourself!)

To make testing instant for hackathon judges and readers without needing a WhatsApp developer sandbox, I built an Interactive Web WhatsApp Simulator:

👉 Live Web Simulator: https://tenderlens-api-6q3t.onrender.com/

👉 Source Code: github.com/AnthonyASBaptiste/tenderlens

Try clicking the 1-tap quick action buttons in the demo:

📷 1. Send WASA Ad: Ingests the authentic Trinidad newspaper ad and extracts critical dates.
✉️ 2. Request ERP Email: Generates the official package request email.
📄 3. Send Full RFP: Parses 10 compliance items with exact page citations.
⏰ 4. Trigger Check-in: Fires a simulated Temporal proactive follow-up notification.
📊 5. Check Status: Displays live bid readiness score.

7. Submission Checklist & Category Qualifications

[x] Theme: Side Hustle: Commercial B2B service for local contractors solving a quantifiable revenue problem.
[x] Best Use of Render: Complete multi-service blueprint in render.yaml deploying FastAPI, Temporal background worker, and PostgreSQL.
[x] Best Use of Gemma: Powered by Google's open-weight Gemma model for procurement reasoning.
[x] Best Use of Temporal: Multi-week durable workflows managing timers, signals, and proactive check-in activities.

SideQuest T&T: Your Real Life Is the Game

Anthony — Mon, 12 Oct 2026 03:58:22 +0000

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

What I Built

SideQuest T&T turns Trinidad and Tobago into a real-world RPG map. Players browse a shared daily pool of quests, accept one, go explore, then submit a short reflection about what they observed.

The app checks submissions against each quest’s criteria. If a reflection needs more detail, the player can retry; when a submission passes, the player earns XP. Quests show their criteria and safety guidance before acceptance, so players know what to look for and can choose what feels appropriate.

The MVP covers Trinidad. I tested it outdoors: after adding more detail to a reflection, the verifier approved the quest and awarded 25 XP. The demo shows the generated pool, the retry and verification flow, and the points tally.

Demo

Code

SideQuest T&T on GitHub

How I Built It

The product uses the open-weight Gemma model, running locally through Ollama on a home server. Gemma generates the daily quest pool and assesses submitted reflections against the accepted quest’s criteria.

The React/Vite frontend is deployed on Vercel. The NestJS API is deployed on Render and manages sessions, quests, submissions, and verification results. MongoDB Atlas stores the game data. A worker on the home server connects to the API to run Gemma; the API validates the assessment before changing quest status or awarding XP. Completion and XP are applied together, so a repeated result cannot award points twice.

I used GitHub Copilot during development. Copilot helped build the application; Gemma is the AI used by the running product.

Why Does Open Innovation Matter?

An open-weight model made it possible to run the quest generator and verifier on hardware I control, instead of making a closed hosted AI API a required part of the product. I could choose the model, connect it to a specific quest rubric, and test how it handled both an irrelevant response and a more detailed outdoor reflection.

The API owns the rules for quest state and XP, while the model supplies an assessment that the API validates. The submitted reflection is processed by the app and sent to the home-server worker for inference; it is not sent directly to a third-party model API.

Prize Categories

Best Use of Gemma
Best Use of Render — the deployed NestJS API runs on Render and supports the app’s quest-verification workflow; Gemma inference runs on my home server.
Best Use of MongoDB Atlas
Best Use of GitHub Copilot

Briefly: A Local-First, Zero-Data-Egress Filing Assistant for Legal Practice

Anthony — Sun, 04 Oct 2026 03:03:14 +0000

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

What I Built

My wife is a practicing attorney managing an active case load. Like many legal practitioners working against tight court filing deadlines, her day-to-day workflow involves downloading court orders, disclosure bundles, witness statements, client emails, and vendor invoices directly into her local Downloads folder with the intention of filing them later.

Over time, this operational bottleneck created significant administrative drag. Her Downloads directory accumulated hundreds of ambiguously named files—such as WhatsApp Document 2026-09-14 at 11.23.pdf, scan_0042.pdf, and generic court export names. Locating a specific pleading or affidavit before a hearing required manual searching through unstructured files, wasting valuable time and interrupting focused legal work.

I built Briefly to help her work smarter by automating that administrative overhead.

Briefly is a lightweight, local-first document filing assistant. It monitors an inbox directory, extracts text from supported documents directly on her machine, and queries a local open-weight model to identify the corresponding legal matter and document category. High-confidence matches are filed automatically into a standardized matter directory structure. Any ambiguous, scanned, or low-confidence files remain untouched in the inbox for quick manual review.

Handing It Over: Her Real-World Feedback & Immediate Iteration

The challenge prompt specifically notes: "Bonus points if you actually hand it over and tell us what they said."

When I deployed Briefly on my wife's machine with her actual workflow documents, her immediate feedback drove two crucial product insights:

Eliminating Cognitive Friction (Minutes vs. Seconds): When she opened the settings dialog and saw the cooldown timer configured in seconds, she gave immediate, practical feedback: > "I entered 30 mins but is moving stuff in less than a minute. What's going on with this?"

That's when I realized I was having her enter the cooldown as an integer in seconds but she thought she needed to use minutes.

She was completely right. Engineers think in seconds; busy professionals think in minutes. I immediately adjusted the interface to present standardized minute presets (1 min, 5 min, 10 min, 15 min, 30 min, 1 hr) while managing the underlying seconds conversion transparently in the background.

Validating the Data Model (The Matter Search Request): Once Briefly completed the first-pass discovery and organized her scattered documents into clean matter folders, she clicked through the directory tree and asked: > "This is well organized. Can I now search for specific keywords across all the documents inside this matter?"

In product development, a user requesting search across newly organized data is strong confirmation that the foundational organization problem has been solved. She immediately trusted the matter hierarchy and saw it as an operational asset. While cross-document indexing was out of scope for a weekend MVP, it validated the underlying folder architecture and established our roadmap for version 2.

Demo

Here is a walkthrough of Briefly running locally:

Per the challenge announcement's invitation to use ElevenLabs for video narration, the walkthrough audio was generated using **ElevenLabs.

Core Workflow:

First-Pass Collective Discovery: When starting with an unorganized inbox and an empty library, Briefly analyzes the document batch collectively to propose canonical matter folder names (e.g., Marcus Sterling v Gopaul & Colfire, Estate of Joseph Ramdial). It never creates directories or moves files without explicit user confirmation.
Deterministic Classification & Filing: Validated legal files are routed into standardized subdirectories: Pleadings, Correspondence, Disclosures, Orders, and Evidence.
Non-Case Document Routing: Non-legal receipts, tickets, and personal office files can be excluded with a single click, moving them directly to ~/Documents so they do not clutter future reviews.
Safety Defaults: Files are never deleted. Active browser downloads are protected by cooldown timers, and name collisions are resolved automatically using timestamped suffixes.

Code

Briefly is open-source under the MIT license:

AnthonyASBaptiste / briefly

Briefly

A local-first filing assistant for legal work. Briefly watches a folder, reads supported documents on your machine, asks an open-weight model to identify the matter and document type, and files only clear matches. Everything uncertain stays where it is for review.

Weekend MVP for DEV's Build for a Friend challenge. Built around a lawyer's real habit: download now, file later.

What works in this MVP

Local browser dashboard served by Python; no account, cloud service, or telemetry.
Configurable inbox and matter library, cooldown, file type allow/exclude lists, and confidence threshold.
PDF, DOCX, TXT, and Markdown text extraction. Scanned PDFs are recognized as unsupported without optional OCR; no silent guess based on an empty extraction.
Local Ollama chat API with Gemma (or another locally installed model), constrained JSON output.
High-confidence files are moved into an existing matter folder and document-type subfolder. Low-confidence and unassigned documents remain in the inbox and…

View on GitHub

Quickstart (Running Locally)

Requirements: Python 3.10+ (Standard Library only — zero pip dependencies) and a local Ollama instance.

# 1. Pull the model locally
ollama pull gemma4:e2b-it-qat

# 2. Run Briefly
python3 briefly.py

Access the dashboard at http://127.0.0.1:8765.

How I Built It

Briefly was architected around two core engineering principles: complete local execution and standard library minimalism.

1. Local Open-Weight Inference with Google Gemma

Inference is executed strictly against local Ollama (http://127.0.0.1:11434) using Google's open-weight Gemma 4 (gemma4:e2b-it-qat).

We specifically evaluated this quantized Gemma 4 model to match her everyday laptop specifications, achieving deterministic structured JSON output in approximately 2 seconds per document without excessive thermal throttling or memory pressure. Briefly enforces a strict JSON schema so classifications map deterministically to verified matters:

{
  "matter": "Marcus Sterling v Gopaul & Colfire",
  "document_type": "Pleadings",
  "confidence": 0.94,
  "reason": "High Court claim form identifying collision dispute between named parties."
}

Briefly is also model-agnostic: practitioners with high-end desktop workstations or dedicated GPUs can specify larger local models (such as Gemma 4 27B or Llama 3.3) directly in the settings panel without modifying code.

2. Trap 1: The "Where Did My File Go?!" Race Condition

If an attorney downloads an affidavit to attach to an outgoing email, and a background watcher immediately moves it 30 seconds later, that automation disrupts active work.

Implementation: Background file watching is disabled by default (watch_enabled: false).
Cooldown Protection: When automated watching is enabled, files are protected by a configurable cooldown timer (cooldown_seconds). Newly downloaded files remain accessible in the inbox while actively in use.
Documents are only evaluated after the cooldown period elapses, or when the user initiates a manual scan.

3. Trap 2: The Parsing Quagmire

Legal files are rarely uniform. They include scanned raster PDFs without text layers, encrypted court bundles, nested .zip archives, and corrupt DOCX files.

Implemented a 50 MB file size ceiling to prevent memory exhaustion.
Added decompression size validation (info.file_size <= MAX_FILE_SIZE) on DOCX XML streams to protect against zip bombs.
Integrated pdftotext with password-protected PDF detection and empty text validation, routing unsupported files to the review queue without failing the pipeline.

4. Trap 3: Hallucinated Directory Trees

If an LLM invents subtle variations of a matter name across runs (Smith v. Jones, Smith_vs_Jones, Smith v Jones (2024)), the local directory structure quickly fragments.

Implemented a closed-world schema where the model selects only from existing, validated matter directories.
Designed canonical_matter_key normalization that strips punctuation, legal particles (v., vs., versus), and whitespace variations into a single canonical identifier before any filesystem interaction.

5. Crash-Proof Subprocess Isolation

To eliminate GUI driver conflicts (epoll_ctl errors and segmentation faults caused by running Tkinter within a multi-threaded web server), system folder pickers are executed in isolated child processes (osascript on macOS, zenity/kdialog on Linux).

6. Local SQLite Audit Trail

All classification events, confidence scores, and filing destinations are recorded in a local SQLite database (activity table), providing a complete, auditable operational log.

Why Does Open Innovation Matter?

In legal practice, attorney-client privilege and confidentiality are strict professional mandates, not operational preferences.

Transmitting unredacted court pleadings, financial affidavits, or trade secrets across commercial cloud AI APIs risks waiving privilege under professional conduct rules. Cloud AI terms often permit telemetry collection or model retraining, which constitutes an unacceptable disclosure liability for any legal practitioner.

Open innovation provides the only compliant architecture for this domain:

Zero Data Egress: Because models like Google Gemma are open-weight, all inference runs in local memory on the practitioner's machine (127.0.0.1). No document text or metadata ever leaves the device.
Operational Independence: Open-source systems insulate professional practices from proprietary subscription lock-in, forced cloud migrations, or sudden API deprecation.
Verifiable Auditability: Open code paired with local weights allows practitioners to verify exactly how confidential client data is handled.

For high-trust professions—law, medicine, and accounting—open-weight models are not merely an alternative; they represent the only ethical and compliant deployment model.

My Agent Session

This project was developed using a multi-agent pair-programming workflow:

Codex CLI: Used for initial project scaffolding, CLI argument handling, and standard library HTTP server structure.
Google Antigravity: Used for architectural planning, implementing the safety safeguards (cooldown timers, bounded parsing, canonical matter reconciliation), generating the 21-document synthetic legal test corpus, conducting accessibility design reviews, and performing defensive adversarial security audits.
Test-Driven Verification: Antigravity engineered and verified our automated test suite across 40 unit tests (tests/test_briefly.py), covering concurrency, zip bomb mitigation, host header rebinding protection, and subprocess isolation.

(Note: Raw session transcripts were audited locally and kept private to protect local system paths and environment configuration).

Prize Categories

Best Use of Gemma (Featured Category)

Briefly utilizes Google's open-weight Gemma 4 (gemma4:e2b-it-qat) running locally via Ollama as its core intelligence layer. Gemma 4 performs document classification, matter assignment, and collective multi-document reasoning for first-pass discovery, ensuring complete privacy and compliance with legal confidentiality requirements.
Best Use of ElevenLabs

The Hacktoberfest challenge announcement specifically invited competitors to use ElevenLabs for demo video voiceover narration. We used ElevenLabs to produce the voiceover for our technical walkthrough, generating clear, professional audio that effectively communicates the problem space, architectural safeguards, and live filing workflows.