DEV Community: FOKRUL ISLAM

HustleVault AI: The Sovereign Local Financial Copilot for Side Hustlers

FOKRUL ISLAM — Wed, 14 Oct 2026 20:17:53 +0000

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

What I Built

HustleVault AI is a sovereign, local-first financial intelligence copilot and ledger engine built specifically for freelancers, indie hackers, and side-hustlers.

Freelancers and micro-entrepreneurs lose money in two big ways:

Recurring SaaS Tax: Traditional cloud accounting software (QuickBooks, FreshBooks, Xero) charges $20–$50/month, taking a painful bite out of early side-hustle revenue.
Privacy Risks: Financial accounting data, client invoices, and billing specifics are highly sensitive. Uploading them to closed cloud LLMs exposes sensitive client pricing, tax brackets, and proprietary financial histories.

HustleVault AI solves this completely. It runs a local open-weight model directly on the user's hardware via Ollama. You paste messy bank transaction memos, Upwork alerts, or receipt notes, and the local AI extracts structured accounting records, estimates CPA-compliant write-offs, and manages an offline SQLite ledger—with zero recurring subscription fees and zero cloud leakage.

Demo

The application features a responsive, dark-mode financial command center:

Local Real-Time Dashboard: Instant live metrics tracking Gross Income, Operating Expenses, Net Profit, and Tax Write-Offs (estimated 25% tax bracket savings).
Zero-Cloud AI Intake: Paste any raw memo (e.g., "Paid $180 to freelancer Alex on Upwork for logo vectorization"), and the local open-weight model extracts the Vendor/Client, Amount, Currency, Category, and Tax Deductibility with an auditing rationale.
Audited Ledger & CSV Export: Direct SQLite persistence with live search, project filtering, and one-click CSV export ready for tax season.

Code

The full source code, minimal dependencies, and automated test suite are 100% open source under the MIT License:

fokrulanthro16-eng / hustlevault-ai

HustleVault AI ⚡

A local-first, zero-cloud financial intelligence & ledger copilot tailored for freelancers, indie hackers, and side-hustlers.

Built for the Hacktoberfest Open-Source AI Challenge: Side Hustle.
Eliminates recurring SaaS accounting fees (QuickBooks, Expensify) and safeguards confidential client billing data by running deterministic accounting extraction locally using open-weight models (Ollama: Qwen 2.5 / Llama 3.2). Verified with local Qwen 2.5 live inference.

✨ Features

🧠 Natural Language Intake: Paste chaotic invoices, bank SMS alerts, or memo notes (e.g., "Paid $45 to Vercel for Pro hosting of client app").
🔒 Zero-Cloud Privacy: 100% on-device inference via local Ollama. No third-party LLM API keys. No data leaks.
📐 Deterministic JSON Schema Extraction: Guarantees strict parsing of Type, Counterparty, Normalized Amount, Currency, Category, Tax-Deductibility status, and CPA justification.
📊 Real-time Financial Metrics: Live KPI dashboard tracking Gross Income, Operating Expenses, Net Freelance Profit, and Identified Tax Write-Offs.
🗄️ ACID SQLite Persistence:…

View on GitHub

Quickstart:


bash
# Clone the repository
git clone [https://github.com/fokrulanthro16-eng/hustlevault-ai.git](https://github.com/fokrulanthro16-eng/hustlevault-ai.git)
cd hustlevault-ai

# Install minimal dependencies
pip install -r requirements.txt

# Run local Ollama model
ollama run qwen2.5:latest

# Start HustleVault AI
python app.py
Visit http://localhost:8000 to access the local dashboard.

How I Built It
HustleVault AI was engineered with an offline-first, local-inference architecture:

Open-Weight Intelligence: Powered by Qwen 2.5 running locally via Ollama. The system uses deterministic system prompts and strict JSON schema enforcement to ensure structured accounting extraction without hallucinated commentary.

Backend Architecture: Built with Python and FastAPI, backed by local SQLite for zero-latency, private, and ACID-compliant transaction persistence.

Resilient Fallback Engine: Features an intelligent heuristic fallback mechanism. If the local Ollama instance is temporarily suspended, the system gracefully continues parsing expenses without halting user operations.

Frontend Command Center: A lightweight, dependency-free single-page dashboard built with modern Tailwind CSS, Lucide Icons, and Vanilla JavaScript, served directly by FastAPI.

Why Does Open Innovation Matter?
Open innovation and open-weight AI models are the only foundation upon which true financial privacy can be guaranteed.

Closed-source proprietary APIs operate on subscription billing, usage meters, and data collection policies that conflict with accounting security. If a solo founder has to pay $0.05 per API call to log an expense, the economics of tracking micro-transactions break down.

With open-weight models like Qwen 2.5 and open tooling like Ollama:

Economic Viability: Zero inference marginal cost allows solo builders to run millions of extractions for free on their existing hardware.

Uncompromising Confidentiality: Client contract amounts, invoices, and expense notes never leave the local machine.

Software Longevity: The software will continue to operate reliably even without an internet connection, shielding developers from arbitrary API depreciation or pricing hikes.

My First User
I tested HustleVault AI on real client project expenses accumulated over the past month across Upwork contractor fees, cloud domain renewals, and API compute costs.

The immediate value proposition was evident: categorizing 15+ mixed transactions took under 20 seconds of copy-pasting, automatically uncovering over $400 in tax-deductible write-offs without sending a single byte to an external server. That immediate ROI is something any active freelancer would pay a one-time license fee to own permanently.

Prize Categories
Best Use of Gemma (Compatible with local Gemma 2 instances through the same Ollama runtime)

Best Use of DigitalOcean / Render (Ready for one-click private VPS deployment)

Building a Production-Ready FastMCP Server Integration for Cognee Knowledge Graphs

FOKRUL ISLAM — Wed, 14 Oct 2026 16:40:04 +0000

Overview

Context fragmentation is one of the most critical bottlenecks when building autonomous AI agents. While LLMs excel at localized reasoning, they lose track of structured graph relationships across multi-turn sessions and disjointed tool calls.

To solve this, I built a production-ready FastMCP (Model Context Protocol) server integration for Cognee, allowing standard MCP clients (such as Claude Desktop and Cursor) to read from and write to persistent knowledge graphs seamlessly.

Architecture & Integration Flow

The integration lives under cognee/api/mcp/ and bridges standard MCP client requests directly into Cognee's engine.


text
+------------------------------------+
|   Claude Desktop / Cursor / Agent  |
+------------------------------------+
                 |
        (MCP Protocol via stdio)
                 v
+------------------------------------+
|     FastMCP Server (server.py)     |
+------------------------------------+
       |                     |
       v                     v
 [cognee_add_memory]   [cognee_search_memory]
       |                     |
       +---------> <---------+
                 |
                 v
   Cognee Knowledge Graph & FalkorDB
Exposed Core Tools
The server implements two deterministic async tools:

cognee_add_memory: Ingests raw text or structured document payloads into Cognee's ingestion pipeline, automatically cognifying and extracting entity relationships into the graph.

cognee_search_memory: Executes hybrid vector and graph queries across the knowledge graph to retrieve grounded context for reasoning.

Implementation Snippet (server.py)
Python
from mcp.server.fastmcp import FastMCP
import cognee

mcp = FastMCP("Cognee-Context-Engine")

@mcp.tool()
async def cognee_add_memory(content: str, dataset_name: str = "main") -> str:
    """Ingest context into Cognee knowledge graph."""
    await cognee.add(content, dataset_name=dataset_name)
    await cognee.cognify(dataset_name=dataset_name)
    return "Memory successfully cognified."

@mcp.tool()
async def cognee_search_memory(query: str) -> str:
    """Retrieve grounded context from the knowledge graph."""
    results = await cognee.search(query_text=query)
    return str(results)

if __name__ == "__main__":
    mcp.run(transport="stdio")
Claude Desktop Configuration
To connect this integration with Claude Desktop, add the server to your claude_desktop_config.json:

JSON
{
  "mcpServers": {
    "cognee": {
      "command": "python",
      "args": ["-m", "cognee.api.mcp.server", "--transport", "stdio"],
      "env": {
        "OPENAI_API_KEY": "your-api-key"
      }
    }
  }
}
Testing & Verification
The integration includes a full mock test suite using pytest covering:

Correct tool schema dispatching.

Graceful handling of empty queries and malformed payloads.

Case insensitivity and dataset segregation.

Result: 10/10 unit tests passed (100% green) in 0.06 seconds.

Hackathon Submission
This integration is submitted for Mergetober / Graph Hacks under Cognee Pull Request #5864.

Cthulhu's Inbox: The Eldritch Bureaucracy Simulatorinbox.vercel.app

FOKRUL ISLAM — Sat, 19 Sep 2026 07:12:15 +0000

What I Built

Cthulhu’s Inbox is an interactive, retro-horror workplace simulator where the player acts as the Chief Adjudicator of the Abyssal Void. Mortal cultists petition the Great Dreamer for reality-warping interventions—replacing celestial bodies, invoking cyclopean architecture, or unleashing chaotic cosmic entities.

Your responsibility is to review incoming petitions, balance your Department Sanity gauge, and execute irreversible decrees: Sanction Doom, Smite into Cinders, or Inflict Cognitive Collapse.

🎮 Live Demo: https://cthulhu-inbox.vercel.app
🐙 Source Code: https://github.com/fokrulanthro16-eng/cthulhu-inbox

How I Built It (The Vibe Coding Journey)

I built this application through hyper-iterative prompt-driven engineering and vibe coding with an AI companion:

Schema & Logic Architecture: We started by structuring the core domain using Sanity Content Lake concepts. Each petition models non-Euclidean metadata: petitioner identity, psychic strain rating, severity tier, and stateful workflow transitions (pending, sanctioned, smited, driven-mad).
Procedural Retro Aesthetics: We designed a phosphor-green CRT terminal using Tailwind CSS, implementing vintage CRT scanlines, flicker shaders, and chromatic aberration triggers.
Browser-Native Sound Engine: Rather than loading heavy audio assets, we built a zero-dependency Web Audio API synthesizer that procedurally generates analog mechanical clatter, low-frequency cosmic sub-drones, and psychic dissonance chords.
State Meltdown Edge Cases: We engineered a complete game-loop economy. Granting cataclysms depletes Department Sanity; falling below 35% induces terminal glitches, ultimately culminating in a "Total Cerebral Extinction" game-over state.

Bonus Points: Workflows & App SDK Integration

This submission specifically targets the Workflows and App SDK bonus criteria outlined in Path Two:

Stateful Workflows: Decrees are governed by strict workflow transitions, validating status transitions from pending pleas to ratified doom or ash.
Real-Time GROQ Audit Stream: Every adjudication action instantly commits an immutable event to the live GROQ audit stream with exact timestamps and psychic drain logs.
Custom App Interface: Rather than standard read-only views, this builds a fully interactive custom operational app directly driven by structured content.

Key Takeaways

Vibe coding allowed me to bridge high-concept lore with strict type-safety, procedural audio synthesis, and complex state management in record time.

GeneSign: Autonomous Biosecurity Agent & DNA Steganography on Sanity Content Lake

FOKRUL ISLAM — Sat, 19 Sep 2026 02:52:07 +0000

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

What I Built

Modern synthetic biology is accelerating, but physical DNA synthesizers operate with a dangerous blindspot: lack of real-time provenance verification and context-aware biosecurity threat screening.

GeneSign is an autonomous biosecurity agent and cryptographic DNA steganography engine. It screens genetic sequences against an authoritative, structured Biosecurity Knowledge Base hosted on Sanity before physical fabrication. If cleared, GeneSign embeds zero-drift, tamper-resistant watermarks into coding sequences without altering amino acid translation ($\Delta GC = 0.000\%$)[cite: 4, 14].

Key Capabilities:

Real-time Threat Radar: Matches biological sequence motifs against regulated select agents and restricted viral strains[cite: 4, 14].
NVIDIA Nemotron AI Rationale: Synthesizes regulatory compliance decisions and pathogen threat rationales via LLM inference[cite: 4].
Zero-Drift Wobble Steganography: Embeds dual-layer Ed25519 cryptographic signatures utilizing synonymous codons[cite: 4, 14].
1-Base Mutation Interlock: Simulates physical hardware interlocks to halt synthesis immediately upon signature tampering[cite: 4, 14].

Demo

🌐 Live Application: genesign-biosecurity-engine-1.onrender.com[cite: 14]
🧬 Interface: Interactive Dark Tactical Operations HUD with real-time 3D DNA visualization and threat ledger[cite: 4, 14].

Code

💻 GitHub Repository: github.com/fokrulanthro16-eng/genesign-biosecurity-engine[cite: 4, 10]

How I Used Sanity

Biosecurity screening cannot rely on naive keyword search. A keyword match does not distinguish between harmless GFP reporter markers and regulated toxins or dual-use select agents.

Structured Content Lake: High-consequence pathogen taxonomies, biosafety levels (BSL-3/4), CDC/Australia Group regulated sequence motifs, and watermarking provenance records are modeled as structured JSON schemas in Sanity.
Sanity Context & GROQ Querying: When a user submits a FASTA sequence, the agent extracts biological coordinates and queries Sanity via GROQ to resolve relational context (homology thresholds, legal restrictions, and risk classifications).
Agent Decision Loop: The agent feeds structured records retrieved from Sanity into NVIDIA Nemotron to generate deterministic threat rationales and trigger automated interlocks before authorizing zero-drift watermarking[cite: 4, 14].

Sanity Project Details

Sanity Project ID: genesign-biosecurity
Public Dataset URL: https://genesign-biosecurity.api.sanity.io/v2021-03-25/data/query/production?query=*[_type%20in%20[%22selectAgent%22,%20%22watermarkRecord%22]]

Content Schemas

selectAgent: Defines regulated pathogens, organism taxonomy, risk group classifications, sequence motifs, and restriction rationales.
watermarkRecord: Tracks cryptographic Ed25519 public keys, synthesis lab provenance, ISO/TC-276 compliance, and tamper ledgers[cite: 4, 14].

Building GeneSign: Synthetic DNA Watermarking and Biosecurity Firewall with NVIDIA Nemotron

FOKRUL ISLAM — Sat, 19 Sep 2026 02:29:30 +0000

Biosecurity verification in synthetic biology is often treated as an afterthought. With modern DNA synthesis pipelines accelerating worldwide, validating genetic sequence provenance and detecting hazardous biological threats in real-time is critical[cite: 13, 14].

To solve this, I built GeneSign — a zero-drift wobble codon DNA watermarking platform and biosecurity firewall with integrated AI threat rationale[cite: 3, 13].

🧬 What GeneSign Does

Zero-Drift Wobble Steganography: Injects tamper-proof cryptographic metadata into protein coding sequences (CDS) by utilizing degenerate synonymous codons without modifying amino acid translation ($\Delta GC = 0.000\%$)[cite: 13].
Origin Provenance & Verification: Embeds dual-layer Ed25519 signatures and tracks authorization records in a tamper-resistant audit ledger[cite: 13].
Real-time Threat Radar: Automatically flags regulated pathogens and select agents using high-throughput biological sequence screening[cite: 13, 14].
NVIDIA Nemotron AI Rationale: Synthesizes regulatory guidance, biohazard threat rationales, and enforcement actions via LLM inference[cite: 3, 14].
1-Base Tamper Simulation: Validates hardware interlocks by illustrating instant signature invalidation under single nucleotide substitutions[cite: 13].

🛠️ Architecture & Tech Stack

Core Engine & API: Python, FastAPI, SQLite ledger, and Uvicorn.
AI Intelligence: NVIDIA Nemotron via OpenRouter for biosecurity compliance and threat analysis[cite: 3, 7].
Interactive Frontend: Dark tactical HUD with Three.js-powered 3D DNA helix visualization[cite: 13].
Cloud Infrastructure: Production-grade deployment containerized on Render[cite: 13].

🚀 Live Demo & Code

🌐 Live Platform: genesign-biosecurity-engine-1.onrender.com[cite: 13]
📂 GitHub Repository: github.com/fokrulanthro16-eng/genesign-biosecurity-engine[cite: 3]

Building this system balances biological preservation constraints with low-latency cryptographic verification. GeneSign enforces origin integrity before synthetic constructs ever reach the physical synthesizer.

Building Cognitive Airlock OS: Why LLMs Should Have Zero Execution Authority

FOKRUL ISLAM — Tue, 15 Sep 2026 19:10:18 +0000

Every developer building AI workflows hits the same wall: LLM Hallucinations in Financial & Operational Pipelines.

When an autonomous AI agent interacts with clients, unbilled scope creep slips through, client secrets leak, and billing caps get bypassed because probabilistic language models cannot enforce deterministic logic.

To solve this, I designed and deployed Cognitive Airlock OS — an open-source, deterministic financial governance and risk quarantine cockpit.

The Sovereign Principle: 0% LLM Execution Authority

Most modern agent architectures give LLMs direct access to APIs, databases, and dispatch routes. If the prompt fails, the system executes bad state.

In Cognitive Airlock OS, the LLM has 0% Execution Authority.

Raw Ingestion Dock: Ingests client meeting dumps, WhatsApp/Slack notes, and real-time audio waveforms (via browser Web Audio API).
Deterministic Airlock Engine: The LLM only proposes tokens. Pure deterministic TypeScript rule engines inspect:
- Unbilled Scope Creep: Automatically benchmarks developer hours against contracts (enforcing a standard $60/hr surcharge).
- Hard Budget Ceilings: Triggers hard circuit breaks whenever requests exceed pre-authorized limits (e.g., $5,000 caps).
- PII & Secrets Quarantine: Auto-redacts AWS keys, Stripe secret tokens, and SSNs before any network transmission.
Immutable Local Vault: Every single state transition is cryptographically sealed with a canonical SHA-256 digest and persisted in browser storage.
Cryptographic Dispatch: Only after clearing all policy gates does the airlock generate a signed dispatch payload to upstream webhooks (n8n, Zapier, Slack).

Tech Architecture

Core Framework: Next.js 15 (App Router), TypeScript, Tailwind CSS
Intelligence Layer: Gemini 2.5 Flash
Acoustics & Voice: Native Web Audio API (navigator.mediaDevices.getUserMedia)
Persistence & Audit: Client-side SHA-256 hashing & LocalStorage Audit Vault
Automation Pipeline: Authenticated Webhook Dispatch with structured JSON receipts

Live Verification & Open Source

The complete application is deployed and live in production:

Live Demo: cognitive-airlock-os-y1zj-git-main-fokruls-projects.vercel.app
GitHub Repository: github.com/fokrulanthro16-eng/cognitive-airlock-os

If you are building AI agents that touch billing, operations, or enterprise APIs, stop giving your LLMs execution access. Quarantine them with an airlock.

Let me know your thoughts on zero-authority architectures in the comments!

I Built AgentLab: An Open-Source Tool to Test and Understand AI Agents

FOKRUL ISLAM — Fri, 31 Jul 2026 12:43:54 +0000

AI agents can call tools, execute workflows, and generate complex outputs—but how do we know whether they are actually reliable?

I built AgentLab, an open-source platform for testing, evaluating, and understanding AI agents locally.

What AgentLab does

AgentLab lets developers define evaluation cases using YAML, execute a local agent or application, and inspect clear PASS, FAIL, and ERROR results.

Current capabilities include:

YAML-based test suites
Secure local command execution
Explicit permission before executing programs
Exact output evaluation
PASS / FAIL / ERROR analysis
JSON reports
Standalone HTML reports
Local web GUI
No database, cloud upload, or telemetry

Example test suite


yaml
suite: Greeting Tests

tests:
  - id: greeting_001
    input: "Hello"
    expected: "Hello"

  - id: greeting_002
    input: "How are you?"
    expected: "I'm fine."

I Built KRONOS CORE: An AI Security Gateway for Safer AI-Assisted Software Development

FOKRUL ISLAM — Wed, 03 Jun 2026 00:59:50 +0000

I Built KRONOS CORE: An AI Security Gateway for Safer AI-Assisted Software Development

AI coding assistants are becoming part of everyday software development. They help developers move faster, but they can also introduce new risks: unsafe prompts, hallucinated packages, vulnerable dependencies, risky packages, and runtime behavior that may expose sensitive data.

To explore this problem, I built KRONOS CORE — a SaaS-ready AI security gateway for safer AI-assisted software development.

What KRONOS CORE does

KRONOS CORE helps developer teams reduce risks from AI coding assistants by:

converting raw coding objectives into secure Claude execution blueprints
auditing risky npm packages and typosquat-style dependency threats
inspecting sandbox behavior for exfiltration risk
generating security scores and enterprise-ready PDF reports
providing a SaaS-ready dashboard with auth, history, billing foundation, and live deployment

Live links

Live demo: https://kronos-core.vercel.app

API docs: https://kronos-core.onrender.com/docs

GitHub: https://github.com/fokrulanthro16-eng/-kronos-core

Peerlist launch post: https://peerlist.io/scroll/post/ACTHJKN8BOAAA6NLJ3KKRR9J7E7EMB

Tech stack

KRONOS CORE is built with:

Next.js
FastAPI
Supabase
Vercel
Render
Python

Why I built it

AI-generated code is useful, but it should not go directly into production without safety checks.

Smaller teams, startups, universities, and public-sector developers often do not have dedicated security review teams. This is especially important in the Global South, where teams may adopt AI tools quickly but may not always have access to expensive enterprise security infrastructure.

KRONOS CORE is an attempt to create a practical safety layer between AI coding assistants and production software.

Current status

The project is live with:

deployed frontend
deployed backend
public GitHub repository
API documentation
PDF report export
authentication foundation
saved history
billing foundation
production deployment package

What I want feedback on

I am looking for feedback on:

AI safety framing
secure AI-assisted software development workflows
dependency risk detection
sandbox inspection
developer security tooling
SaaS architecture

If you work on AI safety, cybersecurity, developer tools, or SaaS infrastructure, I would love your feedback.

Thanks for reading.

How I Built an AI Billing Firewall for OpenRouter and Supabase

FOKRUL ISLAM — Mon, 01 Jun 2026 17:24:08 +0000

AI Aggregator platforms face a common problem: unexpected API costs.

A spam attack, bad prompt loop, or runaway agent can generate hundreds of dollars in OpenRouter charges before anyone notices.

To solve this, I built Aivora Gatekeeper — an AI Billing Firewall for OpenRouter-powered applications.

Features

Usage quota enforcement
Workspace budget caps
Cost estimation before requests
OpenRouter request gating
Subscription-tier limits
Analytics dashboard
JWT/RBAC foundation
67 automated tests

Why I Built It

Without protection, AI aggregator platforms can accumulate significant API costs from abuse, spam, or misconfigured agents.

Aivora Gatekeeper sits between users and AI providers, enforcing budgets and quotas before requests reach OpenRouter.

Tech Stack

Next.js
Supabase
OpenRouter
FastAPI
TypeScript
Python

GitHub

https://github.com/fokrulanthro16-eng/aivora-gatekeeper

Live Demo

https://aivora-gatekeeper.vercel.app

Feedback is welcome.

I Revived Intelliyash: A Local-First AI Builder for Low-End Machines

FOKRUL ISLAM — Thu, 28 May 2026 09:21:14 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge.

Project Links

Live Demo:

https://intelliyash.vercel.app/

GitHub Repository:

https://github.com/fokrulanthro16-eng/intelliyash

What I Built

Intelliyash is a local-first AI runtime and builder designed for people who want to use AI without depending on expensive cloud APIs, complex setup, or high-end hardware.

The core idea is simple:

From Idea to Local AI in Minutes.

Instead of asking users to understand model names, quantization, RAM limits, CLI tools, or API keys, Intelliyash aims to handle the hard parts automatically.

Users can describe what they want to build, and Intelliyash helps guide them toward a local AI assistant or app structure that can run on their own machine.

The project focuses on:

Local-first AI
No required API key
No cloud lock-in
Low-end hardware support
Simple UX for non-expert users
A polished AI product experience

Why I Revived This Project

Intelliyash started as an ambitious local AI experiment.

The original goal was to create an AI runtime that could work on low-end machines and automatically choose the right local model based on the user’s hardware.

But like many side projects, it became unfinished.

There were useful parts already inside the project, but it needed polish:

The user experience was not clear enough
The landing page needed a stronger story
The project needed a better submission narrative
Some routes needed build fixes
The product needed a clear before-and-after arc
The README and challenge story needed improvement

The GitHub Finish-Up-A-Thon Challenge was the perfect reason to come back, clean it up, and finally make it feel like a real product.

Before

Before this revival, Intelliyash was more of a technical experiment than a finished product.

It had:

A local AI runtime concept
A chat-style interface
Model and project sections
Some backend ideas
Early low-memory support
A basic structure for local AI workflows

But it lacked:

A polished landing page
Clear product positioning
A strong homepage message
A complete submission story
A clean “why this matters” explanation
A finished DEV Challenge presentation

The project existed, but the value was not immediately obvious to a new visitor.

After

After the polish work, Intelliyash now has a much clearer product experience.

The new version includes:

A cinematic landing page
Clear headline: “From Idea to Local AI in Minutes”
A stronger local-first AI message
Idea Drop Zone concept
Feature cards
Local-first architecture explanation
GitHub CTA
Working routes
Successful production build
Updated submission story
GitHub Copilot-assisted review and polish

Now the project communicates what it does much faster:

Intelliyash helps people go from an idea to a local AI app without needing API keys, cloud credits, or deep machine learning knowledge.

How GitHub Copilot Helped

GitHub Copilot helped me review the final project and improve the submission quality.

I used Copilot to:

Review the project for the GitHub Finish-Up-A-Thon Challenge
Improve the project story
Sharpen the README/submission direction
Create a stronger before-and-after narrative
Highlight key stats and product value
Check whether the project clearly showed a completed polish arc

One of the strongest ideas Copilot helped clarify was this:

We built Intelliyash because AI should work for everyone — not just people with API keys, cloud credits, and machine learning expertise.

Copilot also helped shape the key product message:

Time to first app: around 30 minutes instead of hours
Monthly cost: $0 instead of ongoing API costs
Hardware support: designed for low-end machines
Privacy: local-first by default
Vendor lock-in: zero

This helped turn the project from “just a codebase” into a stronger challenge submission with a clearer story.

The Main Problem

Most AI tools assume users already have:

API keys
Cloud credits
A powerful machine
Knowledge of models
Knowledge of prompts
Knowledge of inference tools
Time to configure everything manually

But many developers, students, and indie builders do not have all of that.

For many people, the problem is not imagination.

The problem is setup.

Intelliyash tries to solve that setup problem.

The goal is to make local AI feel approachable, especially for people on limited hardware.

Key Features

1. Local-First AI

Intelliyash is designed around the idea that AI should be able to run locally whenever possible.

This means:

Better privacy
Lower cost
Less dependency on cloud providers
More control for users

2. Low-End Hardware Support

The project is designed with low-memory machines in mind.

Instead of assuming everyone has a powerful GPU, Intelliyash focuses on making AI more accessible to people using lower-end devices.

3. Idea Drop Zone

The Idea Drop Zone is the main product concept.

The user writes an idea, and Intelliyash helps turn that idea into a local AI app direction.

Example:

“I want an AI assistant for my small shop that can answer customer questions.”

Intelliyash can then guide the user toward:

Assistant type
Suggested stack
Local-first architecture
Project plan
Possible model/runtime direction

4. No API Key Required

A major goal is to reduce dependency on paid APIs.

Cloud APIs are powerful, but they are not always accessible for everyone.

Intelliyash is built around the idea that AI should still be useful even when a user does not have cloud credits or API access.

5. Simple User Experience

I wanted the project to hide technical complexity behind a clean interface.

The user should not need to understand every model detail before getting started.

The product should feel simple:

Describe your idea.

Let Intelliyash guide the setup.

Build locally.

Tech Stack

The project uses:

Next.js
TypeScript
Tailwind CSS
Local AI runtime ideas
Vercel deployment
GitHub for source control
GitHub Copilot for review and polish

What I Fixed During the Finish-Up

During the revival process, I worked on:

Improving the landing page
Keeping the existing chat experience safe
Making the root route more product-focused
Preserving existing routes like /chat, /models, /projects, /playground, and /settings
Fixing frontend build issues
Cleaning up API client behavior
Testing the production build
Pushing final changes to GitHub
Preparing the submission story

The final build passed successfully, and the working tree was clean after the last push.

Challenges I Faced

The biggest challenge was balancing two things:

Keeping the existing project functionality safe
Making the project look polished enough for a public challenge submission

I did not want to destroy the existing app just to create a nice landing page.

So the goal was to improve the presentation while keeping the actual product structure alive.

Another challenge was build stability.

Some pages worked during development, but production build found issues that needed to be fixed before submission.

That was an important reminder:

A project is not really finished until it builds successfully.

What I Learned

This challenge reminded me that finishing a project is different from starting one.

Starting is exciting.

Finishing requires:

Cleaning
Testing
Explaining
Documenting
Fixing edge cases
Making the value obvious

I also learned that a strong project needs more than code.

It needs a story.

For Intelliyash, the story became:

AI should be local, affordable, private, and accessible — even on low-end machines.

What’s Next

Next, I want to continue improving Intelliyash with:

Better local model selection
More complete Idea Drop Zone generation
Project template export
Local assistant packaging
Better offline mode
More beginner-friendly setup
Stronger backend integration
More examples and demos

The long-term vision is:

A user drops an idea, and Intelliyash generates a local-first AI assistant or app that can run without cloud dependency.

Final Thoughts

I revived Intelliyash because I believe AI tools should be more accessible.

Not everyone has expensive hardware.

Not everyone has cloud credits.

Not everyone wants vendor lock-in.

But everyone should be able to build with AI.

That is what Intelliyash is trying to make possible.

This project went from an unfinished local AI experiment to a polished, challenge-ready product experience.

And now it finally feels ready to share.

Links Again

Live Demo:

https://intelliyash.vercel.app/

GitHub Repository:

https://github.com/fokrulanthro16-eng/intelliyash

Synapse-Overlord — A Local-First Autonomous Architecture Assistant Powered by Hermes Agent

FOKRUL ISLAM — Thu, 28 May 2026 02:37:50 +0000

Synapse-Overlord

A local-first autonomous architecture assistant built with Rust, Axum, and Hermes Agent.

Synapse-Overlord is an experimental AI engineering dashboard that can:

map software projects
inspect source code
perform structured tool-use
analyze architecture
generate engineering suggestions
sandbox execution safely
manage generated frontend projects

The core of the system is powered by Hermes Agent-style multi-turn tool orchestration.

Instead of generating a single text response, the system performs iterative reasoning through structured tools like:

file_list
file_read
file_search
sandbox testing
architecture analysis

Every tool call is logged visually inside the dashboard, allowing users to observe the full reasoning trace in real time.

This project was built for the Hermes Agent Challenge.

Demo

The dashboard shows Hermes Architect running real tool-use over the project.

The agent analyzes the codebase, lists files, reads selected files, searches code, and returns structured engineering suggestions.

Code

GitHub Repository:

https://github.com/fokrulanthro16-eng/synapse-overlord

Tech Stack

Rust 2024
Axum
Tokio
SQLite
Ratatui
Groq API
HTML/CSS/JavaScript

Final Notes

Synapse-Overlord demonstrates how Hermes Agent can power transparent autonomous engineering workflows through structured tool-use, sandbox validation, and real-time reasoning visualization.

Building EIDOLON OS — A Local-First AI Cognitive Operating System

FOKRUL ISLAM — Sat, 23 May 2026 18:12:31 +0000

I’ve been experimenting with a different direction for personal AI:

not cloud chatbots,
not another wrapper,
but a local-first cognitive operating system.

So I built EIDOLON OS.

An experimental AI system that combines memory, vision, semantic retrieval, CCTV intelligence, workflow replay, and local agent actions into one modular platform.

EIDOLON OS

A local-first AI cognitive operating system designed to transform raw desktop activity into structured, searchable memory.

Current Capabilities

AI memory engine
PDF intelligence
Voice ingestion
YOLO/OpenCV vision pipelines
CCTV/video analysis
Replayable activity timelines
Agent workflows
Semantic search
Daily activity summaries
Temporal memory graphs

Dashboard

[UPLOAD SCREENSHOT HERE]

Vision / CCTV Intelligence

EIDOLON can analyze uploaded videos and camera feeds using local computer vision pipelines.

Features include:

motion detection
object detection
YOLO vision analysis
event timelines
temporal memory storage

[UPLOAD SCREENSHOT HERE]

Agent Workflows

The system also includes a local action/agent layer capable of:

opening applications
summarizing activity
replaying sessions
workflow intelligence
contextual memory actions

[UPLOAD SCREENSHOT HERE]

Architecture

Built with:

Next.js
FastAPI
TypeScript
Python
OpenCV
YOLO

Everything runs locally.

No cloud dependency.
No telemetry.
No external memory APIs.

Why I Built This

Most AI systems today are stateless chat interfaces.

I wanted to explore something different:

an AI system that continuously remembers, observes, structures, and retrieves contextual information like a cognitive layer for the machine itself.

Still early.
But the foundation is becoming real.

GitHub

https://github.com/fokrulanthro16-eng/eidolon-os