Three Agents, Three Philosophies

March 17, 2026 · 8 min read

If you've used an AI coding agent in the past year, you've probably encountered OpenClaw — the TypeScript-based personal AI assistant that connects to 23+ messaging channels. You may have also heard of Hermes, the self-improving Python agent from Newest Research that's been quietly gaining traction among developers who want something fundamentally different.

But there's a third contender that occupies entirely different territory: AGNT — a full-stack AI operations platform that combines visual workflow automation, multi-agent orchestration, unlimited tool integrations, and an autonomous goal execution loop, all running locally on your machine.

This article is a deep technical comparison. Not "which is best" — but which architecture fits the way you want to work.

Photo by Jordan Harrison on Unsplash

The One-Sentence Summary

Before we dive into source code, here's the mental model:

OpenClaw = The operating system for your AI assistant — a unified control plane across every messaging channel you use.

Hermes = The self-improving agent — optimized to learn from doing, with elegant simplicity.

AGNT = The AI command center — a self-generating platform that creates its own agents, workflows, tools, skills, and widgets on demand. Not just an agent — an entire AI operations hub that grows with you.

Now let's see how they actually work under the hood.

Core Architecture

The first thing that strikes you about each project is how different their architectural philosophies are.

OpenClaw: The WebSocket Gateway

OpenClaw is built in TypeScript on Node.js 22. Its central abstraction is a WebSocket-based gateway — a single process that becomes the control plane for your entire AI assistant experience. Everything flows through this gateway:

• Message routing across 23+ channels (WhatsApp, Telegram, Slack, Discord, Signal, iMessage, Teams, Matrix, and more)
• Session management with phase tracking
• Event streaming with strictly monotonic sequence numbers and 150ms text delta throttling
• RPC-based agent runtime for tool execution

You run one gateway process on your machine, message it from any channel, and it executes real tasks on a real computer. The architecture is designed for reach — one brain, every channel.

Hermes: The While Loop

Hermes is built in Python. Its core is a single class called Agent in run_agent.py — over 3,600 lines containing the entire agent loop. The main method run_conversation is beautifully simple:

while True:
    1. Check interrupts
    2. Consume iteration budget
    3. Build API messages
    4. Make LLM call
    5. Process tool calls or return response

No event bus. No WebSocket protocol. No middleware. Just a loop. The simplicity is intentional — it enables direct control over every aspect of the agent's behavior. When something goes wrong, you know exactly where to look: one file, one loop, one execution path.

AGNT: The Self-Generating Platform

AGNT is built as a TypeScript/Node.js backend with a VueJS frontend, packaged as a local Electron app. Its architecture is fundamentally different from both OpenClaw and Hermes because it's not just an agent — it's a platform that generates its own infrastructure on demand.

The key insight: AGNT ships with a built-in AI assistant (called Annie) that is available everywhere in the app. You don't configure things manually — you ask for what you need, and the system creates it:

• "I need an agent that monitors my GitHub PRs" → Agent auto-created with the right tools, skills, and system prompt
• "Build me a workflow that alerts me when Bitcoin drops below $60k" → Visual workflow generated with timer trigger, API node, conditional logic, and email alert
• "Create a tool that checks my Stripe revenue" → Custom tool scaffolded in ToolForge, immediately available to all agents
• "Import this skill.md file" → Skill loaded, parsed, and assigned to relevant agents

The platform has 65+ API endpoint groups powering this self-generation:

The design philosophy: the system builds itself. You describe what you want, and the platform generates the agents, workflows, tools, and skills to make it happen.

LLM Provider Support

How many models can each system talk to?

The takeaway: OpenClaw has the most mature failover story. Hermes wins on cost optimization. AGNT wins on sheer breadth — 15+ providers out of the box, with the ability to add more dynamically via a single API call or by asking the assistant.

Tool Systems: Where the Rubber Meets the Road

Tools are what make agents useful. The three projects take radically different approaches.

OpenClaw: The Plugin Architecture

OpenClaw uses a plugin-based tool system with a rich hook system:

• Before/after tool call hooks
• LLM input/output interception
• Priority ordering for plugin execution
• Extremely powerful for building complex, multi-stage workflows

This is the most "enterprise" approach — highly configurable, but requires understanding the hook lifecycle.

Hermes: The Registry Pattern

Hermes uses a flat registry pattern — each tool module calls registry.register at import time. Tools are organized into tool sets (web, terminal, skills):

• Simpler mental model: register a function, it becomes a tool
• Concurrent execution with up to 8 workers running tools in parallel
• Certain tools marked as "never parallel" (e.g., terminal commands that modify state)
• More transparent — you can read every tool's implementation in one pass

AGNT: The Unlimited, Self-Expanding Ecosystem

AGNT's tool system is designed to be boundless. It operates across four distinct layers, and every layer can grow on demand:

The critical difference: in OpenClaw and Hermes, you write code to add a tool. In AGNT, you describe the tool you want — in plain English — and the built-in assistant creates it for you in ToolForge. It's immediately available to every agent in the system.

For example:

• "Create a tool that fetches the current weather for any city" → JavaScript tool with API call, error handling, and emoji formatting — generated and registered in seconds
• "I need a Python tool that analyzes CSV files and returns summary statistics" → Python-based tool with pandas, created via ToolForge
• "Make an AI tool that rewrites text in a professional tone" → AI-prompt tool that wraps an LLM call with a specific system prompt

The tool count isn't fixed — it's whatever you need it to be.

Memory & Learning: The Biggest Differentiator

This is where the three systems diverge most dramatically.

OpenClaw: Session Transcripts + Vector Search

OpenClaw stores conversations as JSONL session transcripts with a pluggable context engine. Memory options include:

• File-based storage
• LanceDB vector database for semantic search
• Context compaction via LLM summarization with 1.2x safety margin

Solid engineering, but no learning loop — the agent doesn't get better over time, it just remembers more.

Hermes: Three-Layer Memory + Skills

Hermes has the most sophisticated memory system of the three, organized into three layers:

Layer 1 — Persistent Memory: memory.md and user.md files loaded once at session start. Never mutated mid-session (this is deliberate — stable system prompts maximize prompt cache hits, saving ~75% on API costs).

Layer 2 — Session Database: SQLite with WAL mode and FTS5 full-text search for semantic search across past conversations. Every session is indexed and searchable.

Layer 3 — Honcho Integration (optional): An external AI memory service that uses dialectic reasoning — the system argues with itself about what to remember, creating more robust long-term memories.

And the crown jewel — Skills (Procedural Memory): After solving a complex problem (5+ tool calls), Hermes autonomously creates a skill — an .md file with front-matter metadata, step-by-step instructions, and platform-specific notes. On repeat tasks, this collapses 15 tool calls down to 3.

Skills have:

• Platform awareness (different instructions for macOS vs. Linux)
• Conditional visibility (skills only appear when relevant tools are available)
• Full lifecycle management (create → test → improve → deprecate)
• Community sharing via agentskills.io
• Security scanning for prompt injection, credential exfiltration, and other threats

This is the feature that makes Hermes fundamentally different. The agent genuinely learns.

AGNT: Structured Goals + SkillForge Evolution

AGNT approaches learning from a different angle — not through conversation memory, but through structured goal execution traces and a skill evolution pipeline that validates learning before trusting it.

The Goal System (AGI Loop):

for each iteration (max configurable):
    1. GoalProcessor decomposes goal into ordered tasks
    2. AgentTaskMatcher assigns the best agent per task
    3. TaskOrchestrator executes tasks with tool calls
    4. GoalEvaluator scores outputs against success criteria
    5. If score < threshold → replan failed tasks, update world state
    6. Git checkpoint → commit iteration state
    7. Repeat until pass or max iterations

Every goal execution produces a rich trace: task inputs, outputs, tool calls, errors, recoveries, world state transitions, iteration history, and evaluation scores. This isn't just "memory" — it's a complete audit trail of how the agent solved a problem.

Skills & SkillForge (Autonomous Skill Evolution):

AGNT supports importing .skill.md files directly — drop one in or ask the assistant, and the skill is immediately parsed, loaded, and available for assignment to any agent. But the real power is in SkillForge, which autonomously evolves skills from goal execution traces:

1. Analyze: TraceAnalyzer extracts transferable patterns from goal execution traces
2. Generate: Distill patterns into a skill candidate (.SKILL.md)
3. Test: A/B test the skill — run a similar goal with and without it
4. Decide: Keep if the Skill Effectiveness Score (SES) improves, discard if not
5. Promote: Skills scoring >90% SES become Gold Standards, available to all agents

The key difference from Hermes: AGNT skills aren't just created — they're validated through controlled experiments before being trusted. And they evolve across generations, building on what worked in previous versions. Skills can also be imported from external sources, shared across installations, and versioned with full lineage tracking.

Visual Workflows: AGNT's Unique Advantage

Neither OpenClaw nor Hermes has anything comparable to AGNT's visual workflow system. This is an entire category that AGNT occupies alone.

Workflows are built with a drag-and-drop node editor — or generated automatically by asking the built-in assistant. The system can create arbitrarily complex automation pipelines. Some examples of what users build:

Each workflow supports:

• 50+ built in trigger types: Timer (every minute to monthly), webhooks, email inbox, Discord messages, Slack messages, Google Sheets new rows, etc
• Conditional routing with JavaScript expressions on edges
• Version control with checkpoints and rollback
• Any tool as a node — every tool in the system (built-in, plugin, custom, MCP) can be a workflow step
• AI nodes — any step can invoke an LLM for intelligent processing, summarization, or decision-making

The number of workflows is unlimited. Users generate new ones constantly — either by building them visually in the drag-and-drop editor, or simply by describing what they want to the built-in assistant. "Build me a workflow that monitors my competitors' pricing pages every hour and emails me a summary" — and it's done.

This is where AGNT bridges the gap between "AI agent" and "automation platform." You get the intelligence of an LLM agent and the reliability of a visual workflow engine.

Multi-Agent Orchestration

OpenClaw: One Agent, Many Channels

OpenClaw runs a single agent but routes it across 23+ messaging channels. The same brain answers your WhatsApp messages, Slack DMs, and Telegram chats. Per-channel routing lets you customize behavior by platform, and multi-agent routing is available for different channels.

Hermes: One Agent, Self-Improving

Hermes is also a single agent, but one that improves itself over time through skills and memory. The focus is depth over breadth — one agent that gets progressively better at everything, rather than many agents with static capabilities.

AGNT: Unlimited Auto-Generated Agents

AGNT doesn't ship with a fixed roster of agents — it generates them on demand. The system auto-creates specialized agents based on what you need, and each agent is fully configurable:

• Individual provider/model selection — assign any of the 15+ providers and any model to each agent (e.g., one agent on Claude Opus for complex engineering, another on GPT-4o-mini for fast triage)
• Assigned tools — each agent gets exactly the tools it needs, from 1 to all of them
• Assigned skills — skills are injected into agent system prompts, giving each agent specialized knowledge
• Assigned workflows — agents can trigger and manage automated workflows
• Credit limits and success rate tracking — monitor each agent's cost and performance
• Category classification — organize agents by domain (Operations, Business, Creative, Engineering, Research, etc.)

For example, a user might say:

• "Create an agent that's an expert financial analyst with access to Stripe and QuickBooks" → Agent created with the right tools, a finance-specific system prompt, and relevant skills
• "I need a code review agent that uses Claude Opus" → Agent created on Claude Opus with shell, file, and Git tools
• "Make me a social media manager that can post to Twitter and LinkedIn" → Agent created with social media plugins and a content strategy skill

The AgentTaskMatcher in the goal system automatically selects the best agent for each task based on tool overlap, skill match, and historical success rate. This means the goal system isn't just running one agent in a loop — it's orchestrating a team of specialists that the system itself created.

Security Models

Hermes wins on defensive depth — it's the most paranoid about what tools can do. AGNT wins on identity and access management — 50+ OAuth2 providers, JWT auth, credit limits per agent.

Integration & Ecosystem

Channel Coverage

OpenClaw dominates messaging channels. If "meet the user where they are" is your philosophy, OpenClaw is unmatched.

API & Service Integrations

AGNT's 50+ connected OAuth2 providers give it a massive integration advantage — and new providers can be added at any time via the custom providers API:

Productivity: Google (Sheets, Drive, Slides, Calendar), Notion, Airtable, Todoist, Evernote, Obsidian, Asana, ClickUp, Monday, Trello
Developer: GitHub, Atlassian/Jira, Figma, Zapier
Communication: Slack, Discord, Twitter/X, LinkedIn, Facebook, Zoom
Finance: Stripe, Plaid, QuickBooks, Xero, Bankr (crypto)
Sales/CRM: Salesforce, HubSpot, Intercom, Zendesk
Storage: Dropbox, Google Drive
Analytics: Tableau, Analytics
Mail: Gmail, Mailchimp
Other: Canva, DocuSign, Unsplash, OpenWeatherMap, Firecrawl

MCP Ecosystem: Beyond OAuth2 integrations, AGNT connects to the entire Model Context Protocol ecosystem — thousands of community-built MCP servers covering everything from Chrome DevTools and Figma to database management, system monitoring, and filesystem access. Any MCP server can be added by URL or npm package name.

Neither OpenClaw nor Hermes comes close to this level of integration breadth.

The Head-to-Head Scorecard

Choosing Your Architecture

Choose OpenClaw if...

• 📱 You live across messaging platforms and want one AI brain answering everywhere
• 📲 You need native mobile apps (iOS, Android) with device integration (camera, screen recording, voice wake)
• 🔌 You want a mature plugin system with before/after hooks and priority ordering
• 💬 Your primary use case is conversational assistance across channels
• 🖥️ You want device integration — canvas, screen recording, voice activation

Choose Hermes if...

• 🧠 You want an agent that genuinely learns — skills that collapse 15 tool calls down to 3
• 🐍 You're a Python developer and want to understand every line of the agent loop
• 💰 Cost matters — prompt caching saves ~75% on multi-turn conversations
• 🔧 You want maximum transparency — one file, one loop, one database
• 🔒 You need aggressive security against shell injection and prompt attacks
• 🌐 Community skill sharing is important to your workflow

Choose AGNT if...

• 🎯 You need autonomous goal execution with plan → execute → evaluate → replan loops
• 🔄 Visual workflows are important — timer triggers, webhooks, conditional routing, drag-and-drop
• 👥 You want the system to auto-generate specialized agents — describe a role and it's created with the right tools, skills, and model
• 🔌 You need to connect to 50+ SaaS services via OAuth2, plus thousands of MCP servers
• 🛠️ You want to create custom tools by describing them in plain English — no coding required
• 📦 You want to import .skill.md files and have the system immediately integrate them
• 📈 You want a skill evolution system that A/B tests skills before trusting them
• 🧩 You need a platform that grows with you — every agent, workflow, tool, and skill you create makes the whole system more capable

The Convergence Thesis

Here's what's interesting: these three projects are converging from different directions toward the same destination — an autonomous, self-improving AI system that integrates deeply with your digital life.

• OpenClaw started from channels — be everywhere the user is
• Hermes started from intelligence — make the agent smarter over time
• AGNT started from orchestration — coordinate agents, tools, workflows, and goals, and let the system generate its own infrastructure

Each project's weakness is another's strength:

The agent ecosystem is not winner-take-all. It's a composable landscape where these architectures can complement each other. Imagine OpenClaw's channel reach feeding into AGNT's workflow engine, with Hermes-style skills evolving autonomously via SkillForge. That's not science fiction — it's a plausible near-term integration.

The Deeper Lesson

All three projects share a conviction that's quietly reshaping software: the age of manually configured AI is ending.

• OpenClaw says: "Don't make me switch apps — be everywhere."
• Hermes says: "Don't make me repeat myself — learn from what I do."
• AGNT says: "Don't make me build anything — describe what you need and the system generates it."

Each is a different answer to the same question: what does the human actually need to do? The less, the better. The trajectory is clear — from manually prompting a chatbot, to configuring an agent, to describing a goal and letting the system build itself around it.

We're not there yet. But these three projects — all open-source, all production-grade, all running on your own hardware — are the leading edge.

Source Code & Links

All three projects are open-source:

• OpenClaw: GitHub — TypeScript, Node.js 22
• Hermes: GitHub — Python, single-file agent
• AGNT: agnt.gg — TypeScript/VueJS, full-stack platform

This article is part of AGNT's Architecture Deep Dive series, exploring the technical foundations of autonomous AI agent systems. For more, see our comparison of Karpathy's Autoresearch vs. AGNT and Executor vs. AGNT AI Tool Infrastructure.