🚀 What I Built

I built Hermes Agent Assistant, a lightweight agentic AI system designed to demonstrate how modern AI agents can be structured using a modular architecture instead of a simple, single-prompt response model.

The system takes an abstract user task, breaks it down into structured steps using a dedicated planner, executes those steps sequentially via an execution engine, utilizes targeted tools, and stores the interaction context in a persistent memory system.

⚙️ Why I Built This

Most AI applications today are simple wrappers around LLMs that rely on a single input-output loop. I wanted to understand and demonstrate how production-grade, autonomous agent systems operate internally. Specifically, I wanted to explore how:

• Planning can be decoupled from execution to allow for complex error handling and multi-step reasoning.
• Tools can be dynamically integrated into an agent's reasoning loop.
• State and memory can persist across tasks to enable true contextual continuity.

Hermes Agent is my architecture simulation built to solve this problem in a highly accessible, lightweight, and scalable format.

🧠 System Architecture & Workflow

The codebase is split cleanly into four autonomous components that mirror real-world AI agent meshes:

       User Request (e.g., /run?task=...)
                     │
                     ▼
       ┌───────────────────────────┐
       │         PLANNER           │ ➔ Slices abstract goals into 
       └─────────────┬─────────────┘   structured, sequential steps.
                     │
                     ▼
       ┌───────────────────────────┐
       │        EXECUTOR           │ ➔ Orchestrates task completion 
       └─────────────┬─────────────┘   by processing each step.
                     │
                     ▼
       ┌───────────────────────────┐
       │       TOOLS LAYER         │ ➔ Provides functional utilities 
       └─────────────┬─────────────┘   (simulated web search, logic, maths).
                     │
                     ▼
       ┌───────────────────────────┐
       │      MEMORY SYSTEM        │ ➔ Persists execution logs statefully 
       └───────────────────────────┘   into local JSON storage.

📡 Production Showcases & Links

• 🌐 Live Production Demo: hermes-agent-tanush.onrender.com
• 💻 Open Source Repository: https://github.com/tanush326k/hermes-agent-assistant.git
• 🆔 Cloud Deployment Service ID: srv-d88revegvqtc73bdj380 (Render Infrastructure Node)

💡 What Makes It Different

Unlike traditional, rigid APIs or simple conversational chatbots, Hermes Agent:

• Thinks in Workflows: It establishes an internal chain-of-thought lifecycle before executing anything.
• Separates Reasoning from Action: Slicing the Planner from the Executor prevents cascading generation failures.
• Is Highly Extensible: New tools and custom utility logic can be dropped into the system without breaking core routing.
• Maintains Context Persistence: The custom memory module ensures state history is preserved between network calls.

🎛️ API Interaction Example

Request

POST /run?task=search AI agents HTTP/1.1
Host: hermes-agent-tanush.onrender.com

Response

{
  "task": "search AI agents",
  "plan": [
    "analyze request parameters", 
    "query tool registry for search utilities", 
    "summarize agent data structural output"
  ],
  "result": "final structured output successfully generated and written to persistent storage."
}

🧰 Tech Stack

• Core Language: Python 3.10+
• Web Framework: FastAPI (Asynchronous Server Gateway Interface)
• Production Server: Uvicorn
• Memory Layer: Volatile-to-Persistent JSON state manager
• Architecture Pattern: Modular Agentic Workflow Design

🔮 Future Improvements & Roadmap

• 🤖 Real Foundation LLM Integration: Swapping out simulated logic for live OpenAI, Anthropic, or local open-source Ollama completion hooks.
• 🗄️ Vector Database Memory Upgrade: Transitioning flatfile storage over to a proper semantic vector indexing framework (FAISS / ChromaDB) for semantic chunk lookups.
• 🤝 Multi-Agent Orchestration: Upgrading the workflow to host distinct Planner, Executor, and Critic agents working collaboratively with separate system prompts.
• ⚡ Live Server-Sent Events (SSE): Integrating real-time execution streaming so client frontends can observe the agent's thought process step-by-step.