DEV Community: FOKRUL ISLAM

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