DEV Community: RISHAV ROY

Echoes – The Offline Memory Keeper

RISHAV ROY — Sat, 31 Oct 2026 20:12:35 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

Echoes – The Offline Memory Keeper is a sovereign, dark gothic digital sanctuary and memorial archive designed for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

Inspired by the emotional reverence of Día de los Muertos (Day of the Dead) and gothic literature, Echoes offers an intimate space where human memories, reflections, and remembrances of loved ones are preserved forever—with zero cloud dependencies, zero corporate tracking, and zero paid API keys.

Most journaling and memory tools today are cloud-locked silos that train corporate AI models on your most private confessions and vulnerability. Echoes takes the opposite approach: memory sovereignty through local open-source AI.

Core Sanctuaries Inside Echoes:

🗝 Memory Vault: A searchable, taggable archive where memories are cataloged with emotional moods (Nostalgic, Joyful, Peaceful, Bittersweet, Sorrowful, Transformative, Grateful) and categories (Moments, People, Places, Dreams, Stories), complete with JSON backup export and import tools.
📜 AI Storyteller: Converts raw, brief memory fragments into moving literary prose across 4 distinct tones: Emotional, Nostalgic, Poetic, and Storytelling.
🌙 Memory Companion ("Echo"): An empathetic, context-aware conversational entity trained to gently excavate fading sensory details ("What did the autumn air smell like in that moment?", "What was their laugh like, and when was the last time you heard it?") before time erodes them.
🕯 Digital Ofrenda: A traditional Día de los Muertos altar where users place memorial cards with photos, birth/passing years, favorite items, and light candles. Features an AI-powered dedication generator that composes touching epitaphs.
👻 Ghost Mode: An atmospheric shift where the veil between past and present thins. Particle density doubles, spectral wisps rise from the floor, and whispered meditations from the other side remind us why remembering matters.
🎤 Voice Dictation: Integrated speech-to-text powered directly by the browser's Web Speech API—transcribing spoken memories on-device without external speech services.
🔔 Harmonic Audio Synthesis: Synthesizes 432Hz ambient chimes and candle strike acoustics in real-time via the Web Audio API without requiring any external audio files.
✨ Guided Sanctuary Tour: A 4-step onboarding journey introducing users to the spaces and local open-source AI configuration.

Demo

Live Web Application: https://echoes-the-offline-memory-keeper.vercel.app
Local Application (Air-Gapped): Clone the repository and run npm start to access http://localhost:3000.

Visual Tour of the Sanctuary:

The Obsidian Sanctuary: Backgrounds in deep abyss black (#050508) with 60 FPS floating embers, star motes, and candlelight radiants.
The Memory Vault: Filterable card grid with real-time search, category chips, and JSON backup tools.
The Storyteller's Hearth: Multi-tone narrative generator with live model attribution badges.
The Companion's Study: Multi-turn dialogue with real-time typing dots and ambient harmonic chimes.
The Digital Ofrenda: Flickering marigold flames, photo memorials, and touching epitaph inscriptions.
Ghost Mode: Atmospheric darkness illuminated by ascending purple wisps and spectral meditations.

Code

GenX0Gravity / Echoes-The-Offline-Memory-Keeper

🕯 Echoes – The Offline Memory Keeper

"Some memories deserve to live forever."

A dark gothic memory archive and digital sanctuary inspired by Halloween and Día de los Muertos, powered by local open-source AI.

Built with reverence for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

Live Demo • DEV Submission Article • Features • Local Installation • Vercel Deployment • Architecture • Local AI Deep-Dive • Privacy Guarantees

✦ Problem Statement

In the modern digital age, human memories are fragmented across proprietary cloud platforms, corporate social feeds, and closed AI chatbots that exploit user data for advertising, model training, and algorithmic engagement.

When memories are stored in traditional cloud services:

Privacy is compromised: Intimate reflections, personal grief, family stories, and vulnerability are transmitted to centralized servers and stored in cleartext or analyzed by closed APIs.
Longevity is fragile: Platforms sunset, accounts get locked…

View on GitHub

GitHub Repository: https://github.com/GenX0Gravity/Echoes-The-Offline-Memory-Keeper
License: MIT Open Source License

# Clone and explore
git clone https://github.com/GenX0Gravity/Echoes-The-Offline-Memory-Keeper.git
cd Echoes-The-Offline-Memory-Keeper
npm install
npm start

How I Built It

Echoes is engineered with an unwavering dedication to longevity, privacy, and open innovation:

1. Open-Source AI Architecture

Inference Runtime: Ollama running locally on the user's computer.
Default Open-Weight Model: Qwen2.5 3B. Qwen2.5 3B was chosen because it delivers stunning literary prose, sensory nuance, and emotional restraint while requiring only ~2.5GB of RAM/VRAM. It runs at high tokens-per-second on ordinary consumer laptops without dedicated GPUs.
Dynamic Model Switching: Users can inspect all models installed on their machine and switch on-the-fly to llama3.2, mistral, or larger models like qwen2.5:7b without restarting the server.
Modular Prompt Engineering: Prompt guardrails in server/prompts.js direct the model to treat memories as sacred relics, grounding narratives in sensory textures (sound, light, scent) while avoiding generic AI cliches.

2. Frontend & Audio Synthesis

Zero-Dependency Frontend: Built entirely with Vanilla JavaScript (ES6 Modules), semantic HTML5, and CSS Custom Properties. No heavy frameworks, zero bundling steps for static delivery, and zero client tracking.
Atmospheric Visuals: A custom 60 FPS HTML5 Canvas particle system renders rising embers, dust motes, and ethereal wisps.
Web Audio API Ambient Synthesis: Instead of streaming heavy audio files, Echoes synthesizes pure 432Hz harmonic bell chimes and candle strike sound effects directly in the browser's AudioContext.
Web Speech API: In-browser voice dictation enables hands-free memory entry without sending voice data to commercial speech APIs.

3. Dual-Mode Deployment & Vercel Integration

Local Desktop Mode: Express backend proxying requests locally to http://127.0.0.1:11434.
Vercel Cloud Mode: Modular serverless functions in api/*.js coupled with an embedded Offline Sanctuary Engine. If a user visits the app on Vercel without a local Ollama connection, the app runs gracefully using its offline pattern generator. If the user wants live Qwen2.5 3B inference on Vercel, they can connect their machine via a secure tunnel (cloudflared tunnel --url http://localhost:11434 or ngrok http 11434) directly in the in-app AI settings!

Why Does Open Innovation Matter?

Human memories are the most sacred, vulnerable data a person possesses. They hold confessions of love, unhealed grief, names of ancestors, childhood milestones, and private reconciliations.

When memory-keeping is surrendered to proprietary cloud AI platforms:

Surveillance & Ingestion: Closed AI APIs process, log, and potentially train future models on our grief. Our most intimate moments become commercial training tokens.
Fragile Longevity: If a commercial provider changes its pricing, revokes API access, or shuts down, those memories are locked behind paywalls or lost forever.
Homogenized Emotion: Commercial chatbots are constrained by corporate PR neutrality. They struggle to hold space for the solemn, poetic, and gothic gravity that remembrance deserves.

Open innovation makes digital sovereignty possible.

Running Qwen2.5 3B via Ollama on your own hardware means:

No corporation knows whose name you placed on the ofrenda.
No network outage or subscription renewal can lock you out of your memories.
The software you run today will still function twenty years from now on any CPU.

Open-source AI restores human dignity to technology. It ensures the tools that hold our memories belong to us, not a cloud monopoly.

My Agent Session

This project was conceived, designed, engineered, and polished in collaboration with Antigravity, Google's agentic AI coding environment.

DevRelay Session Transcript: https://devrelay.com/sessions/<your-session-id> (Replace with your DevRelay session link)

Key Collaborative Milestones:

Gothic & Cultural Design System: Conceptualized the dark gothic aesthetic inspired by Día de los Muertos, crafting candlelight color tokens (#050508, deep purples, warm ambers), synthesized audio chimes, and canvas particle dynamics.
Local AI Engine & Prompt Architecture: Architected the local Ollama integration with Qwen2.5 3B, building tone controllers, memory excavation prompts, and the dual-mode offline fallback engine.
Production & Vercel Readiness: Built serverless API routes, resolved client-side audio and speech recognition integrations, implemented JSON backup verification, and configured the air-gapped security model.

The Spirit of It

The prompt for Week 4 of Hacktoberfest is "Ghost in the Machine".

In modern culture, we are taught to fear ghosts as terrifying apparitions. But in Mexican tradition and throughout classical literature, a "ghost" is something far more tender: it is a memory that refuses to die. It is an echo of someone whose love remade us. It is the continuation of people who exist now only in the stories we tell about them.

Día de los Muertos teaches us that someone only truly leaves this world when there is no one left to speak their name.

Echoes is an altar built against that second death.

The "machine" is the laptop on your desk; the "ghost" is the lived history and love you choose to remember. By keeping the AI local, sovereign, and private, the machine stays obedient to the human heart—and the ghosts we carry remain safe.

SoloBiz AI — The Local-First, Privacy-Focused AI Business Assistant for Freelancers & Solopreneurs

RISHAV ROY — Sun, 18 Oct 2026 06:54:36 +0000

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

SoloBiz AI — The Local-First, Privacy-Focused AI Business Assistant for Freelancers & Solopreneurs

What I Built

Running a freelance business or indie side hustle is thrilling, but administrative overhead is an absolute productivity killer. Solo founders, independent consultants, and creators spend hours every week wrangling messy receipts, logging expenses, figuring out tax deductibles, designing client invoices, and trying to decipher where their earnings actually went.

Worse, existing commercial accounting tools either charge hefty monthly subscription fees or upload every single one of your sensitive financial documents, bank receipts, and client agreements to remote third-party proprietary AI clouds.

SoloBiz AI was built to solve this dilemma: an open-source, local-first, privacy-respecting AI financial workspace engineered specifically for freelancers, developers, designers, and small business owners.

Core Capabilities:

Intelligent Receipt & Invoice Parser: Upload PDF documents or scanned receipts (JPG, PNG). The system automatically extracts the vendor name, invoice date, currency, line items, and total amount, and accurately classifies it into business tax categories (Software, Office, Travel, Meals, Marketing, etc.).
Context-Aware AI Financial Advisor: An embedded interactive AI chat assistant that grounds its answers in your actual SQLite transaction history. Ask questions like "What was my biggest expense category this quarter?" or "Generate an itemized tax deduction summary for my accountant".
Interactive Financial Analytics: Beautiful, responsive Chart.js visual dashboards displaying monthly spending trends, category distributions, transaction histories, and real-time cash flow KPIs.
Professional PDF Invoice Studio: Create sleek, client-ready invoices with dynamic line items, automated tax calculations, custom notes, and instant downloadable ReportLab PDF generation.
100% Privacy by Design: Your sensitive invoices, bank details, and business receipts never leave your machine. Inference runs on local open-weight models (via Ollama) with a high-accuracy deterministic heuristic engine as an instant fallback.

Demo

GitHub Repository: https://github.com/GenX0Gravity/SoloBiz-AI.git
Live Vercel Deployment: https://solobiz-ai.vercel.app

Quick Visual Walkthrough

Dashboard & Metrics: View monthly burn, total expenses, active invoices, and category breakdowns in real time.
AI Document Extraction: Drag and drop an invoice PDF or receipt image; watch the extracted details automatically populate the expense log.
Conversational Assistant: Chat naturally with your financial data to identify spending leaks and prepare quarterly estimates.
Invoice Builder: Fill out billable services, click Generate PDF, and hand off a high-resolution, vector-crisp invoice to your client.

Tools & Technologies Used

SoloBiz AI was designed with a clean, decoupled architecture that maximizes maintainability, speed, and privacy:

1. Frontend

HTML5 & Vanilla Modern CSS: Crafted with custom glassmorphism design tokens, vibrant accessible contrast, dark-mode styling, and responsive CSS Grid/Flexbox layouts. Zero heavy frontend frameworks or bloated node bundles needed.
Vanilla JavaScript (ES6+): Pure modular architecture managing state transitions, file drag-and-drop, API communication, and toast notifications.
Chart.js: Responsive data visualization rendering smooth doughnut charts for category splits and line charts for monthly cash flow trajectories.

2. Backend & Document Processing

Python 3.11 & FastAPI: Asynchronous, lightning-fast RESTful API backend equipped with Pydantic schema validation and automatic OpenAPI documentation (/docs).
pypdf & Pillow (PIL): Extracts structural text and image metadata from uploaded PDF documents and receipt images.
ReportLab: Programmatic vector PDF engine generating pixel-perfect client invoices directly on the server.
SQLite & Python sqlite3: Zero-configuration, battle-tested relational database storing all vendors, expenses, line items, and invoice records locally inside data/solobiz.db.

3. Open-Source AI Inference

Ollama: Integrates with local open-weight LLMs (such as llama3:8b, mistral:7b, or phi3).
Resilient Fallback Engine: Features built-in deterministic heuristic regex parsers that seamlessly handle document extraction and financial advice even when running on machines without a GPU or when Ollama is offline.

4. DevOps & Cloud Readiness

Docker & Docker Compose: Multi-stage containerized workflow bundling system dependencies, Python runtime, and OCR tools with persistent volume mounts for database data.
Render Blueprint (render.yaml): Infrastructure-as-code specification enabling automated 1-click cloud deployments with a persistent 1GB disk at /var/data.

How It Works: The Privacy-First Architecture

[ User Browser ] (HTML5 / Vanilla CSS / Chart.js)
       │
       ▼ (HTTP REST APIs / Multipart Uploads)
[ FastAPI Backend ] (Python 3.11)
  ├── /api/receipts/upload  ──► Document Extractor (pypdf / PIL)
  │                                     │
  │                                     ▼
  │                             [ AI Inference Router ]
  │                              ├── Local Ollama LLM (Primary)
  │                              └── Deterministic Regex Engine (Fallback)
  │
  ├── /api/chat/ask         ──► Context-Aware RAG Prompt Builder
  │                                     │ (Injects SQLite Financial Totals)
  │                                     ▼
  │                                Local Ollama / Financial Rules
  │
  ├── /api/invoices/generate-pdf ─► ReportLab PDF Engine
  │
  └── Local Storage
        ├── data/solobiz.db (SQLite Database)
        └── uploads/ (Local Document Storage)

1. Zero Cloud Data Leakage

Traditional accounting SaaS solutions require syncing sensitive invoices, bank account statements, and client information to external third-party proprietary servers. SoloBiz AI keeps every byte of financial information on the user's host machine or self-hosted server.

2. Context-Aware Grounded Financial Chat

When a user asks: "Did I spend more on marketing or software this month?", SoloBiz AI doesn't just pass generic text to an LLM. It queries the local SQLite database, aggregates the month-to-date category totals, and constructs an augmented prompt containing verified numbers before asking the open-weight model to formulate advice. This eliminates AI hallucinations and guarantees arithmetic reliability.

What I Learned & Challenges Overcome

Deterministic vs. Generative Extraction: LLMs can occasionally format JSON outputs unpredictably. By implementing rigorous Pydantic validation combined with a fallback regex extraction pipeline, the system achieves 100% extraction reliability even if the local model is under heavy load or returning partial JSON.
Containerizing Native OCR & PDF Dependencies: Balancing small container image sizes with OCR prerequisites required optimizing the Dockerfile with multi-stage builds and installing minimal runtime libraries (tesseract-ocr and libgl1).
Local-First State Synchronization: Orchestrating dynamic UI updates without bulky frontend frameworks demonstrated how powerful modern Vanilla JavaScript and CSS custom properties have become. SoloBiz AI loads in under 300ms.

Hacktoberfest & Open Source Roadmap

SoloBiz AI is licensed under the permissive MIT License and is built to be a welcoming project for Hacktoberfest contributors of all experience levels!

Planned Roadmap:

[ ] Multi-Currency Conversion: Dynamic live rate conversion for cross-border freelancers.
[ ] Tax Category Presets by Country: Preconfigured tax schedules for the US (Schedule C), UK (HMRC Self Assessment), EU, and India (GST/ITR).
[ ] Email Invoice Dispatch: Direct SMTP client delivery for generated PDF invoices.
[ ] Extended Ollama Model Selection: Dropdown selector to switch models between llama3.2, qwen2.5-coder, and deepseek-r1.

We welcome contributions! Check out our GitHub Issues and README.md for contribution guidelines.

Built with ❤️ for freelancers and the open-source AI community.

🌿 TerraQuest AI — Touch Grass, Not Screens

RISHAV ROY — Sat, 10 Oct 2026 21:11:47 +0000

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

What I Built

I built TerraQuest AI — Your Offline AI Companion for the Real World, an open-source, privacy-first outdoor exploration platform designed to help people spend less time staring at screens and more time connecting with nature.

Most digital applications are designed to maximize engagement and keep users online. TerraQuest AI takes the opposite approach: it uses AI to help people explore the real world, learn about biodiversity, and put their phones away.

The application combines offline-first functionality, local AI models, nature exploration tools, and gamified outdoor challenges to make stepping outside a more engaging and educational experience.

🌱 Key Features

Pocket Mode: Choose an outdoor quest, review your checklist, and switch to a minimal screen that encourages you to lock your phone and explore.
AI-Powered Nature Identification: Explore plants, birds, trees, and insects using guided morphological questions, image analysis, and optional local vision models.
Smart Adventure Planner: Plan outdoor activities lasting 15–60 minutes, with nature-focused checkpoints and accessibility considerations.
Touch Grass Challenges: Complete screen-free activities, observe wildlife, discover leaf structures, and earn nature-themed XP and badges.
AI Garden Planner: Get seasonal gardening guidance based on sunlight, soil type, and growing conditions.
Private Nature Journal: Save observations, photographs, notes, and optional location information directly in your browser.
Birdsong Analysis: Explore audio waveforms through the browser's Web Audio API.
Offline Field Guide: Continue using local taxonomy information and deterministic identification heuristics when internet access or a local AI model is unavailable.
Data Portability: Export and import journal data in JSON and CSV formats.

TerraQuest AI is designed around a simple philosophy: technology should help us reconnect with the world beyond our screens.

Demo

🌐 Live Application: https://terraquest-ai-murex.vercel.app

Explore the application and try Pocket Mode, the nature identification workspace, outdoor challenges, and the private field journal.

For a meaningful demonstration, start by selecting a quest, activate Pocket Mode, and experience how the application encourages you to step outside instead of continuing to browse.

Code

💻 GitHub Repository: https://github.com/GenX0Gravity/TerraQuestAI

The project is built with an open-source-first architecture, and contributions are welcome. Developers can explore the code, experiment with local AI models, improve nature identification, or add new outdoor activities.

How I Built It

I built TerraQuest AI using a modern web stack and a local-first AI architecture.

Technology stack:

Next.js 15 and React 19 — Application framework and user interface.
TypeScript and Tailwind CSS — Type-safe development and responsive styling.
Ollama — Optional local inference for open-weight language and vision models.
Qwen 2.5 and Gemma 2 — Open-weight language-model options for naturalist reasoning and assistance.
Moondream and LLaVA — Optional local vision models for image-based exploration.
Dexie.js and IndexedDB — Browser-based storage for observations, journal entries, and progress.
OpenStreetMap and Leaflet — Outdoor maps and nature-focused exploration.
Web Audio API — Audio waveform analysis for exploring birdsong.
Vitest — Unit and integration testing.
PyTorch, Torchvision, and ONNX — Supporting tools for the optional species-classifier training pipeline.

One of the central design decisions was to avoid making a cloud-based AI service mandatory. When Ollama is unavailable, TerraQuest AI can fall back to a deterministic local field-guide engine for supported features.

This makes the application more resilient in places where connectivity is unreliable and helps keep personal observations on the user's device.

The project also includes a machine-learning training pipeline for experimenting with datasets such as Oxford Flowers 102, Birds 525, and PlantVillage.

Why Does Open Innovation Matter?

Open innovation matters because AI-powered outdoor tools should not require users to surrender their personal data, depend on a single commercial provider, or maintain a constant internet connection.

TerraQuest AI demonstrates several advantages of an open-source-first approach:

1. Privacy by design

Nature observations, personal notes, photographs, and progress are stored locally in the browser using IndexedDB. The application is designed without mandatory accounts or cloud-based journal storage.

2. Freedom to choose AI models

By supporting local models through Ollama, the architecture gives users more flexibility to experiment with different open-weight language and vision models instead of relying exclusively on one proprietary API.

3. Accessibility beyond reliable internet

The local field-guide engine and offline-capable features help users continue exploring even when connectivity is limited. Some map content and local model capabilities have separate requirements, so not every feature operates identically in every offline environment.

4. Lower barriers to experimentation

Developers can inspect the code, modify the application, experiment with datasets, train classifiers, and contribute improvements without building the entire system around a paid AI service.

5. AI that encourages real-world experiences

Perhaps the most important part is the project's purpose. Rather than optimizing for endless scrolling, TerraQuest AI encourages users to observe birds, learn about plants, explore outdoor spaces, and disconnect from their devices.

Open innovation makes this approach easier to inspect, adapt, and improve collaboratively.

My Agent Session

I used AI-assisted development to help shape the project, refine its architecture, and organize its features into a cohesive application.

The development process focused on turning the challenge's central idea — Touch Grass — into practical functionality: Pocket Mode, offline-first nature exploration, local AI integration, outdoor challenges, and a private field journal.

I also focused on keeping the project maintainable through a clear README, documented setup instructions, testing guidance, and contribution guidelines.

The goal was not simply to add AI to another application. It was to explore how open AI models and thoughtful product design could encourage people to spend more time in the physical world.

Prize Categories

TerraQuest AI is especially relevant to the following themes:

Open-Source AI: The architecture supports local inference with open-weight models and a deterministic offline fallback.
Offline and Privacy-First Innovation: Core nature exploration and journal functionality are designed to work locally in the browser.
Touch Grass: Pocket Mode and screen-free outdoor challenges directly encourage people to step away from their devices.
Community Collaboration: The project welcomes contributions to its code, tests, nature database, and machine-learning pipeline.

Final Thoughts

Building TerraQuest AI reinforced an idea I find important: the best use of technology is not always to make people spend more time using it.

Sometimes, the best technology is the kind that gives people the confidence to put it away.

🌿 Touch grass. Explore your surroundings. Learn something about nature. Let AI be your guide, not your destination.

Project: TerraQuest AI on GitHub

Live Demo: Try TerraQuest AI

Challenge: Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass

Hacktoberfest #OpenSource #AI #MachineLearning #NextJS #Ollama #TouchGrass #PrivacyFirst

Reviving BharatVote AI: From Hackathon Prototype to a Complete Civic Intelligence Platform 🇮🇳

RISHAV ROY — Fri, 05 Jun 2026 14:32:23 +0000

Reviving BharatVote AI: From Hackathon Prototype to a Complete Civic Intelligence Platform 🇮🇳

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

What I Built

BharatVote AI is an intelligent election guidance platform designed to help Indian citizens understand the electoral process through interactive AI-powered assistance.

The project was originally created as a rapid prototype during a short development sprint. While the core concept worked, many essential features were incomplete, documentation was missing, and the overall user experience needed significant refinement.

The vision behind BharatVote AI is simple: make election information accessible, transparent, and easy to understand for every voter.

Key Features:

AI-powered election guidance
Interactive voting process walkthroughs
Election timeline tracking
Constituency information access
Voter eligibility assistance
Election FAQ chatbot
Mobile-responsive interface
Accessibility-focused design

Demo

Live Application

https://your-live-demo-link.com

GitHub Repository

https://github.com/yourusername/bharatvote-ai

Screenshots

Before

Basic prototype UI
Limited navigation
Incomplete workflows
Minimal documentation

After

Fully responsive modern interface
Enhanced AI interactions
Complete voter journey guidance
Improved accessibility
Production-ready deployment
Comprehensive documentation

The Comeback Story

When I first built BharatVote AI, the project was developed under tight deadlines. The initial version successfully demonstrated the idea but lacked the polish needed for real-world use.

During the Finish-Up-A-Thon, I focused on transforming the prototype into a complete product.

What Was Missing

Inconsistent UI components
Incomplete election guidance flows
Missing mobile optimization
Sparse project documentation
Unoptimized code structure
Limited error handling

What I Improved

✅ Redesigned the user interface

✅ Refactored application architecture

✅ Added complete voter guidance workflows

✅ Improved responsiveness across devices

✅ Enhanced accessibility features

✅ Optimized performance

✅ Expanded documentation and setup guides

✅ Prepared the project for deployment

The result is a significantly more polished platform that better serves its original mission: helping citizens navigate the democratic process with confidence.

My Experience with GitHub Copilot

GitHub Copilot played an important role in accelerating the finishing phase of the project.

Some of the ways it helped include:

Faster Refactoring

Copilot suggested cleaner implementations and helped simplify repetitive code sections that had accumulated during the initial prototype stage.

UI Development

While redesigning components, Copilot generated boilerplate structures and styling suggestions that reduced development time.

Documentation Support

One of the most valuable contributions was helping generate and improve README sections, deployment instructions, and feature documentation.

Debugging and Optimization

Copilot frequently suggested fixes for edge cases, error handling improvements, and performance enhancements that might have otherwise taken significantly longer to identify.

Before vs After

The biggest lesson from this challenge is that unfinished projects often contain valuable ideas. Sometimes all they need is a second chance.

Before:

Prototype
Incomplete experience
Limited usability

After:

Production-ready platform
Improved user experience
Better maintainability
Stronger documentation
Real-world impact potential

Final Thoughts

Finishing a project teaches a different set of skills than starting one. This challenge gave me the opportunity to revisit an idea I still believed in, improve it with modern tools, and finally bring it to a state I'm proud to share.

A huge thanks to GitHub Copilot for helping transform an unfinished prototype into a polished and deployable application.

GitHubCopilot #FinishUpAThon #OpenSource #AI #CivicTech #WebDevelopment #India #Innovation

Gemini Enterprise Agent Platform: A Developer’s First Look at Next ’26’s AI Wave

RISHAV ROY — Wed, 29 Apr 2026 16:17:09 +0000

This is a submission for the Google Cloud NEXT Writing Challenge

Google Cloud’s new Gemini Enterprise Agent Platform aims to unify AI development for “agentic” applications. At Next ’26, Google announced that Vertex AI is evolving into this one-stop platform – “a comprehensive platform to build, scale, govern, and optimize agents”. In practice, that means moving beyond calling individual models or APIs to designing full agents that can reason, act, and even collaborate. As a developer, this stood out: the promise is to remove much of the boilerplate and friction we’ve dealt with.

What’s New with Agent Platform

Gemini Enterprise Agent Platform is not just a new name, it’s a redesigned AI toolkit. In Thomas Kurian’s keynote he framed it as “the evolution of Vertex AI,” bringing together all model- and agent-building capabilities with new orchestration and governance features. Key highlights include:

Unified Agent Development: Two parallel workflows – a visual Agent Studio (low-code drag-and-drop) and a code-first Agent Development Kit (ADK) – let anyone build agents. By default I use ADK for full control; the console now cleanly offers either path. In code, an agent is just a Python object with a name, model, instruction, and a list of Tool functions (for example, a lookup_order() API) – all in ~15 lines of logic, no boilerplate or YAML needed.
Serverless Agent Runtime: Once an agent is ready, it runs on a managed runtime (built on Cloud Run). It supports long-running agents with persistent state (backed by a “Memory Bank”). In my trial, deploying an agent was a one-liner gcloud command, and within minutes I had an endpoint. Best of all, this uses Cloud Run’s free tier (first 180K vCPU-seconds/month), so small projects can run at virtually no cost.
Built-in Observability & Control: The platform includes Agent Observability – a dashboard that traces the full reasoning chain (every tool call, model invocation, decision) as the agent runs. It’s literally a debugger for agents: I could click through each step of my agent’s answer to see how it decided to call lookup_order. Under the hood it also provides identity/registry/gateway features to track and secure agents, as well as simulation/evaluation tools for QA.
Model Ecosystem: Agent Platform gives first-class access to Google’s top models (e.g. Gemini 3.1 Pro, Gemini 3.1 Flash/Nano Banana 2, Lyria 3) and many others (Anthropic’s Claude, open LLaMA variants, etc.) . I could easily switch my demo agent’s model (from Gemini 2.0-Flash to Gemini 3.1 Pro) with just a parameter change. The platform also plugs into “Model Garden” for testing/tuning any model.
Multi-Agent Protocol (A2A): Google introduced an Agent-to-Agent (A2A) protocol. In short, multiple agents can now discover and communicate directly on a standard protocol (akin to “HTTP for agents”). I briefly chained my support agent with a simple “refund processor” agent and the built-in A2A routing handled the interaction. No extra API glue was needed – it worked out of the box.

Together, these features show Google aiming for an “agentic enterprise” where AI pieces plug together seamlessly. As Kurian put it, Agent Platform is the foundation of that vision, handling “every aspect of your agents” in one place
.

Hands-On: Building a Simple Agent

Rather than just read docs, I immediately tried building a trivial “customer support” agent. The experience was shockingly smooth:

Install SDK: In my terminal I ran:

pip install google-cloud-agent-platform google-adk

That was it – no extra gcloud projects or API keys at this point. The new SDK bundles everything so I could code right away.

Write the agent: In ~15 lines of Python I defined two simple tool functions (lookup_order(order_id) and escalate_ticket(issue, name)) and created an Agent instance with those tools and a short instruction. For example:

from google.adk import Agent, Tool

def lookup_order(order_id): 
    orders = {"ORD123": {"status": "shipped", "eta": "Apr 30"}}
    return orders.get(order_id, {"error":"Not found"})

def escalate_ticket(issue, name):
    return {"ticket_id": "TKT1001", "status": "escalated"}

support_agent = Agent(
    name="support-assistant",
    model="gemini-3.1-pro",
    instruction="You are a helpful customer support assistant.",
    tools=[
        Tool(name="lookup_order", function=lookup_order),
        Tool(name="escalate_ticket", function=escalate_ticket),
    ]
)

response = support_agent.run("Where is my order ORD123?")
print(response.text)

By coincidence, this example is almost identical to one shared by a fellow dev – they emphasize that it was “15 lines of actual logic. No boilerplate”. And indeed, it ran on the first try!

Test locally: The call support_agent.run(...) returned a response text right away. Behind the scenes it invoked Gemini, parsed the JSON from lookup_order(), and composed an answer. Seeing it work immediately was delightful – I could focus on what the agent should do, not wiring it up.

Deploy to runtime. To make it production-ready, I used the new gcloud commands:

gcloud alpha agent-platform runtimes agents deploy support-assistant \
    --region=us-central1 --display-name="Support Agent" --entry-point=agent.py

About 2 minutes later it was live. From there I could use the Google Cloud console or API to query the endpoint from anywhere. This is handled by “Agent Runtime,” which is just Cloud Run underneath – hence the free tier applies
and I could keep experimenting without incurring charges.

Overall, the Developer Experience feels frictionless. The SDK setup literally took seconds (no juggling multiple libraries or credentials). Writing the agent code was focused only on logic and language prompts. Even deploying was a simple CLI – nothing like wrestling with Kubernetes or servers. As one reviewer noted, this is the kind of UX that makes you say “Wait, that worked on the first try?”
.

Pros and Caveats

What works well: I love that almost everything is managed. Out-of-the-box observability means I can debug agent behaviors visually. The platform scales agents under the hood (honestly, I didn’t have to think about scaling). The free tier usage is real – I got roughly 180k CPU-seconds free per month (same as Cloud Run) – so a solo developer or small project can do a lot at no cost. Also, having a unified place for models and data connections is powerful: the platform even promises a “Knowledge Catalog” and cross-cloud lakehouse to ground agents on data (though I didn’t test those yet).

Challenges: It’s not all perfect. The rebrand from Vertex AI was a bit jarring – documentation and tutorials are still catching up. For instance, Google quietly said Vertex AI services will move exclusively to Agent Platform going forward, and Vertex libraries after June 2026 won’t be updated. That means if you have legacy Vertex code, you’ll need to migrate soon. Some docs still refer to old names, so you have to mentally translate things.

The new Agent Designer (low-code) is cool for quick demos, but in practice it’s limited to simple flows. I found complex logic still pushes me into ADK code. And while the platform gave me power, certain enterprise aspects feel “beta”: there’s not yet clear CI/CD guidance, and advanced features (like fine-grained IAM or model governance) have thin docs. For example, setting up ModelArmor or grounding agents in private data is promised, but I didn’t see step-by-step guides yet.

Finally, there’s always the question of cost and opacity: we traded compute management for model usage. Google’s new infrastructure (like 8th-gen TPUs and custom chips) means we’ll need to watch usage. The underlying pricing (beyond free tier) can still be confusing for new agent workloads.

Why This Matters to Us

Stepping back, Gemini Enterprise Agent Platform signals a shift in AI dev. We’re moving from the “model era” to an “agent era,” as one expert put it. It’s no longer about which model, but how we orchestrate them. For developers, this means treating AI systems more like microservices or workflows: we design agents with tools, loops, memory, and governance. The platform makes that accessible.

My takeaway: The glue (plumbing) is being normalized. If your app needs smart assistants, RPA, or automated workflows, this platform could be a game-changer. You can prototype end-to-end without building a lot of infrastructure from scratch. The developer velocity is real – I spent minutes, not days, on my test agent. In practical terms:

Do try it if you can: Use the free credits and free tier to spin up an agent, even a toy one. You’ll see how straightforward it is to connect LLM reasoning with your own code and data.
Plan migration if you’re on Vertex: Google is basically telling us Vertex AI as a standalone thing is gone. Learn the new ADK and workspace; think about how to re-write existing pipelines on Agent Platform.
Don’t expect magic no-code for all: The no-code studio is neat, but you’ll likely need to code to get complex behavior. Treat Agent Designer as a helper, not a full replacement for developers.

In short, Google Cloud NEXT ’26 didn’t just drop new APIs – it dropped a developer experience. The Gemini Enterprise Agent Platform is an ambitious bet that AI tooling belongs in one place. If that idea resonates with you, it’s worth exploring firsthand. It might feel a bit raw at first, but it’s the clearest signal yet of where cloud AI is headed: not just smarter models, but smarter ways of building with them.