DEV Community: Shreyas Guha Neogi

Animas - Mourning the Dead 💀

Shreyas Guha Neogi — Sun, 01 Nov 2026 06:59:47 +0000

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

What I Built

For this year's "Ghost in the Machine" theme, I wanted to explore the intersection of memory, digital permanence, and Día de los Muertos. But as I started designing a digital ofrenda (memorial altar) to house family histories, letters, and spoken anecdotes, I hit a moral wall: I refuse to upload my family’s grief, intimate memories, and ancestral stories to a corporate cloud API to be monetized or used as training data.

So, I built Ánimas: The Sovereign 3D Ofrenda.

Ánimas is a 100% offline, privacy-first interactive memorial. It transforms fragmented family archives into a highly atmospheric, 16-bit retro-pixel 3D sanctuary. Using a locally running Gemma model and an offline RAG (Retrieval-Augmented Generation) pipeline, users can ask questions about their family history. The "ghost in the machine" channels these archives, answering with strict, grounded evidence, while the 3D WebGL environment dynamically reacts to the emotional sentiment of the memory—shifting lighting, candle flicker, and swirling marigold petals.

Demo

ais-dev-x3ntfjfg52mlohn4xx7t2b-131186369993.asia-southeast1.run.app

Code

shrguhaneogi-pixel / -NIMAS

Ghost in the Machine

(Note: Because Ánimas is designed to run 100% locally on your machine for absolute privacy, this video demonstrates the local execution of the Next.js/FastAPI monorepo)

How I Built It

Building a performant 3D application that simultaneously runs an LLM and vector database on consumer hardware required ruthless optimization and strict agentic scaffolding.

The Intelligence Layer (Gemma + SQLite-vec):
I used Google AI Studio to meticulously engineer strict Chain-of-Thought (CoT) prompts. Small models (like Gemma 2B/9B) need a reasoning_scratchpad to prevent hallucinations. The backend is a Python FastAPI service utilizing sqlite-vec for local vector embeddings. When a user asks, "What was Abuela's recipe for pan de muerto?", the local Gemma model retrieves the exact archival chunk and outputs a flat JSON contract driving both the text answer and the 3D scene's emotional state.

The 16-Bit 3D Sanctuary (React Three Fiber):
To keep the GPU load minimal while running local AI inference, I applied a massive pixel-art WebGL overhaul. I set the WebGL renderer's pixel ratio to 0.32 with hardware nearest-neighbor upscaling (image-rendering: pixelated), cutting GPU fragment shading by 88%. The environment uses a curated 16-color Día de los Muertos palette with 4x4 Bayer dithering for procedural linocut ancestor portraits.

The ReactBits WebGL Dither Cursor:
Instead of DOM-heavy SVG filters, I wrote a custom Three.js GLSL Post-Processing pass inspired by ReactBits. As you move the mouse, a top-down pixelated candle cursor leaves a dissipating, dithered 4x4 Bayer noise trail in the framebuffer, interacting dynamically with the 3D altar lighting.

Multi-Agent Scaffolding (Google Antigravity & Copilot):
To transition from AI Studio prototypes to a production monorepo, I used Google Antigravity. I exported a strict agent_skills.yaml file defining 6 specialized agents (AI/RAG, 3D/Creative, Security, etc.) to scaffold the Next.js and FastAPI environments, while GitHub Copilot assisted in writing the complex Three.js InstancedMesh math for the swirling petal vortexes.

Why Does Open Innovation Matter?

Because grief is not training data.

If you build a digital memorial reliant on a closed, venture-backed API, you are putting a ticking clock on your family’s history. When that service pivots, raises prices, or shuts down, your digital ofrenda goes dark.

Open innovation—specifically open-weight models like Gemma—changes the paradigm. It allows Ánimas to operate under the "One Machine, One Archive" principle. The entire RAG pipeline, embedding model, and vector database run on an air-gapped laptop. Open innovation means this software will still boot up and function exactly as intended thirty years from now, honoring the true permanence and reverence of Día de los Muertos.

My Agent Session

I utilized Google Antigravity and DevRelay to enforce strict privacy protocols and zero-cloud boundaries across the codebase. You can view the agent reasoning trace where we locked down the local-only FastAPI loopback and built the CoT hallucination defenses

The Spirit of It

During testing, I loaded a synthetic archive containing a fictional, fragmented story about a family's migration. I asked the local terminal, "Why did Tío Héctor leave the old house?"

There was a brief pause as the local GPU hummed. The 3D UI didn't just spit out text. The scene's memory_tone JSON triggered a shift: the vibrant amber lighting dimmed to a soft, somber glow, the swirling petals settled onto the chevron stone floor, and the Dither Cursor left a slow, fading trail. The model pulled the exact quote from a digital diary entry and politely abstained from guessing the parts of the story that were missing. It felt incredibly intimate, respectful, and slightly eerie—a true ghost in the machine, recalling a memory exactly as it was written, safe inside my own hardware.

Prize Categories

Gemma: For powering the local-first, zero-hallucination RAG and Sovereign Sentiment Engine using Gemma 2B/9B.

GitHub Copilot: For assisting in the procedural Three.js GLSL shader development and WebGL optimization.

Entire: (If applicable for the agent session trace embedding).

🦥 SlothSort : Messy files 📁 to Calm folders 🗂️

Shreyas Guha Neogi — Mon, 26 Oct 2026 06:27:19 +0000

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

What I Built

SlothSort is a privacy-first, local AI file organizer that turns your chaotic Downloads folder into a structured workspace. It scans your digital clutter, uses local AI to classify each file, and presents a neat organization plan. You simply review the proposed folders and click "Approve"—letting you reclaim your time and embrace your inner sloth without compromising your data.

Demo

Project will run on localhost and does not have a .com link

Code

shrguhaneogi-pixel / SlothSort

SlothSort

SlothSort uses local AI to turn your messy Downloads folder into an organized workspace, without uploading your private files.

🦥 Slow and Steady

SlothSort is built for the DEV Community Slow and Steady theme: let a local open-weight model do the tedious sorting work while you stay relaxed private, and in control. It rewards laziness without outsourcing your data: Gemma runs through Ollama on your machine, SlothSort proposes a plan, and you approve only the moves you actually want.

The app is deliberately cautious. It scans direct child files, classifies filename and extension metadata, shows a review table, and waits for an explicit approval before moving anything.

🎬 Interactive Demo

Demo placeholder: replace link-to-gif.gif with a recording of a cluttered folder becoming an organized workspace.

✨ Key Features

Local AI — classify files with a locally running Gemma model through Ollama.
Zero Data Leakage by Design — only filenames…

View on GitHub

How I Built It

SlothSort is designed entirely for local, offline execution to prioritize data sovereignty:

UI & Logic: Py & Streamlit power user interface & safe-move execution layer.
Inference: Ollama handles the local model serving.
The Brain: Gemma 3 : 1B evaluates file metadata and outputs constrained JSON to assign predefined categories (e.g., Finance, Documents, Media).

The architecture separates planning from execution. The AI suggests the plan, but a strict Python validation layer enforces collision protection, path traversal blocks, and requires explicit human approval before a single file is moved.

Why Does Open Innovation Matter?

Sorting personal files demands absolute privacy. Relying on a closed-source API would mean streaming sensitive filenames (like 2026_Tax_Return.pdf or Medical_Records.docx) to third-party cloud servers. By leveraging open-weight models like Gemma running locally, SlothSort guarantees zero data leakage, zero API subscription costs, and the freedom to automate your chores completely offline.

My Agent Session

Building SlothSort: A Slow and Steady Local-AI File Organizer

You

Build SlothSort incrementally as a local-AI file organizer using Python, Streamlit, and Ollama, with strict privacy and no-overwrite requirements.

Agent

Audited the repository, confirmed Python and local Ollama availability, and planned a focused package structure without modifying code during the audit.

You

Implement the project scaffold, read-only scanner, local Ollama adapter, classification planner, Streamlit review workflow, and safe execution layer.

Agent

Implemented the system in incremental phases: pathlib scanning, localhost-only Ollama JSON inference, allowlisted classification, root-safe planning, human approval, and collision/symlink-protected execution. Each phase was tested and committed separately.

You

Perform a comprehensive regression and security audit.

Agent

Ran the full suite, fixed a destination symlink-component issue, added regression coverage, and verified that model output cannot supply trusted paths and session state does not retain file contents.

You

Prepare the final demo and hackathon README.

Agent

Generated ignored demo files, verified repository hygiene, wrote a judge-focused README with privacy guarantees and architecture details, and added an MIT license. The final project emphasizes local open-weight inference, explicit approval, and slow-and-steady safety.

The Lazy Payoff

Instead of spending thirty minutes a week agonizing over where to drag-and-drop hundreds of random downloads, I now click a single button, review the table, and hit "Organize." What used to be a dreaded, procrastinated digital chore is now a satisfying 10-second approval task.

Prize Categories

Open-Weight Champion (Gemma)
Local Inference Hero

ScopeShield: The Open-Source Scope Creep Detector for Freelancers**

Shreyas Guha Neogi — Mon, 19 Oct 2026 06:32:12 +0000

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

What I Built

Freelancers and boutique digital agencies bleed revenue through "death by a thousand cuts"—incremental scope creep. A client rarely breaches a contract explicitly; instead, they ask for "one more quick revision," "a secondary blog page," or "just a tiny change before launch." Checking a dense 20-page Master Services Agreement (MSA) during a fast-paced Slack exchange takes too much time, and pushing back carries emotional friction.

ScopeShield turns a static PDF contract into an active, deterministic reference engine. You upload your signed agreement and paste the client's latest email. ScopeShield decomposes the message into atomic asks, evaluates them against the contract, and returns a verified verdict (In Scope, Out of Scope, or Ambiguous). It then drafts a calibrated, polite change-request email that quotes the exact contract clauses to defend your boundaries.

The Business Case: Freelance designers, developers, and copywriters would happily pay a $9/month subscription or a $99 lifetime deal for this. It acts as an automated project manager, directly saving them unbilled hours and eliminating the anxiety of writing "no" to a client.

Demo

Live App: https://scopeshield-app.onrender.com (Hosted on Render)
Video Walkthrough: [YouTube Link]

Code

shrguhaneogi-pixel / ScopeShield

ScopeShield

Protect your scope. Preserve your client relationships.

ScopeShield analyzes client requests against a signed contract. A self-hosted Gemma model proposes typed atomic asks; a Mastra workflow orchestrates the analysis; strict Zod schemas validate it; and deterministic TypeScript verifies every citation and scope rule before a response is drafted.

Run locally

npm install
cp .env.example .env.local
npm run dev

The default mock mode is deterministic and requires no API credentials. Select a sample contract or paste canonical contract text, paste a client request, and analyze it at http://localhost:3000.

The API accepts either the sample-contract shape:

{ "contractId": "software-msa", "message": "Could we add a mobile app?", "tone": "neutral" }

or raw contract text:

{ "contractText": "1. Services\nBuild the web application.", "clientMessage": "Could we add a mobile app?", "tone":

…

View on GitHub

How I Built It

ScopeShield is built strictly around Google Gemma 4 (running locally via Ollama) and orchestrated by Mastra. The Next.js 16 (App Router) frontend is hosted on Render.

Instead of relying purely on an LLM's inherently flawed reasoning for legal checks, I built a hybrid architecture:

Typed Orchestration: A Mastra workflow ingests the PDF via unpdf and segments it into numbered clauses.
Decomposition: Gemma 4 breaks the client's email into individual tasks and proposes a verdict and a supporting contract quote, validated via Zod schemas.
The Anti-Hallucination Gate: This is the core innovation. A deterministic TypeScript function takes the model's generated quote and performs an exact normalized substring match against the ground-truth contract. If the model hallucinated the citation or the text isn't a 100% match, the verdict is forcibly downgraded to AMBIGUOUS and flags a prominent Lucide ShieldAlert warning.
Drafting: Mastra triggers a second Gemma pass to draft the email, strictly limiting its context to only the citations that passed deterministic verification.

To keep my hackathon budget at exactly $0, I deployed the Next.js/Mastra app to Render's Free Tier and exposed my local Ollama instance (running gemma2) to the cloud using a free Cloudflare Tunnel.

Why Does Open Innovation Matter?

Open innovation is the only reason ScopeShield can exist as a viable business.

NDA & Privacy Compliance: Client proposals, commercial trade agreements, and hourly billing rates are bound by strict non-disclosure obligations. Sending this data to closed, proprietary APIs creates massive third-party data-leakage liabilities. Using an open-weight model like Gemma guarantees that intellectual property never leaves developer-controlled infrastructure.
Zero Marginal Cost: Scope checking is a high-frequency, low-margin utility. If I had to pay per-token cloud API fees for every 10,000-token MSA evaluation, the $9/month micro-SaaS margins would evaporate. Running an open model on fixed-cost infrastructure (or directly on a local machine) makes the unit economics of this side hustle actually work.
No RAG Fragility: Standard independent contractor agreements fit perfectly inside Gemma 4's context window. I didn't have to build brittle vector databases or chunking logic that might accidentally split a crucial legal clause in half.

My First User

I shared the local build with a freelance UI/UX designer friend who constantly battles "one last revision" requests. They uploaded an active Statement of Work and pasted a real client email asking for a "quick interactive payment calculator."

ScopeShield correctly flagged it as an explicit exclusion (Custom Backend Code), verified the citation, and generated a firm "Out of Scope" response with a placeholder for a separate hourly estimate. They loved the ShieldAlert confidence system and mentioned that having a neutral "robot" point out the contract boundaries completely removed their usual anxiety about pushing back.

Prize Categories

Best Use of Render: Next.js application, Mastra orchestration, and API routes hosted seamlessly on Render.
Best Use of Gemma: Utilized Gemma 4 for atomic task extraction and tone-calibrated drafting, demonstrating its power in processing large, complex legal contexts.
Best Use of Mastra: Orchestrated the entire multi-step pipeline (Extract -> Verify -> Draft) using Mastra workflows with strict Zod schema enforcement.
Best Use of Entire: Recorded and published the agent reasoning sessions behind the deterministic architecture.
Best Use of GitHub Copilot: Used Copilot to accelerate the Zod schemas, UI scaffolding, and unit test generation for the verification engine.

TerraScout : Offline Nature Quest

Shreyas Guha Neogi — Sun, 11 Oct 2026 18:21:01 +0000

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

What I Built

hyper-local digital naturalist, designed to reverse the "doomscrolling" trend and get people into the woods.

Instead of acting as a generic map or a chatty assistant, TerraScout generates a personalized "Nature Quest" (e.g., Find a red oak leaf, Spot a local songbird, Locate a quartz rock) based on your selected location. Once you hit the trail, the app is designed to be pocketed. The core feature is the Offline Field Guide: If you spot something interesting or need a hint to complete your quest, you can ask the app in natural language. Because the AI runs entirely locally in the browser memory, you can get instant answers deep in the woods or canyons where cellular service drops to zero. The screen is strictly a tool to facilitate physical exploration, not the destination itself.

Code

shrguhaneogi-pixel / terrascout

How I Built It

TerraScout was built within a highly constrained timeframe using the Google AntiGravity multi-agent IDE.

The Tech Stack & Open-Source AI:

Local AI Inference (The Core): The Offline Field Guide is powered by WebLLM leveraging the WebGPU API. It runs the open-weight gemma-2-2b-it-q4f16_1-MLC model entirely locally on the user's device (phone or laptop). The model is cached in IndexedDB via Service Workers, allowing it to initialize without a network connection.

Frontend PWA: Built with Next.js 16 (App Router) and Tailwind CSS. I used next-pwa to ensure the application shell caches correctly for offline reopening.

Backend & Data (The Pre-Hike Phase): Hosted on Render (frontend) and DigitalOcean (backend microservices). When the user is still on Wi-Fi, the app uses SerpApi to check trail conditions and TabPFN to analyze local tabular weather datasets (stored in TigerData) to predict the most likely flora/fauna to generate the quest. The AI orchestration was mapped using Entire.

Database & Dashboard: Completed quests sync back to MongoDB Atlas when the user reconnects, managed via a Backboard admin panel.

Development Tools: Rapidly prototyped the Gemma prompts using Tinker, and accelerated the Next.js boilerplate using GitHub Copilot alongside AntiGravity.

Why Does Open Innovation Matter?

By utilizing open-weight models like Gemma 2B and open frameworks like WebLLM, TerraScout achieves three things closed systems cannot:

Zero-Connectivity Execution: You can take the AI miles away from a cell tower. It processes your questions instantly on your device's GPU.

Absolute Privacy: Your location, queries, and trail habits never hit a remote server while you are exploring.

Zero Inference Cost: I don't pay a cent for API calls when users are chatting with the field guide on the trail.

My Agent Session

Google AntiGravity's autonomous agent workflows to handle the WebGPU boilerplate and Next.js PWA configuration.

TerraScout — Offline Nature Quest PWA Autonomous Build & Verification gemma-2-2b-it-q4f16_1-MLC

You

Execute the autonomous build plan to implement TerraScout, a production-minded offline nature quest PWA. Spawn parallel subagents for terminal operations, file editing, and browser validation. Prioritize functional code, local WebGPU inference, and a highly polished mobile-first UI.

Critical Constraint: Do not claim a feature works unless you have implemented and verified it. Do not hallucinate API keys, remote backend dependencies, or unsupported WebLLM features.

Phase 0: Repository Initialization & Version Control
Phase 1: Environment Audit & Dependency Resolution
Phase 2: Core UI & Mock Quest Engine (app/page.tsx)
Phase 3: WebLLM Integration (Real Local Inference)
Phase 4: Validation & Finalization

Agent

Implemented and verified TerraScout, an offline nature scavenger hunt and wilderness reconnaissance Progressive Web Application (PWA) with on-device WebGPU inference via WebLLM.

Key Deliverables Across All Phases:

Phase 0 — Repository Setup & Version Control:
- Initialized Git repository with Next.js App Router structure and strict .gitignore.
- Enforced Scheduled Commit Protocol with atomic commits for each phase (86efaa5, c7ffeff, d25fcfb, 60c7a7e, dad71b2, 58b1234).
Phase 1 — Dependencies & PWA Offline Shell:
- Installed @mlc-ai/web-llm and configured @ducanh2912/next-pwa in next.config.mjs with 15MB cache limits to precache WebAssembly runtimes and the app shell.
- Generated PWA manifest.json and standalone icons (192x192, 512x512).
Phase 2 — Core UI & Mock Quest Engine:
- Built a mobile-first dark earthy backcountry palette (Deep Pine, Moss, Sage, Parchment).
- Implemented controlled location input with real-time validation and preset trailheads.
- Built procedural quest engine (lib/questEngine.ts) returning three contextual items per biome (Coniferous, Coastal, Montane, Desert, Urban, Woodland).
- Built interactive checklist with accessible checkboxes (role="checkbox", aria-checked) and real-time progress calculation.
- Added dedicated 4-card Offline Field Guide handbook.
Phase 3 — WebLLM On-Device WebGPU Inference:
- WebGPU capability detection with graceful fallback UI for unsupported browsers.
- Integrated CreateMLCEngine with primary target model gemma-2-2b-it-q4f16_1-MLC and low-memory Qwen2.5-0.5B-Instruct-q4f16_1-MLC fallback.
- Real-time initProgressCallback displaying true progress percentage and compilation stages.
- Silent system prompt injection (max 2 sentences, scout guidelines) with chat history sanitization.
- Functional state updates appending streaming tokens incrementally.
Phase 4 — Validation & Testing:
- Automated Unit Tests: 10/10 tests passed (npm test).
- Typecheck & Lint: Zero errors, zero warnings (tsc --noEmit, next lint).
- Production Build: Compiled cleanly with prerendering and service worker generation (npm run build).
- End-to-End Browser QA: Verified responsive viewports, validation edge cases, quest generation, checklist progress, and WebGPU detection.
- Comprehensive documentation in TERRASCOUT_SUMMARY.md.

▸ unit_tests npm test

Input

npm test

Output

10 passed, 0 failed, 0 skipped, duration 355ms

▸ static_analysis npm run typecheck && npm run lint

Input

npm run typecheck && npm run lint

Output

tsc --noEmit: exit 0; next lint: No ESLint warnings or errors

▸ production_build npm run build

Input

npm run build

Output

Next.js production build compiled successfully, service worker generated at /sw.js

▸ browser_qa_validation browser subagent on http://localhost:3000

Input

browser subagent on http://localhost:3000

Output

Responsive mobile/desktop layouts verified, location validation passed, quest generation verified, checklist progress tracking verified, WebGPU detection verified

Prize Categories

Github Copilot
Render
Tinker
Gemma

📖 LocalHost Journaling ✍️With Gemma

Shreyas Guha Neogi — Sun, 04 Oct 2026 18:09:26 +0000

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

What I Built

I built Space Journal - an Offline "Safe-Space" Cognitive Journal Analyzer for my friend, Risiraj, who suffers from panic attacks and manages anxiety through journaling and is a poet at heart, but is fiercely protective of their privacy.

It is a completely offline zero-telemetry environment where my friend can securely paste their daily inflections without a permanent online imprint or embarassment.

Demo

Code

shrguhaneogi-pixel / spaceJournal

Offline Safe-Space Journal Analyzer

A privacy-first, 100% offline desktop application designed for safe, personal journal reflection using an open-weight model running entirely on your own machine.

Quick Start (3 Easy Steps)

Step 1: Install Ollama & Pull Model

Download and install Ollama for your operating system.
Open your terminal / command prompt and download the local AI model:
```
ollama pull gemma2:2b
```

Step 2: Install Python Dependencies

Open your terminal in this directory and install the dependencies:

pip install -r requirements.txt

Step 3: Launch the Application

Start the application with a single click or command:

Windows: Double-click start_journal.bat (or run start_journal.bat in Command Prompt).
Mac / Linux: Execute ./start_journal.sh (run chmod +x start_journal.sh first if necessary).

Automated Infrastructure Sync

To schedule daily background backups of application code changes (excluding all private user data):

Windows (Task Scheduler)

Run this command in an Administrator Command Prompt (update directory path if needed):

schtasks /create

…

View on GitHub

How I Built It

I used an autonomous agent (Antigravity) to scaffold the project with strict privacy constraints. The core stack relies entirely on local execution:

Model: Google's Gemma (gemma2:2b), an open-weight model small enough to run fast on a standard laptop CPU.

Inference: Ollama, serving the model locally.

Frontend: Streamlit for a clean, minimalist user interface.

Prototyping: Google AI Studio to perfect the system prompt for objective, non-judgmental cognitive reframing before writing any code.

Antigravity generated idempotent deployment scripts (start_journal.sh / .bat) so my non-technical friend can launch the Ollama server and the Streamlit app with a single click. It also generated a strict .gitignore that physically blocks local caches and journal data from ever being committed, ensuring only the infrastructure is synced to the private repository.

Why Does Open Innovation Matter?

For deeply personal mental health tools, open innovation isn't just a feature—it's the only way the product can exist.

If this relied on a closed API, my friend simply wouldn't use it. By leveraging an open-weight model, I was able to guarantee absolute data sovereignty.

My Agent Session

Check out how I used Antigravity to autonomously generate the offline privacy constraints and idempotent deployment scripts:

Offline Safe-Space Journal Analyzer - Autonomous Build & Deploy

You

Build and locally deploy the Offline Safe-Space Journal Analyzer desktop web application. Core requirements: 100% offline local processing using Ollama (gemma2:2b), privacy-first zero-telemetry Streamlit app, startup scripts (start_journal.bat and start_journal.sh), zero-leakage .gitignore, and automated backup sync scripts.

Agent

Created the complete Offline Safe-Space Journal Analyzer application suite in spaceJournal workspace:

app.py: Streamlit frontend with local Ollama inference using gemma2:2b, error handling, and empathetic UI.
requirements.txt: Minimal dependencies (streamlit, ollama).
start_journal.bat & start_journal.sh: One-click startup scripts checking port 11434 before starting Ollama and Streamlit.
.gitignore: Strict privacy exclusions ignoring logs, database files, and personal journal notes.
sync_codebase.bat & sync_codebase.sh: Scoped version control backup scripts pushing infrastructure updates to GitHub.
README.md: 3-step setup and background sync scheduling instructions.

Prize Categories

Best Use of Gemma : (Ran Google's gemma2:2b open-weight model locally for offline inference)

Future of AI: Better Memory over Reasoning.

Shreyas Guha Neogi — Sat, 30 May 2026 08:39:07 +0000

This is a submission for the Hermes Agent Challenge

Most AI Agents Are Forgetful. Hermes Agent Is Betting That Memory Matters More Than Intelligence.

Every few weeks, a new AI agent framework appears. For about ten minutes, it feels revolutionary.

Then reality kicks in.

The agent forgets everything. Fancy Reasoning over lacklustre memory.

Hermes Agent is interesting because it treats intelligence as something that compounds. This changes everything.

That is the insight I would carry forward from it.

Hermes is not only about planning or tool use or multi-step reasoning, although it does those things. It is about turning repeated work into remembered work, and turning remembered work into better future work.

If the next generation of agent systems is going to matter, it will not be because they can produce a good one-off answer.

It will be because they can learn the shape of the work, keep that knowledge, and become more useful every time they are used.

Hermes is pushing in that direction.

IMO, that is why it is worth building on.

TL;DR Hermes is one of the few agent systems explicitly designed around the idea that accumulated knowledge should survive beyond a single session.