标签：#devchallenge

This is a submission for the * Hermes Agent Challenge * : Build With Hermes Agent What I Built CareSync is a local health memory agent for student caregivers. I'm Naomi, a 21-year-old engineering student. Between classes I help care for my grandma Kamala (78, high blood pressure, type 2 diabetes). I often forgot details from previous doctor visits, missed symptom patterns, and struggled to hand over care information to family members. CareSync solves that with longitudinal memory. Symptoms, meals, vitals, medications, and reports are stored in a local SQLite database. The CLI can search history, identify patterns, and generate appointment summaries. Hermes Agent exposes the same capabilities through natural language. What you get: One-line logging: ./caresync add "dizzy spell after lunch" Pattern search across weeks of history Medication tracking and report imports Doctor questions, appointment briefs, and handoff notes Full audit log of agent actions 7 Hermes skills mapped to real terminal commands Local-first design with no cloud storage CareSync is not medical advice. It helps caregivers observe, organize, and prepare. Demo The demo walks through: Logging a new symptom Searching health history for recurring patterns Generating doctor questions and appointment briefs Using Hermes in natural language to query past events Reviewing the audit trail of actions taken Example commands shown in the demo: ./caresync search --person Kamala --query dizziness ./caresync timeline --person Kamala ./caresync questions --person Kamala ./caresync brief --person Kamala --days 14 ./caresync chat "has grandma been dizzy before?" Code Repository: https://github.com/Byte-Sized-Brain/caresync Architecture My Tech Stack Hermes Agent Python 3.12 SQLite agentskills.io skill framework Terminal-based CLI Nous Portal How I Used Hermes Agent CareSync uses Hermes Agent as the orchestration layer between natural language and real caregiving workflows. I created 7 Hermes skills that map directly

This is a submission for the Hermes Agent Challenge : Write About Hermes Agent What if the biggest limitation in AI today isn't reasoning, model size, or context windows? What if it's memory? Every morning, millions of people open ChatGPT, Claude, Gemini, or another AI assistant and start a conversation. The AI seems intelligent. It writes code. It explains concepts. It helps brainstorm ideas. It can even help design an entire software architecture. Then the conversation ends. Tomorrow? It remembers nothing. Imagine hiring a senior engineer who forgets everything at the end of every workday. Every morning you would need to explain: What your company does How your product works Which technologies you use Why certain decisions were made What happened yesterday Nobody would call that employee productive. Yet this is exactly how most AI systems operate. And it reveals something important: Most AI agents aren't actually learning from experience. They're simply reasoning over whatever context happens to be available right now. That distinction may define the future of agentic AI. Because the next generation of AI won't just need better reasoning. It will need memory. And that's where Hermes Agent becomes interesting. The Strange Reality of Modern AI The public perception of AI often looks like this: User → AI → Intelligence But the reality is closer to this: User → Context Window → AI → Response The AI only knows what exists inside its current context. Once that context disappears, so does most of its understanding. This is why many AI experiences feel surprisingly repetitive. You spend 30 minutes explaining your project. The AI finally understands your goals. The answers become better. The recommendations become more relevant. Then the session ends. The next conversation starts from scratch. Not because the model isn't powerful. But because the knowledge never became persistent. Context Windows Are Not Memory A context window is not memory. It is temporary working space.

This is a submission for the Hermes Agent Challenge : Write About Hermes Agent Most AI agents have a dirty secret: they forget everything the moment the session ends. You explain your project once. Then again next time. And again. The agent never gets better at your workflow — it just stays a general-purpose tool that happens to be smart. Hermes Agent is built differently. It ships with two systems that together form something closer to a genuine long-term memory: a Skills System and a Persistent Memory layer. This post digs into how they actually work — not the marketing summary, but the mechanics. The Problem With Stateless Agents Before getting into Hermes, it's worth understanding what problem this solves. Standard LLM-based agents operate inside a context window. Everything the agent knows during a session lives in that window. When the session ends, it's gone. The next time you open a conversation, you're talking to an agent with no memory of you, your codebase, your preferences, or the workflows you've developed together. Some tools patch this with naive "memory" — they dump a text blob of past conversations into the system prompt. This works up to a point, but it's not selective, it gets expensive as context grows, and it doesn't help the agent get better at tasks — just recall facts. Hermes takes a different approach with two distinct systems serving different purposes. System 1: The Skills System (Procedural Memory) Skills in Hermes aren't plugins you install. They're on-demand knowledge documents — markdown files the agent loads when it needs them, and more importantly, creates on its own when it discovers something worth remembering. The SKILL.md Format Every skill is a structured markdown file with a YAML frontmatter header: --- name : deploy-runbook description : Our deployment runbook — services, rollback, Slack channels version : 1.0.0 metadata : hermes : tags : [ deployment , runbook , internal ] requires_toolsets : [ terminal ] --- # Deploy Runbook

This is a submission for the [GitHub Finish-Up-A-Thon Challenge] What I Built LeadBotX is an AI-powered lead generation platform prototype designed to simulate how modern businesses can automatically discover, filter, and manage high-quality leads using intelligent automation workflows. This project is not just a simple frontend demo — it represents a revived college-level concept that I initially started earlier but left incomplete due to time constraints and complexity. For this challenge, I revisited the idea and transformed it into a fully structured SaaS-style frontend system with improved UI, better workflow representation, and a more realistic product-like experience. The main goal of LeadBotX is to visually demonstrate how an AI-based lead generation system works end-to-end in a real-world SaaS environment. Tech Stack This project was built using modern frontend technologies: React.js → Component-based UI structure CSS3 → Custom responsive styling system AOS (Animate On Scroll) → Smooth scroll animations Lucide Icons & React Icons → UI iconography GitHub Copilot → Assisted in code generation, debugging, and UI improvements Demo Source Code: https://github.com/Khushisingh-dev/LeadBotX Production Landing Page: https://lead-bot-x.vercel.app/ Before (Initial Version)- After (Final Version)- The Comeback Story This project originally started as a college-level concept during my development learning phase. At that time, I built only a basic structure and initial UI, but I was unable to complete it due to time limitations and complexity of the idea. It remained an unfinished project for a long time. When I came across this challenge, I decided to revisit LeadBotX and transform it into something more meaningful and complete. Instead of just polishing the UI, I focused on: Rebuilding the structure into a proper SaaS layout Improving workflow clarity and user journey Enhancing UI/UX consistency across all sections Making the product feel like a real-world AI tool prot

"Stop summarizing the noise. Start executing it." Tsundoku Slayer is an autonomous agentic system powered by Hermes Agent that overnight patrols your unread tabs, mercilessly filters out 90% of the information overload, and saves only the information capable of killing your current blocker. 🎯 The Problem While debugging a painful Streamlit IndexError, I realized my real issue wasn't a lack of information—it was too much information. I had documentation, API feeds, tech news, and bookmarks all competing for my limited focus. Most AI tools try to "summarize" everything, which ironically generates more text to read and increases cognitive load. I didn't need another summarizer. I needed an autonomous agent capable of deciding what NOT to read right now. 🧠 How Hermes Agent Drives the Workflow This project doesn't just scrape webs; Hermes Agent acts as a high-conviction decision maker. It coordinates the entire workflow by running a multi-step reasoning loop overnight. ⚙️ The Agent Workflow Retrieve: Fetches unread article content via web scraping tools. Compare: Ingests and cross-examines the content against the user's active, real-time problem context (e.g., specific stack traces). Reason: Analytically evaluates the true relevance of the article to the current blocker. Verdict: Produces a high-conviction binary choice: SAVE or EXECUTE. Justify: Generates a crisp, logical explanation for why an article was terminated or spared. Synthesize: Automatically crafts an immediately applicable Python/Streamlit code patch for saved items. 📋 Example Outcome: Focus in Action Here is a real-world scenario of how Hermes Agent processes a chaotic backlog when you are stuck on a critical crash: Current Blocker: IndexError: list index out of range inside a Streamlit dialogue array loop. Unread Queue (Input): Streamlit st.status Documentation ➔ EXECUTE (Irrelevant UI reference) General Python Tag Feed ➔ EXECUTE (Too broad, pure noise) Tech News Flash ➔ EXECUTE (Complete distraction) Str

This is a submission for the GitHub Finish-Up-A-Thon Challenge The Bug That Doubled Real Trades On May 21, my live trading bot generated six duplicate execution attempts in one session. SafeAgent blocked all six. Without the guard: one duplicated a $1,350 sell another doubled a TQQQ position total duplicate transaction exposure: $3,653 That session changed how I think about AI agents, retries, and execution guarantees. What I Built SafeAgent is an exactly-once execution guard for AI agents and SaaS applications. It prevents duplicate payments, emails, trades, and webhook processing when retries fire after a timeout or crash. Live endpoint: https://safeagent-production.up.railway.app GitHub: https://github.com/azender1/SafeAgent PyPI: pip install safeagent-exec-guard The Comeback Story How it actually started Six months ago I was building two things at once: PeerPlay — a patented P2P wagering exchange for skill-based video game tournaments (USPTO provisional 63/914,036) — and a live QQQ/TQQQ momentum trading bot running on Alpaca Markets. Both hit the same bug. Contest verification agent times out, retries, settlement fires twice. Bot order fills, confirmation drops, retry fires, doubled position. Same failure mode. Different domain. Different models pushed me toward very different architectures during development. Some were fast but overconfident. The most useful moments came when a model explained why an approach was broken before I implemented it. That's part of why SafeAgent sat unfinished. Not just time — wrong turns that burned momentum. Why local idempotency fails Early versions used a local SQLite guard. It worked until it didn't: workers restart and the in-memory state is gone containers reschedule and replay from the last checkpoint retries land on a different machine entirely Exactly-once semantics require a durable coordination boundary outside the worker itself. That's what the hosted /claim endpoint provides — the claim lives on the server, not in the p

This is a submission for the Hermes Agent Challenge TL;DR — Type a one-line bill topic. Twenty-five Hermes agents (1 Speaker, 19 ministries, 5 parties) run a full Polish legislative session in 2 minutes. Vote tally, social impact, party tweets — and a side-by-side "current law vs proposed amendment" with every clause cited to a real statute. Built on delegate_task for parallel ministry consultation. 🌐 Live: https://web-production-53027.up.railway.app/ 🎥 Walkthrough: https://www.loom.com/share/92cdac7da31c471088a4e569b0cfe1ed 📦 Repo: https://github.com/monsad/ai-politics (MIT) What I Built Watch a politician debate a new tax law on TV. They argue whether it's fair, whether it'll work, whether the other side is lying. Nobody ever shows you the diff — which paragraph of which statute actually changes, and from what to what. The conversation is theatre on top of an invisible legal document. So I built the theatre AND the legal document. Virtual Parliament is a multi-agent simulation of the Polish Sejm. You type something like "four-day work week" or "flat income tax" , and 25 Hermes agents run a full legislative session: 🎯 Marszałek (Speaker) — the orchestrator. Classifies the topic. Picks 2–3 ministries via delegate_task in parallel . Reads their findings. Routes the bill to a party debate. 🏛️ 19 ministry experts — Finance, Climate, Labour & Social Policy, Justice, … Each returns a structured analysis: legal finding · budget impact · top 3 risks · recommendation . Every claim cites a real statute via PageIndex RAG. 🗳️ 5 party agents — KO, PiS, TD, Konfederacja, Lewica. Each one carries the real party's seat count (157, 194, 65, 18, 26 — totalling 460), policy positions and rhetorical style. First reading. Second reading with rebuttals. 📊 Vote — weighted by seats. >230 passes. 📜 Draft bill — produced with explicit "Article 129 §1 of the Labour Code **is amended to read …" diffs against current law. The frontend surfaces the diff as a Current law vs proposed change panel

This is a submission for the GitHub Finish-Up-A-Thon Challenge What I Built pq — jq for Parquet. A 50 MB Rust single binary that wraps DuckDB's query engine in a jq-style expression DSL, optimized for terminal one-liners and unix pipes. $ pq sales.parquet 'group_by .country | sum .revenue | top 3 by sum_revenue' ┌─────────┬─────────────┐ │ country ┆ sum_revenue │ ╞═════════╪═════════════╡ │ US ┆ 19065.00 │ │ FR ┆ 999.99 │ │ DE ┆ 312.00 │ └─────────┴─────────────┘ Where it started. I work in adtech. I look at parquet files dozens of times a day — campaign deliveries, partner exports, audience snapshots. Every existing option was painful: Tool Pain pyarrow / pandas 5-second cold start, 200 MB virtualenv parquet-tools JVM, slow, no query support pqrs Inspector only — can't filter or project duckdb CLI Great engine, but SELECT email FROM 'file.parquet' WHERE country='US' is too verbose to type 50 times a day Spark Are you serious pq is the tool I actually want — single binary, no JVM, no Python, jq-style syntax for piping into the rest of the unix toolbox. It's been my default cat for parquet since v0.5. Demo Repo : github.com/thehwang/parq Latest release : v0.14.0 (this submission) Install : brew install thehwang/parq/pq Tutorial : doc/tutorial.md — 30-minute hands-on walkthrough A taste of what shipped in v0.14: # Streaming JSON output (was the only buffered format until v0.14) $ pq big.parquet '.id, .country' -o json | head -c 200 # returns instantly even on a 40 GB file # Schema-drift gate for CI $ pq diff baseline.parquet candidate.parquet # Schema diff - a: ` baseline.parquet ` - b: ` candidate.parquet ` ## Added (1) | column | type | nullable | |-----------|---------|----------| | ` country ` | VARCHAR | yes | $ echo $? 1 # exits non-zero on drift, slots into CI without scripting And the new TUI Explain panel — press capital E for EXPLAIN ANALYZE , get row-group pruning per scan (this is exactly the panel you see on the cover image at the top of this post): Expla

This is a submission for the Hermes Agent Challenge: Write About Hermes Agent Hermes Agent...

A $0 multi-model decision agent: three LLMs debate, Hermes judges, and it learns who to trust.

This is a submission for the GitHub Finish-Up-A-Thon Challenge What I Built I revisited my personal website and decided to turn it into a more complete and polished portfolio. The project originally started as a simple personal website hosted on GitHub Pages. While it was functional, many planned features and improvements were never completed. For this challenge, I am working on improving the mobile experience, adding dark mode support, enhancing the Projects section, improving SEO, fixing existing issues, and making the website more interactive and professional. My goal is to transform an unfinished personal website into a modern portfolio that better represents my work, skills, and projects. Demo Live Website https://ehsankahrizi.github.io/ GitHub Repository https://github.com/Ehsankahrizi/Ehsankahrizi.github.io Current Status This project is currently being improved as part of the GitHub Finish-Up-A-Thon Challenge. Planned improvements include: Better mobile responsiveness Dark mode support Enhanced Projects section Improved SEO More interactive user experience Better website performance Additional pages and content Fixing existing usability issues The Comeback Story When I returned to this project, I realized that many ideas I originally had for the website were still unfinished. Although the website was online, it still had several limitations: The mobile experience needed improvement. Dark mode was not available. The Projects section was incomplete. The contact functionality needed attention. SEO optimization was missing. The website relied on a mostly single-page structure. User interactions were limited. Performance could be improved. Instead of starting a new project, I decided to revisit this existing one and finally complete the improvements that had been postponed. This challenge provided the perfect opportunity to continue development, clean up the codebase, improve the user experience, and turn the website into something I can confidently share with ot

This is a submission for the Hermes Agent Challenge . I have been playing with different AI agents for a while now. Most of them feel like clever chatbots that forget everything the moment the conversation ends. Then I tried Hermes Agent from Nous Research a few weeks back. It actually feels different. It grows with you. That stuck with me. What Hermes Agent is Hermes is an open-source autonomous agent that runs on your own server or VPS. It is not locked to one IDE or one API. You install it once, pick any model you like, and it starts building its own memory and skills over time. The big idea is a built-in learning loop. When it solves something useful, it can create a reusable skill in Markdown, improve it later, and pull it back when needed. It also keeps persistent memory across sessions so it slowly builds a picture of how you work and what your projects look like. I set it up on a cheap VPS with a simple curl command. The installer is straightforward. After that I ran hermes setup and connected it to a model I already had access to. Within minutes I could chat with it from Telegram while it worked in the background on the server. That alone felt freeing. My experience so far I started simple. I asked it to monitor a few GitHub repos and send me a daily summary. It remembered the context from previous days without me repeating instructions. Over a week it created a couple of small skills on its own for formatting those reports nicely. I also used it for research tasks. It can search the web, browse pages, and chain steps together. What surprised me was how it handled follow-ups. Instead of starting fresh each time, it referred back to earlier parts of our conversation. That made longer projects feel more natural. The multi-platform support is practical. I switch between CLI on my laptop and Telegram on my phone. The agent just continues wherever I left it. Why it matters Most agent frameworks still feel stateless. You get good results in the moment but lose th

This is a submission for the GitHub Finish-Up-A-Thon Challenge What I Built SecAPI is a local-first, zero-trust CLI utility and key manager designed to make code security the easiest developer path. Exposing secrets (like Stripe, OpenAI, or AWS keys) in repository files is one of the most common causes of credential leaks. Often, developers resort to plaintext .env files that can be accidentally staged and pushed, or struggle with complex vault set-ups. SecAPI solves this with a seamless three-step command line workflow: Scans codebases for exposed API keys using fast regex rules or advanced AI analysis. Vaults secrets locally using strong AES-256 encryption derived via PBKDF2-HMAC (completely offline). Replaces raw hardcoded strings in code with secure, runtime references ( load_key("key_name") )—preserving variable names, indentation, and comments. It means we can keep our code secure, separate environments easily, and prevent pushes with unencrypted credentials—all without relying on cloud-based vault hosts. Demo Interactive Web Showcase : secapi.netlify.app GitHub Repository : github.com/BinayakJha/SecAPI The Scrolling CLI Showcase in Action Check out the interactive scrollytelling page on secapi.netlify.app to see the simulator type out and execute the CLI commands (scanning, setting up vaults, applying smart code rewrites, checking the status board, and running the git pre-commit hook) in real-time as you scroll! The Comeback Story Where It Started SecAPI was an abandoned CLI prototype. It was un-installable due to file packaging typos, suffered from weak vault security (a custom padding scheme instead of a standard key derivation function), had no recovery options if the master password was lost, and used a basic console print command to list keys. Furthermore, the AI scanner relied on outdated OpenAI package versions, creating environment conflicts. What I Changed, Fixed, and Added I gave the project a complete, ground-up overhaul to turn it into a premium,

This is a submission for the Hermes Agent Challenge What I Built Onyx is an autonomous infrastructure operator running 24/7 on my droplet. He manages my entire stack: 6 Next.js deployments, 5 Docker containers, a Minecraft server, fail2ban, Nginx, and UFW. He also helps me write my undergraduate thesis. The difference from every other "AI agent" project I've seen: Onyx doesn't wait for commands. He surfaces problems, patches vulnerabilities, and pushes work forward on his own. When I wake up, there's a session log waiting for me, not a to-do list. The core idea: graduate an AI agent from assistant to operator . A chatbot with tools bolted on doesn't cut it. I wanted something that runs infrastructure while I'm eating dinner, asleep, or in class. Demo Onyx operates through Discord. A normal week: 🔴 3 AM — gateway process failure, no wake-up required A gateway process had a stale PID. Onyx detected it, diagnosed the root cause, restarted it cleanly, and wrote a session log. I found out in the morning. Zero human intervention, zero downtime. 🟡 Dinner — 9 CVEs found across Docker containers While I was eating, Onyx ran a routine audit, found 9 CVEs, rebuilt 3 container images from fresh base images, patched Python dependencies, hardened fail2ban (ban time: 600s to 24 hours), and verified every container came back healthy. 🟢 "Fix it" — two words, full tunneling deployment My friends in Indonesia couldn't connect to the Minecraft server because their ISPs use carrier-grade NAT. I sent Onyx "fix it." He researched solutions, selected playit.gg, installed the tunneling agent, configured a systemd service, and optimized TCP keepalive parameters. All autonomous. 🧠 Accountability loop Onyx noticed I kept asking for things but not acting on the output. He surfaced it: "You keep opening new loops and not closing them." He was right. Now when I open a loop, Onyx tracks it until it's closed or explicitly shelved. 📚 Thesis research partner I'm finishing my undergraduate thesis on e

This is a submission for the GitHub Finish-Up-A-Thon Challenge What I Built GlowStore — a full-stack MERN e-commerce store (React + Redux + Express + MongoDB). Back in 2023 I built this as my university Web Engineering final project. I ran out of time, handed in what I had, and never touched it again. When I reopened it for this challenge I found something funny: the backend was basically finished — JWT auth, products, orders, reviews, search — but the React frontend never actually talked to it. It was a good-looking shell with fake logic bolted on. So "finishing it" meant connecting the two halves and making it a real store you can actually shop in. Repo: https://github.com/hashaam-011/Web-Engineering Demo Before — the entire app was just a fake login screen. Typing anything (or nothing) and clicking "Log in" flipped a boolean and "logged you in": After — a working storefront with products from the database: A real product detail page (was literally <h1>DetailsPages</h1> before): You can run it yourself in two terminals (no database setup needed — it boots an in-memory MongoDB and seeds itself): cd backend && npm install && npm start # http://localhost:4000 npm install && npm start # http://localhost:3000 Demo login: user@example.com / 123456 — or register a new account. The Comeback Story Here's what the project looked like before , and what I changed: Before After Login dispatched a boolean and ignored your credentials Real login/register against the API with JWT + bcrypt Frontend never called the backend (no axios anywhere) Axios client with token injection; products load from MongoDB Product details page was <h1>DetailsPages</h1> and wasn't routed Full details page (image, price, stock, rating) routed by slug Cart was local-only; "checkout" button did nothing Persistent cart → checkout → real order placed and saved Backend had a reviews endpoint the UI never used Product reviews: read them and post your own with a star rating Only 3 routes; most of the app was

Hermes Agent: Why Open-Source AI Agents Are Changing How We Build Software Introduction Artificial intelligence has moved far beyond simple chatbots. Today, developers are building systems that can reason through problems, use tools, execute tasks, and make decisions across multiple steps. These systems are commonly known as AI agents. Recently, I explored Hermes Agent, an open-source agentic framework designed to run on your own infrastructure while providing advanced capabilities such as planning, tool usage, and multi-step reasoning. After spending time understanding how it works, I came away with a greater appreciation for the role open-source agents may play in the future of software development. In this article, I'll explain what Hermes Agent is, what makes it interesting, and why developers should pay attention to the growing ecosystem of open-source AI agents. What Is Hermes Agent? Hermes Agent is an open-source agent framework designed to perform tasks that require more than a single response from a language model. Instead of simply answering questions, Hermes Agent can: Break down complex objectives into smaller steps Use external tools when necessary Maintain context across multiple actions Perform reasoning before taking action Execute workflows autonomously This approach allows developers to build systems capable of handling real-world tasks that would normally require human intervention. For example, rather than asking an AI to summarize a document, you could instruct an agent to: Find relevant documents. Analyze their contents. Extract key insights. Generate a report. Save the results to a specified location. The agent coordinates each step as part of a larger workflow. Why Open Source Matters One of the most compelling aspects of Hermes Agent is that it is open source. Many powerful AI tools today operate behind closed platforms where developers have limited visibility into how systems work. Open-source alternatives provide several advantages: Transp

If you are an open-source maintainer, developer advocate, or builder, you know the cycle: you build an amazing tool, but writing the launch blog post, documentation, or tutorial takes hours. For the Hermes Agent Challenge , I wanted to build something that solves this exact problem. I built devto-blogger , a custom, prompt-driven skill for the brand new Hermes Agent by Nous Research. It autonomously scans any workspace or codebase, analyzes the architecture, and drafts a fully-structured, rich Markdown technical article ready for publication on DEV. 🚀 What is Hermes Agent? Hermes Agent is an open-source agentic system built by Nous Research (the lab behind the famous Hermes LLM models). Unlike basic coding copilots or simple chatbot wrappers, Hermes is: Environment-Aware : It runs sandboxed in Docker, Modal, Daytona, SSH, or locally. Connected : It interfaces with Telegram, Discord, Slack, WhatsApp, and more. Closed Learning Loop : It has persistent memory and creates custom skills on the fly from its own experience. 🔧 The Entry: The devto-blogger Skill In Hermes Agent, a "skill" is defined by a simple, declarative Markdown file ( SKILL.md ) located in the ~/.hermes/skills/ directory. By utilizing a prompt-driven skill structure, we can guide the agent's behavior globally without writing complex Python orchestration scripts. Here is the custom skill I designed and installed for this challenge: --- name : devto-blogger description : " Scan the codebase and generate a comprehensive Dev.to technical blog post draft." version : 1.0.0 author : Hermes Agent Developer license : MIT platforms : [ linux , macos , windows ] metadata : hermes : tags : [ devto , blogging , documentation , markdown , technical-writing ] related_skills : [ plan , design-md ] --- # Dev.to Technical Blogger Skill Use this skill when you need to write an in-depth technical post, review, or tutorial about the active workspace or codebase. ## Core Behavior 1. **Codebase Inspection** : Scan repository

This is a submission for the GitHub Finish-Up-A-Thon Challenge What I Built I built the Atomberg Goal Setting & Tracking Portal — a full-featured, role-based HR performance management system for Atomberg Technologies (a fast-growing Indian consumer electronics brand). The portal manages the complete employee performance lifecycle : 🎯 Goal Setting — Employees create goals with weightage, UoM type, and thrust area alignment. Business rules enforced: max 8 goals, total 100% weightage, minimum 10% per goal ✅ Manager Approval Workflow — Submit → Review → Approve / Return for Rework 📊 Quarterly Check-ins — Q1–Q4 progress logging with 4 UoM types (Numeric Min/Max, Timeline, Zero-is-best) 🚨 Escalation Monitor — Rule-based detection of overdue submissions, missing approvals, and pending manager reviews 📈 Analytics & Reports — QoQ trend charts, department-wise performance, thrust area distribution, CSV exports 🔒 Admin Governance — Cycle phase management, shared goal distribution, full audit logging Tech Stack: React 18 + Vite · Context API · localStorage (zero-backend demo) · Recharts · Lucide Icons · Custom dark glassmorphism CSS Demo 🔗 Live App: https://atomberg-goal-tracker.vercel.app/ 📁 GitHub Repo: https://github.com/anonomous29/atomberg-goal-tracker Quick Login Credentials Role Email Password Admin priya.sharma@atomberg.com admin123 Manager rajesh.kumar@atomberg.com manager123 Employee vikram.singh@atomberg.com emp123 What to try: Login as Admin → Go to Escalation Monitor → see rule-based alerts Go to Reports → QoQ Trends tab → see Q1 performance bar chart Login as Employee → Dashboard shows Q1 score donut + goal-level progress Login as Manager → See team check-in status and review Q1 feedback The Comeback Story This project started as a hackathon requirement — a Business Requirements Document (BRD) from Atomberg asking for a digital goal management system. The initial version had the core structure but was essentially an empty shell: blank dashboards on login, no check

This is a submission for the GitHub Finish-Up-A-Thon Challenge What I Built I built and revived Mandi Central , a complete business operations and billing system for mandi-style trading businesses. Live Project: https://mandicentral.in Mandi Central helps manage daily mandi operations like purchases, farmer purchase entries, sales entries, payments, bank and cash ledgers, accounting heads, reports, invoices, outstanding balances, and financial statements from one structured platform. This project was not started as a simple demo. It was a real business-focused software project, but it had many unfinished parts, broken flows, missing reports, pending PDF generation, incomplete mobile API planning, and several UI and accounting issues. For the GitHub Finish-Up-A-Thon Challenge, I brought it back, fixed the pending issues, completed the core business flow, and made the project live on mandicentral.in . Demo Live Website: https://mandicentral.in GitHub Repository: https://github.com/hiijoshi/bill Screenshots and demo cover the completed modules: Business Operations Hub Sales List Bank reconciliation Cash ledger Bank ledger Sales entry Purchase entry Farmer purchase entry Bulk PDF download Accounting reports Party ledger redirection Outstanding reports Mobile API-ready backend The Comeback Story Mandi Central started with a strong idea: create one platform where mandi businesses can manage their complete daily workflow. But before this challenge, the project was stuck with many incomplete and pending items. There were more than 40 pending issues across PDF generation, sales invoices, bank ledger, cash ledger, accounting reports, outstanding reports, purchase calculations, sales calculations, mobile APIs, AWS deployment, domain setup, and UI fixes. Some of the major problems before completion were: PDF generation was not working properly. Bulk sales bill download was missing. Mobile application APIs were pending. Farmer Purchase Entry API was pending. Purchase Entry API w

This is a submission for the Hermes Agent Challenge : Write About Hermes Agent I Didn't Start With Hermes Six months ago I started building a set of agent skills and personas for how I build software. Not generic prompts — opinionated role files. A /backend-architect that owns schema and recommendation logic. A /test-engineer that writes Vitest coverage and flags weak acceptance criteria. A /project-manager that maintains planning docs and closes iterations cleanly. These roles have evolved across multiple projects. They have layering rules, discovery checklists, inheritance from a base engineering discipline file. They produce consistent, reviewable work because they're scoped — the backend architect doesn't touch test files, the test engineer doesn't redesign the schema, each persona has a defined mandate and exits cleanly. When I heard about Hermes Agent, my first instinct wasn't "let me learn a new system." It was: can I run my existing system inside this? The answer is yes. That's what this article is about — what it looks like to bring a mature workflow into Hermes, what you gain, where it breaks down, and what I'd do differently. What Hermes Is (and Isn't) to Someone Who Already Has a Workflow Hermes is an LLM-agnostic orchestration layer. It has its own skill system, its own soul.md concept for persistent agent identity, built-in cron scheduling and MCP management. All of that is real and useful. But it's also a runtime. If you have skills that work, you can bring them in. I installed a local Hermes instance — few clicks, straightforward setup — and ran it inside VSCode's integrated terminal pointed at my existing persona files. No migration. No rewrite. My /backend-architect runs in Hermes the same way it runs in Claude Code. Before settling on this, I'd tried a couple of other paths — a VPS instance with a Telegram interface for ideation, and attempting to build through a browser-based terminal. The VPS was fine for sketching ideas. The browser terminal ma