DEV Community: Sayista Yazdani

# I Watched 15 Hours of Hermes Agent Videos So You Don't Have To

Sayista Yazdani — Fri, 22 May 2026 11:41:42 +0000

This is a submission for the Hermes Agent Challenge

Okay, so I got curious about this thing called Hermes Agent. I kept seeing it pop up on YouTube. Some people were hyping it, others were confused. I decided to just sit down and watch what creators are actually doing with it — not the polished ads, but the real stuff. Here's what I found.

First, What Even Is This Thing?

Honestly, when I first heard "Hermes Agent," I thought it was some fancy new AI app. But it's not really that. It's more like a toolkit — a set of building blocks that let you create AI "agents."

What's an agent? Think of it like a really smart assistant that can do stuff for you. It can search the web, read files, write code, and then put it all together to give you an answer. That's basically it.

What I Actually Did

I watched over 15 hours of videos from different creators:

Some were livestreams (raw, unedited, people messing up in real time)
Some were "build with me" videos where they documented their whole process
I specifically looked for videos where things went wrong because that's where you actually learn

I skipped anything that looked too polished or had "revolutionary" in the title. I wanted the real deal.

How Is This Different From Other Tools?

Okay, so most AI frameworks work like this: they follow a strict step-by-step plan. Step 1, then Step 2, then Step 3. If one step breaks, the whole thing falls apart. It's like following a recipe exactly — miss one ingredient and your dish is ruined.

Hermes Agent feels different. It can do multiple things at the same time and adjust on the fly. If one part hits a problem, the other parts keep going and work around it.

Example from a video I watched:

A creator asked it to: book a flight, check visa requirements, look up weather, and add to calendar.

A normal tool would do this one by one. Slow and boring.

Hermes did this:

Checked visa and weather at the same time (because they're independent)
Kept searching for flights
Used the weather info to suggest what to pack
Put everything together in one answer

The creator didn't even tell it to do visa and weather together. It just figured that out itself.

"I didn't tell it to check weather and visa at the same time. It just... did."
— A YouTuber said this in their video, and I had to pause because that's actually cool

The Memory Thing Actually Works

Here's a test from another video. After using it for 3 days and 50+ back-and-forths, the creator asked: "What did we decide about that transformer paper from Tuesday?"

And it remembered:

Which exact paper it was
What the creator didn't like about it
The follow-up questions they had
That they decided to compare it with something called Mamba architecture

Other tools just save your chat history like a big text file. Hermes seems to actually understand and remember what's important, like a human would.

"Other frameworks feel like they have short-term memory loss. Hermes actually remembers and uses that memory to make better choices."

Setting It Up Is... Annoying (But Fixable)

Okay, real talk. I watched people struggle with setup. Here are the main headaches:

Problem 1: It works differently than normal code

Hermes runs things in "async" mode — meaning multiple things can happen at once. But if you're used to normal Python where things go one by one, this will confuse you.

The fix:

# This will break or hang
result = agent.run(task)

# Do this instead
result = await agent.execute(task)

Problem 2: Tool setup is picky

If you define a tool wrong, it fails silently and gives you a weird error later. You have to make sure your parameter names match exactly.

Problem 3: Config files are messy

Hermes looks for settings in multiple places — environment variables, then a file called hermes.yaml, then another file. If you have different settings in different places, it gets confused.

What actually worked (from a video where someone figured it out):

# This Dockerfile actually works
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY hermes.yaml .env ./
ENV HERMES_CONFIG_PATH=/app/hermes.yaml
COPY src/ ./src/
CMD ["python", "-m", "src.main"]

What Are People Actually Building With This?

What they're building	Why they chose Hermes
Research assistant (reading and summarizing papers)	Because it remembers what you read before
Coding helper (writing and fixing code)	Because it breaks complex tasks into smaller parts
Data pipeline (moving and cleaning data)	Because it handles errors without stopping everything
Personal note manager	Because it remembers things weeks later

Money Talk: Is It Expensive?

Thing	Other tools (LangChain)	Hermes
Weekly API cost	~$47	~$31
Lines of code for complex stuff	180+	40-60
Time to set up first agent	~2 hours	~45 minutes

Why cheaper? It doesn't overthink. It only plans deeply when it needs to. Other tools plan a lot even for simple stuff.

What Nobody Showed In Videos

Running 50+ agents together? Nobody did this. Most stopped at 4-5.
How to monitor it in production? Not covered.
What if it talks to a sketchy API? Security stuff — not discussed.
Can you train it for your specific work? Didn't see anyone try this.

My Setup Right Now

This is what I'm actually using, based on what I learned:

from hermes import Agent, PlannerConfig, MemoryConfig

agent = Agent(
    goal="My coding helper that remembers our previous chats",
    planner_config=PlannerConfig(
        max_parallel_tools=3,
        planning_depth="adaptive"
    ),
    memory_config=MemoryConfig(
        type="tiered",
        episodic={"retention_days": 14},
        semantic={"knowledge_graph": True}
    ),
    tools=[search_web, read_file, write_file, execute_code]
)

How fast is it?

One task: ~1.2 seconds
Three tasks together: ~2.8 seconds
Remembering old stuff: ~0.4 seconds

My Honest Take

Hermes Agent is like having a smart team that works together instead of one person doing everything step by step.

What's good:

Fast (does multiple things together)
Smart (figures things out on its own)
Remembers stuff properly
Doesn't break when one part fails

What's annoying:

Setup can be tricky
Smaller community (not as many people using it)
Documentation could be better

But if you want an AI that thinks about how to do the work, not just follows instructions blindly, it's worth trying.

Tell Me Your Experience

Have you tried Hermes Agent? Did you run into the same setup problems? What are you building with it?

Drop a comment — I want to learn from you too. If there's a video I missed that I should watch, let me know!

Tags: #HermesAgent #AI #DeveloperTools #Programming

# 🚀 Gemma Doc Pro: Privacy-First Codebase Intelligence Dashboard

Sayista Yazdani — Mon, 18 May 2026 18:55:13 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

Transform any codebase into a production-grade developer guide using Gemma 4. Visual architecture maps, security auditing, API surface detection, and smart Q&A — all 100% private and browser-native.

💡 What I Built

Gemma Doc Pro is a privacy-first, serverless codebase auditing and interactive documentation platform.

The Problem

When onboarding to a massive or legacy repository, developers waste days mapping out dependencies, identifying API surfaces, and detecting security gaps. Uploading proprietary enterprise code to cloud-hosted AI engines exposes businesses to critical compliance and IP leaks.

The Solution

Gemma Doc Pro solves this by performing 100% browser-native static analysis combined with the intelligent reasoning of Gemma 4. It processes local folders or direct public GitHub URLs, generates interactive 2D/3D visualizations, identifies API endpoints, evaluates OWASP security risks, and lets you chat with your codebase — all without a backend server.

💻 GitHub Repository

🔒 Why Browser-Native Analysis Matters

Traditional AI auditing tools often require uploading proprietary repositories to external servers, introducing privacy and compliance concerns.

Gemma Doc Pro performs dependency mapping, static analysis, and security heuristics directly in the browser. Only structured telemetry is processed by Gemma 4, minimizing exposure of sensitive source code while keeping infrastructure costs near zero.

📈 Performance Benchmarks

By moving the heavy lifting entirely to the browser, we unlocked incredible performance metrics:

⚡ Zero-Server Scalability: Analyzed repositories containing ~2,500 lightweight source files in under 8 seconds on modern desktop hardware..
🚀 Instant Tab-Switching: Mermaid SVG caching reduced re-render latency by 40% to 60% (rendering instantly on tab switch).
🌐 Fast GitHub API Sync: Cloned, parsed, and audited a repository (e.g., expressjs/express) in less than 15 seconds directly in the browser.

🗺️ Architectural Flow

Here is how Gemma Doc Pro parses, visualizes, and reason-audits your code client-side:

[ User Input ] 
    ├➔ Local Folder Upload (Dropzone)
    └➔ GitHub URL ➔ Batch API Content Fetcher (8 Concurrent Requests)
           │
           ▼
[ Browser Static Analysis Engine ]
    ├➔ Heuristic AST-like Tokenizer
    ├➔ File Dependency Import Mapper
    └➔ OWASP Vulnerability & Secret Scanner
           │
           ▼
[ High-Density Telemetry (DocData JSON) ]
    ├➔ 2D Mermaid Chart (With in-memory SVG Cache)
    ├➔ 3D Force-Directed Neural Map
    └➔ Framework Classification Labels
           │
           ▼
[ Gemma 4 Cognitive Synthesis ]
    ├➔ Automated Security Remediation (Roadmap Diff Engine)
    └➔ Contextual Q&A (Codebase Interactive Chat)

🔍 Real Security Detection Examples

Our TS static engine extracts vulnerabilities and passes them to Gemma 4 to generate immediate, secure code recommendations:

1. SQL Injection Detection

Vulnerable Code Detected:

$id = $_POST['id'];
$query = "SELECT * FROM users WHERE id = " . $id;
$result = mysql_query($query);

Gemma 4 Remediation Roadmap Recommendation:

// Safe Parameterized Query
$stmt = $pdo->prepare('SELECT * FROM users WHERE id = :id');
$stmt->execute(['id' => $id]);
$user = $stmt->fetch();

2. XSS (Cross-Site Scripting) Injection

Vulnerable Code Detected:

const userInput = new URLSearchParams(window.location.search).get('name');
document.getElementById('welcome').innerHTML = 'Hello ' + userInput;

Gemma 4 Remediation Roadmap Recommendation:

// Secure text assignment preventing DOM XSS
const userInput = new URLSearchParams(window.location.search).get('name');
document.getElementById('welcome').textContent = 'Hello ' + userInput;

🧠 How I Used Gemma 4

We selected Gemma 4 (Instruct) for this project. Because codebase context can be massive, we run a local heuristic model to reduce thousands of lines of raw code down to high-density structured telemetry (routes, file imports, code violations, structure maps). This structured metadata (DocData) is then fed to Gemma 4, allowing the model to work within a highly optimized context window.

1. Cognitive Roadmap (AI Refactoring)

Gemma 4 processes detected vulnerabilities (e.g., OWASP violations or hardcoded secrets) and generates exact, production-ready secure refactoring suggestions (as shown in our code examples).

2. Conversational Q&A (Gemma Chat)

Using the pre-compiled static telemetry context, Gemma 4 powers an interactive developer chat:

User: "Does our Express API handle user input sanitization properly in our database routes?"

Gemma 4: "Looking at your routing table: /api/users uses direct string query evaluation without standard sanitization middlewares. You should install express-validator and add... [Code Snippet]"

🛠️ Challenges Faced (And How We Solved Them!)

Challenge 1: The XAMPP / Git Executable Bottleneck 🚪

The Issue: Initially, GitHub syncing required cloning repositories via a server-side PHP script. In local developer environments (like XAMPP), Apache permission limitations and missing git path variables made server-side cloning extremely unstable and slow.
The Fix: We completely removed the server dependency! We rewrote the sync utility to consume the GitHub REST API directly from the frontend. It fetches repository file trees recursively and downloads files in throttled parallel batches of 8, decoding base64 content directly into browser-native virtual File arrays.

Challenge 2: Mermaid.js Rendering Chokehold 🗺️

The Issue: Complex dependency diagrams require heavy computational power to render. In React, switching back and forth between tabs triggered mermaid.render() from scratch every time, freezing the UI for 1–2 seconds.
The Fix: We built an in-memory useRef SVG rendering cache. When a graph is rendered once, its output is keyed by the codebase hash and cached. Returning to the tab loads the cached layout instantly, keeping page navigation incredibly fast and lag-free.

🧩 Supported Framework Detection

Gemma Doc Pro can automatically classify and analyze projects built with:

React / Next.js
Express.js
Laravel
Django
FastAPI
Vue
Node.js
TypeScript Monorepos
PHP MVC Architectures

💻 Getting Started

1. Clone & Install

git clone https://github.com/your-username/gemma-doc-pro.git
cd gemma-doc-pro
npm install

2. Set Up Environment Variables

Create a .env file in your root directory:

VITE_GEMMA_API_KEY=your_google_gemini_api_key_here

3. Run Locally

npm run dev

Open http://localhost:5173 in your browser!

🏆 Dev.to Contest Categories

Build Category

Gemma Agent Smart Use: Splits workloads by using a fast AST tokenizer locally and reserving Gemma 4 for high-value reasoning (audit suggestions and codebase chat).
Code Quality: Clean TypeScript (strict mode), batched async fetch pools, modular component design, and zero-backend portability.
Usability: Seamless dynamic state resets, in-memory layout caching, bilingual language toggling, and adaptive mobile-first layouts.

Writing Category

Clear Explanation: Structured visual architecture flows, detailed real-world security examples, and technical problem-solving breakdowns.
Originality: Moving away from standard cloud-centric AI wrappers to build a 100% private, serverless, browser-native developer tool.

Gemma Doc Pro makes software architecture readable, audits instant, and code security accessible to developers everywhere, privately and locally.

🚀 Beyond the Code: What I Learned Today About DNS Records (A, AAAA, and CNAME)

Sayista Yazdani — Thu, 14 May 2026 13:43:59 +0000

Beyond the Code: What DNS Actually Taught Me as a Developer

I used to think DNS was just a “DevOps thing.”

Until today 😅

While configuring subdomains and SSL for my project, I spent hours inside Cloudflare trying to figure out why everything looked correct… but still wasn’t working.

And honestly?
That debugging session taught me more practical networking knowledge than many tutorials ever did.

Here’s the simplest explanation of DNS records I wish someone had given me earlier 👇

📍 A Record → “Direct Address”
Used when you want your domain to point directly to a server’s IPv4 address.

Example:
mywebsite.com → 192.0.2.1

Think of it like saving someone’s exact house number.

📍 AAAA Record → “Modern Internet Address”
Same purpose as an A Record, but for IPv6 addresses.

If your hosting provider gives you a long address like:
2001:db8::1

…you’ll use AAAA instead.

📍 CNAME Record → “Nickname”
This one finally clicked for me today.

Instead of pointing to an IP, a CNAME points one domain to another domain.

Example:
mocks.mbapathshala.com → another-service.com

This is super useful for services like:
• Shopify
• Vercel
• Heroku
• Testpress

Because if their IP changes, your setup still works automatically.

But here’s the catch 👇

⚠️ You generally should NOT use CNAME for your root domain (example.com).
Use it mainly for subdomains like:
• www.
• blog.
• api.
• mocks.

The 2 Biggest Lessons I Learned Today:

☁️ 1. The “Grey Cloud” Trick in Cloudflare
When using third-party SSL services, Cloudflare Proxy (Orange Cloud) can sometimes create SSL handshake issues.

Switching the record to:
DNS Only (Grey Cloud)

…instantly fixed my problem.

🤝 2. Nameservers Are the Real Connection
Adding DNS records inside Cloudflare means nothing until your domain registrar (GoDaddy, Namecheap, etc.) points the domain to Cloudflare Nameservers.

That’s the actual handover step.

Without that, your DNS records are basically just drafts.

One thing I realized today:

As developers, we spend so much time writing code…
…but DNS is the bridge that actually connects our work to real users.

And when DNS breaks — everything breaks 😅

What’s your biggest DNS or deployment horror story?
I’d genuinely love to hear the lessons others learned the hard way 👇

WebDevelopment #DNS #Cloudflare #FullStackDevelopment #LearningInPublic #DevOps #SoftwareEngineering #Backend #Programming #BuildInPublic

🚀 Types of Hosting Every Developer Should Know

Sayista Yazdani — Tue, 12 May 2026 14:05:44 +0000

Here are the 4 most common hosting types every developer should understand 😊

Choosing the wrong hosting solution can directly impact:

Performance
Scalability
Deployment stability
Security
Reliability

Most beginners ask:
“Hosting kitne ka hai?”

But the more important question is 🧐🤔:
“Will my application run properly on this hosting environment?”

Here are the four major hosting types every developer should understand:

Shared Hosting Multiple websites share the same server resources such as CPU, RAM, and bandwidth.

Best suited for:

Portfolio websites
Blogs
WordPress sites
Small PHP applications

Advantages:

Cost-effective
Beginner friendly
Easy to manage

Limitations:

Limited scalability
Lower performance under traffic spikes
Restricted server control

VPS Hosting (Virtual Private Server) A physical server divided into isolated virtual servers with dedicated resources.

Best suited for:

Node.js applications
APIs
SaaS products
Real-time applications

Advantages:

Better performance
Full server access
Supports modern development stacks

Limitations:

Requires Linux/server knowledge
Manual maintenance and security management

Cloud Hosting Applications run on multiple interconnected servers with dynamic scaling capabilities.

Popular platforms:

AWS
Google Cloud
Azure
DigitalOcean

Best suited for:

Scalable applications
Startups
High-traffic systems
Production-grade platforms

Advantages:

High availability
Flexible scaling
Better uptime

Limitations:

Steeper learning curve
Infrastructure complexity
Cost management can become challenging

Dedicated Hosting An entire physical server is allocated to a single business or application.

Best suited for:

Enterprise applications
Large-scale systems
Extremely high traffic platforms

Advantages:

Maximum performance
High security
Complete hardware control

Limitations:

Expensive
Requires advanced server management expertise

One important lesson I’ve learned over the years:
Hosting is not just about uploading files.

Modern deployment also involves:

Security
Monitoring
Backups
CI/CD
Scalability
Reliability
Infrastructure optimization

My recommendation for developers:
Start with Shared Hosting to understand the basics, move to VPS to learn server management, and eventually explore Cloud Hosting to build scalable production systems.

I'd love to hear from you—what hosting type has worked best for your projects? Share your experiences in the comments!

WebDevelopment #Backend #DevOps #Linux #CloudComputing #Hosting #SoftwareEngineering #AWS #Programming #knowledge #development #production

How Homebrew changes everything in developers life👇

Sayista Yazdani — Fri, 08 May 2026 13:01:07 +0000

🚀 Still installing software manually on macOS?
You're wasting hours every month.

Here’s why Homebrew changes everything 👇

What it is: Open-source package manager that installs software via terminal — no more DMG hunting.

Why it wins:

• One command installs CLI tools + GUI apps
• Auto-handles dependencies — no version conflicts
• Keeps everything updated with brew upgrade
• 6,000+ packages (Git, Node, Python, VS Code, Chrome...)

Quick example

Install your core dev stack in seconds:
brew install git node python

2026 Update (v5.0):

• Parallel downloads by default → 2x faster installs
• Linux ARM64 officially supported
• macOS 26 (Tahoe) ready
• Heads up: Intel Mac support ends Sept 2027 — plan migration now

Using homebrew

To use homebrew, you can again open your terminal and run brew commands.
A list of useful commands:

brew --version: Display the installed version of homebrew
brew help: Display the help
brew doctor: Check the system for potential issues
brew update: Fetch the latest homebrew version
brew upgrade: Upgrade all brews (packages)
brew list: List all installed packages
brew install <formulae>: install specific formula
brew services start <service>: Start a specific service

💡 Pro Tip:
Use a Brewfile to set up your entire dev environment in one command:
brew bundle

Dev impact: New Mac setup in minutes, not hours. Team environments stay consistent. Brewfile = your entire stack in one file.

💬 What’s the first package you install with Homebrew?