DEV Community: Ankit Kumar

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

Ankit Kumar — Sat, 24 Oct 2026 18:45:44 +0000

What I Built

Meet LoopZero — Stop managing tasks. Start closing loops.

We all have that folder.

The internship description we saved but never applied to. The PDF we downloaded to read later. The screenshots we took because we were going to do something with them. The notes containing plans that somehow never became actions.

The problem isn't always a lack of productivity. Sometimes, it's the amount of effort required to figure out what we left unfinished.

LoopZero is a local-first AI application that helps turn digital clutter into actionable, evidence-backed commitments.

Instead of simply generating another to-do list, LoopZero:

Collects — Import supported documents, notes, and text files.

Connects — Uses AI to identify potential unfinished commitments and relate them to their source files.

Explains — Shows the evidence behind each discovered commitment instead of asking users to blindly trust an AI-generated result.

Resolves — Proposes practical actions, lets users review changes, and supports approval-based execution of safe operations.

Remembers — Records actions in an activity history and supports undo for operations that can genuinely be reversed.

For example, a resume draft, an internship description, and a note saying “apply later” might all belong to the same unfinished commitment.

Rather than leaving you with three disconnected files, LoopZero helps bring them together into one place with a clear next step.

The goal isn't to automate every part of life. It's to reduce the mental overhead of remembering, organizing, and revisiting things we already intended to finish.

Demo

Try LoopZero: https://loopzero.onrender.com

Explore the interface, review commitments, and see how the workflow is designed to work.

Note: Local AI inference depends on the configured Ollama/Gemma environment. Live inference availability may differ from the local development experience.

Code

GitHub repository: https://github.com/ankit9241/LoopZero

The project includes the frontend, backend API, database integration, local AI processing pipeline, commitment management, action review, and activity history.

Feedback and contributions are welcome!

How I Built It

I built LoopZero around the idea that an AI product should do useful work without requiring every piece of personal information to be sent to a remote AI provider.

The stack includes:

React + TypeScript + Vite for the frontend.

Tailwind CSS for the interface.

Node.js + Express for the backend API.

MongoDB Atlas for persistent application data when configured.

Ollama + Gemma for local model inference.

Multer for handling file uploads.

A structured extraction pipeline that connects discovered commitments to supporting source evidence.

The AI pipeline extracts supported document content, asks the configured local model to identify potential commitments, validates the structured output, and associates results with their source files.

I also implemented safeguards against unsupported claims. A model-generated suggestion should not automatically become a fact, and a commitment should not be treated as certain when the available evidence is ambiguous.

The application distinguishes AI-generated results from deterministic fallback analysis when the local model is unavailable.

For actions, the backend maintains an approval-oriented workflow, records execution history, and supports reversal for operations that can be undone.

The intention was to build a complete product workflow rather than a chatbot wrapped in a dashboard.

Why Does Open Innovation Matter?

For LoopZero, open innovation is not just a technology preference. It changes the privacy and ownership model of the product.

Using an open-weight model through Ollama makes local inference possible. Instead of requiring every document to be sent to a closed AI API, users can process supported content on a machine they control, provided the local model is configured and running.

That creates several practical advantages:

Privacy and control: Sensitive notes and documents can be processed locally without mandatory cloud AI inference.

Model flexibility: Developers can experiment with different compatible models and compare their accuracy, latency, and resource requirements.

Less dependence on a single provider: The core AI workflow does not have to be permanently tied to one proprietary inference API.

Inspectable engineering: The application can validate model output, inspect source references, and enforce safety rules in ordinary application code rather than relying entirely on a model's promises.

Open models do not automatically guarantee perfect privacy, accuracy, or zero cost. Hardware requirements, model licenses, and application configuration still matter.

But they make it possible to build a different kind of AI experience: one where users have more control over where their information goes and how their tools behave.

That is why open innovation matters for LoopZero.

My Agent Session

I used AI-assisted development to accelerate implementation, including the backend integration, structured extraction pipeline, and end-to-end workflow verification.

I haven't included a public agent-session recording here. If I publish a DevRelay session, I'll add it to this section.

The Lazy Payoff

The payoff is simple: spend less time reconstructing what you meant to do and more time actually doing it.

Without LoopZero, a user may need to open several files, remember why they saved them, identify which ones belong together, and decide what to do next.

LoopZero aims to compress that process into a reviewable workflow:

Files → Evidence → Commitment → Approved action

I haven't established a reliable measured time-saving benchmark yet, so I'm not going to invent a percentage or claim a number of hours saved.

A useful next experiment would compare manual organization against LoopZero using the same set of documents, measuring commitment extraction accuracy, incorrect associations, review time, and the number of actions successfully completed.

The real goal is not to create more tasks. It's to help close the loops that would otherwise stay open.

Prize Categories

Gemma — Best Use of Gemma: Local open-weight model inference is central to the commitment extraction workflow.

Render — Best Use of Render: The application is deployed at https://loopzero.onrender.com.

What's Next?

LoopZero is an early MVP, and there's plenty left to improve: stronger commitment deduplication, more robust document extraction, better evaluation of model accuracy, and additional safe, reversible actions.

The next step is to test it against messy, realistic document collections and measure whether it genuinely reduces the work required to close unfinished commitments.

If you've ever saved something for later and completely forgotten why, I'd love to hear what you'd want LoopZero to handle for you.

devchallenge #hf26challenge

TenderTrap — An AI-Powered Bid Intelligence Tool for Small Contractors

Ankit Kumar — Sat, 17 Oct 2026 18:11:46 +0000

Small contractors shouldn't have to spend hours decoding government tender documents just to discover they're missing a critical requirement.

That's the problem I'm trying to solve with TenderTrap, an AI-powered tender intelligence tool that helps contractors evaluate bid opportunities before investing time and resources in preparation.

What I Built

Government procurement can create real opportunities for small contractors and MSMEs, but tender documents are often lengthy, technical, and difficult to evaluate. Eligibility conditions, turnover requirements, registrations, EMD, performance guarantees, and contractual clauses can all affect a bidding decision.

TenderTrap converts tender PDFs into structured, evidence-backed assessments.

Here's what it does:

Extracts requirements: Identifies relevant criteria from tender documents.
Classifies documents: Distinguishes individual tender notices from circulars, contract conditions, amendments, and mixed compilations.
Traces findings to sources: Links extracted requirements to document pages and clauses.
Checks company evidence: Compares requirements with available company information and identifies missing or uncertain evidence.
Supports bid/no-bid decisions: Produces one of three recommendations — PROCEED, INVESTIGATE, or SKIP.
Keeps uncertainty visible: Uses MET, UNMET, and UNKNOWN statuses, with human-review flags when evidence is incomplete or ambiguous.

The goal isn't to replace a contractor's judgment. It's to help them make a more informed decision before committing time to a bid.

Who would pay for it?

Small construction contractors, MSMEs, and independent tender consultants who regularly evaluate government procurement opportunities.

The business hypothesis is that a tool that reduces repetitive document review and highlights potential blockers could save enough time to justify a subscription. Pricing and willingness to pay still need validation with actual users.

Demo

Live application: https://tendertrap.onrender.com

The current prototype demonstrates PDF analysis, document classification, requirement extraction, source citations, evidence matching, and review workflows.

Known limitation: Scanned PDFs are subject to OCR processing limits. In testing, a 157-page scanned compilation was processed partially, with unprocessed pages explicitly reported. The prototype does not guarantee eligibility, contract awards, or legal compliance.

Code

GitHub repository: https://github.com/ankit9241/TenderTrap

The project uses a single codebase built with TanStack Start, React 19, TypeScript, and a Node.js/Nitro server.

How I Built It

TenderTrap combines open-weight AI with deterministic business logic rather than asking an LLM to make an unverified final decision.

Core technologies:

Gemma 3 + Ollama: Open-weight model inference for structured analysis of tender documents in the local development setup.
unpdf: Native PDF text extraction.
Tesseract.js: OCR for scanned documents.
TanStack Start, React 19, TypeScript: Application UI, routing, and server endpoints.
MongoDB driver: Database integration for company and assessment data.
Deterministic matching and decision rules: Compare extracted criteria with available company evidence and generate cautious recommendations.

One of the biggest challenges was preventing plausible-looking but unsupported results.

During testing with a 157-page scanned compilation, the system initially mixed contractual durations with bid deadlines and treated a compilation as though it were a single tender. I improved the pipeline to classify document types, identify sections, separate bid deadlines from contractual durations, validate source citations, and disclose incomplete OCR coverage.

The current automated test suite reports 102 passing tests, and the production build succeeds.

These results validate the tested code paths, not universal accuracy across all tender documents. Production cloud persistence and multi-tenant security still require further verification.

Why Does Open Innovation Matter?

TenderTrap's AI analysis uses Gemma, an open-weight model, through Ollama in local development.

This gives me control over the inference setup and makes it possible to experiment with a specialised document-analysis workflow without relying entirely on a closed, hosted AI API.

Open-source extraction and OCR libraries provide the document-processing foundation, while the matching and decision logic remains inspectable and testable.

For a product aimed at small contractors, infrastructure cost, explainability, and control over the processing pipeline matter. Open innovation makes it easier to experiment with models, change the workflow, and improve the product without locking every part of the system to a single proprietary AI provider.

The longer-term goal is to make tender evaluation more accessible to smaller businesses that cannot afford extensive manual procurement support.

Prize Categories

Render — Best Use of Render: TenderTrap is built for deployment as a full-stack web application on Render, bringing the tender analysis workflow into one accessible platform.
Gemma — Best Use of Gemma: Uses the open-weight Gemma 3 model through Ollama in the tender analysis pipeline to support document understanding and structured extraction.
MongoDB Atlas — Best Use of MongoDB Atlas: Include this category if the submitted implementation uses MongoDB Atlas as its actual data layer.

devchallenge #hf26challenge

StepOut: The Invisible Mission - An OpenSource AI That Gets You Off Your Screen

Ankit Kumar — Sun, 11 Oct 2026 08:10:59 +0000

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

What I Built

StepOut — The Invisible Mission: AI designs the experience. You put your phone away. Real life becomes the experience.

StepOut is a different kind of AI-powered outdoor experience. Instead of keeping users engaged with another app, it uses AI to give them a reason to leave their screens behind.

The idea is simple: a CAPTCHA you can't solve from your screen.

Users create a personalized physical mission based on their available time, surroundings, preferred experience, energy, and accessibility constraints. StepOut generates a real-world challenge that requires observation, listening, exploration, or reflection rather than interacting with a device.

The experience follows four steps:

Create a Mission: Choose a duration, surroundings, experience style, and physical or accessibility constraints. Missions can be tailored to places such as your home, neighbourhood, park, or urban surroundings.
Disappear: Receive a concise mission briefing with clear steps and an observation goal. Lock your phone and experience the world around you.
Return & Reflect: Answer a mission-specific question, followed by an adaptive AI-generated follow-up that explores what you actually noticed.
Read Your Field Report: Get a grounded insight synthesized from your own observations, a personal takeaway, and an entry in your Field Journal Archive.

What makes StepOut different?

Context-aware AI missions: Challenges adapt to the user's circumstances instead of relying entirely on a fixed list of activities.
Phone-free by design: Missions don't require photography, GPS, continuous phone interaction, purchases, or dangerous navigation.
Adaptive reflection: AI asks relevant follow-up questions based on the mission and the user's actual observations, rather than generic mood questions.
Honest by design: StepOut doesn't pretend that a timer proves someone went outside. Time is reported using elapsed timestamps or user-provided information, without surveillance.
Privacy-conscious experience: No camera or GPS tracking is needed to verify the experience.
Graceful AI fallback: When the AI service is unavailable, deterministic fallback logic keeps the experience usable and clearly identifies fallback-generated content.
Persistent missions: Mission state survives refreshes, browser closure, and phone locking through timestamp-based session persistence.
Field Journal: Users can revisit completed missions, observations, AI insights, and personal takeaways.

StepOut is built for people who want to spend less time scrolling and more time noticing the world around them. It doesn't try to make people addicted to another app; it helps them leave it.

Demo

Live Demo: https://stepout-1vha.onrender.com

The demo will show the complete journey: creating a personalized mission, receiving the briefing, putting the phone away, returning for an adaptive reflection, and viewing the final Field Report.

Code

GitHub Repository: https://github.com/ankit9241/StepOut

Built with TanStack Start, React 19, TypeScript, Tailwind CSS, and an open-weight Gemma model served through Ollama.

How I Built It

StepOut is built around Gemma, an open-weight model from Google, with Ollama providing the model-serving interface.

Rather than using AI as a decorative chatbot, the project uses it for specific tasks throughout the experience:

Mission generation: Gemma creates contextual, actionable, real-world missions based on the user's available time, surroundings, preferences, and constraints.
Adaptive inquiry: The AI generates a follow-up question grounded in the user's first reflection, encouraging more meaningful observation.
Insight synthesis: The AI turns the user's actual observations into a concise, personalized field note and takeaway without inventing details about their experience.

Technical architecture

Frontend: TanStack Start, React 19, TypeScript, and Tailwind CSS.
AI inference: Open-weight Gemma through Ollama.
Backend: Node.js server with API endpoints for mission generation and reflection processing.
State persistence: A centralized session layer with local storage and timestamp-based session recovery.
Resilience: Deterministic fallback generation and reflection logic for AI outages.
Testing: Automated unit and integration tests covering AI services, API endpoints, fallback behavior, routing, security, and database functionality.
Deployment architecture: Designed for a unified Render web service, with the AI inference service kept separate from the web application.

The interface follows an editorial field-journal aesthetic rather than a conventional gamified productivity dashboard. It uses Instrument Serif and Geist typography, a warm cream background (#F7F4EC), and a restrained burnt-vermilion accent (#C84B31).

I also built explicit guardrails into the mission-generation process. A challenge should fit the user's real circumstances, remain accessible and safe, and never require them to keep looking at their phone to complete it.

Engineering verification: The latest implementation passed TypeScript checks, linting, production builds, and all 36 automated tests across six test suites.

Why Does Open Innovation Matter?

StepOut's purpose would be undermined if escaping screens required dependence on a closed, opaque AI service.

Using open-weight Gemma through Ollama makes the AI layer more inspectable, gives developers flexibility over model serving, and creates a path toward running inference locally for greater privacy and control.

Open innovation also makes the project's underlying approach reproducible. Developers can examine the prompts, experiment with different models, improve the fallback mechanisms, and contribute better ways of generating safe, meaningful offline experiences.

Most importantly, the model is not the product by itself. The value comes from how the model is integrated into a complete experience that encourages people to disconnect.

StepOut demonstrates that AI doesn't always need to maximize engagement, session length, or screen time. It can be used to help people spend less time with technology and more time in the physical world.

My Agent Session

[Insert DevRelay agent session URL, if available]

Prize Categories

Overall Hacktoberfest Open-Source AI Challenge
Best Use of Gemma
Best Use of Render

Unbury: An Open-Source AI Memory That Turns Messy Life Into Things You Can Actually Do

Ankit Kumar — Sun, 04 Oct 2026 16:37:45 +0000

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

What I Built

I built Unbury for a close friend who has a habit many of us share: important things get buried in everyday conversations.

A deadline might be mentioned in a fast-moving WhatsApp chat. A task might be hidden inside a screenshot. Someone sends an important PDF or a voice note containing something they need to remember days later. The problem isn't that they don't care about these details—the problem is that the information is scattered everywhere across multiple channels.

I didn't want to build another standard todo app where they had to manually convert everything into tasks. I wanted to build something that could understand raw, messy inputs as they arrive and automatically extract actionable commitments and useful memories.

That's how Unbury started. Unbury is an AI-powered external memory for messy real-life information. You can dump text, screenshots, PDFs, or voice notes into it. It parses the content, extracts potential tasks and useful memories, and presents a confirmation review before anything is committed to memory.

The core loop is:

Dump → Understand → Review → Confirm → Remember → Remind

For example:

"Please send the one month strategy to Rahul tomorrow at 5 PM and remind me 15 minutes before."

Transforms into:

Task: Send the one month strategy to Rahul
Deadline: Tomorrow at 5:00 PM
Reminder: 15 minutes before
Evidence: The original raw message

If information isn't actionable (like casual chatter or background thoughts), Unbury filters it into memories rather than unnecessary tasks, keeping the action feed clean.

Demo

Live Application: https://unbury-bphf.onrender.com/app

The deployed application uses hosted Gemma through Google's API for production inference. You can test the core workflow:

Dump unstructured text, upload a document, or share notes.
Let Unbury parse the content.
Review extracted tasks, deadlines, and memories.
Edit, adjust, or discard irrelevant suggestions.
Confirm what gets committed to memory.
Query stored data through the grounded Ask assistant.

Code

ankit9241 / Unbury

Unbury

Turn messy information into structured tasks and memory — without losing context.

Unbury is an AI assistant that reads whatever you throw at it — messages, PDFs, voice notes, screenshots — and extracts the tasks, deadlines, and durable facts buried inside. Nothing is saved without your review.

Live Demo

unbury.onrender.com

What It Does

Dump anything — paste text, upload a PDF, drop a screenshot, or record a voice note
AI extraction — Gemma identifies tasks with deadlines and facts worth remembering
Review before saving — every extraction is a proposal you confirm, edit, or discard
Progressive reminders — browser notifications fire at 1 week, 3 days, 1 day, and 1 hour before a deadline (while the app is open and permission is granted)
Persistent memory — durable facts (people, roles, context) are stored separately from tasks and surface when relevant
Ask Unbury — query your saved memory in plain…

View on GitHub

The repository includes the complete full-stack implementation:

AI extraction pipeline and prompt parsing
Multimodal ingestion (OCR, PDF parsing, text transcripts)
Structured review and user confirmation engine
Reminder scheduler and grounded retrieval workflow

How I Built It

Unbury is architected around Gemma as its cognitive core:

Local Development: Gemma running locally via Ollama for low-latency iteration.
Production Deployment: The Next.js application and AI API routes are deployed on Render, using hosted Gemma through Google's API.
Data Persistence: MongoDB Atlas database cluster storing structured tasks, memories, review states, and reminder queues.

Architecture Flow:

Messy Input (Text / Image / PDF / Voice)
       ↓
Pre-processing & Text Extraction
       ↓
Gemma (Structured JSON Extraction)
       ↓
Validation & Actionability Filtering
       ↓
Review & User Confirmation Screen
       ↓
MongoDB Atlas
       ↓
Actionable Tasks, Grounded Memories & Reminders

Why Does Open Innovation Matter?

Open-weight models like Gemma are essential for personal productivity and memory systems for two reasons:

Privacy & Data Sovereignty: Everyday life dumps contain sensitive personal data—chats, financial deadlines, screenshots, and internal notes. With open-weight models, users are not forced to send their personal life data to proprietary third-party LLMs with ambiguous retention policies. The exact same pipeline can run completely offline and locally using Ollama.
Predictable Scalability: Open architectures eliminate arbitrary token rate limits, sudden API deprecations, and prohibitive subscription fees, enabling sustainable personal tools that remain accessible to everyone.

Prize Categories

Best Use of Gemma (Gemma integrated via Ollama for local environments and hosted Gemma for the live production pipeline)
Best Use of Render (Full-stack web application, inference routes, and background scheduler deployed on Render)
Best Use of MongoDB Atlas (Managed MongoDB Atlas cluster handling persistent memories, review states, tasks, and scheduling metadata)