Aether Agents — Multi-Agent System built on hermes-agent

Overview

What is Aether Agents?

Aether Agents is not a chatbot wrapper nor a simple IDE plugin. It is an agent ecosystem where each Daimon runs as a persistent process, gets spawned on first call, stays alive between sessions, and handles a single well-defined domain. All routing goes through Hermes — the orchestrator — via Olympus MCP. Workflows orchestrate multi-phase tasks across Daimons with HITL (human-in-the-loop) approval gates.

→ Each Daimon has a SOUL.md — a strict system prompt defining its role, responsibilities, and the things it must never do.

→ Daimons don't talk to each other. All routing goes through Hermes.

→ Every project tracked by Aether gets a .eter/ directory at its root — shared state across the team.

→ 6 workflow types with HITL gates — project-init, feature, bug-fix, security-review, research, refactor.

Architecture

How it works

Hermes connects to the Olympus MCP server via stdio. Olympus exposes three tools: talk_to(), discover(), and run_workflow(). Under the hood, Olympus uses the ACP (Agent Client Protocol) to spawn and communicate with each Daimon.

👤 You

→

⚡ Hermes Orchestrator

→ MCP stdio →

⚙ Olympus MCP Server

→ ACP →

◈ Daimons Persistent processes

talk_to() lifecycle

The talk_to() tool exposes 7 actions. Daimons are keep-alive — spawned on first open, they stay alive between sessions.

discover

Lists all available Daimons and their capabilities

open

Spawns the Daimon process (if not running) and creates an ACP session

message

Sends a prompt asynchronously — returns immediately with a session ID

poll

Non-blocking status check — returns current thoughts, messages, tool calls

wait

Blocks until the Daimon completes (max 600s timeout)

cancel

Aborts a running session

close

Closes the session. Agent process stays alive for next call.

.eter/ — Shared Project State

Every project tracked by Aether gets this directory structure at its root. Each Daimon owns a subdirectory.

PROJECT/.eter/
├── .hermes/     ← DESIGN.md + PLAN.md       (architecture, decisions)
├── .ariadna/    ← CURRENT.md + LOG.md       (status, session history)
├── .hefesto/    ← TASKS.md                  (implementation tracking)
└── .etalides/   ← RESEARCH.md               (append-only, only when used)

Workflows

Automated multi-phase tasks

Six canonical workflows orchestrate Daimons in sequence, with human-in-the-loop approval gates at critical points. Each workflow type is purpose-built — you don't start from scratch.

🚀 Project Init PM

Scaffold a new project from scratch — structure, configs, and .eter/ directory.

Participates

Hermes Ariadna Daedalus

HITL gates

Plan approval Final review

✨ Feature All

Implement a new feature end-to-end — research, design, code, and security audit.

Participates

Hermes Ariadna Etalides Daedalus Hefesto Athena

HITL gates

Research review Design review Audit review

🐛 Bug Fix 4 Daimons

Investigate, diagnose, and fix a bug. Research root cause, implement fix, verify security.

Participates

Hermes Etalides Hefesto Athena

HITL gates

Diagnosis review

🛡 Security Review Security

Proactive security audit — threat modeling, dependency CVE check, OWASP review.

Participates

Etalides Athena Hefesto

HITL gates

Findings review

🔍 Research Research

Deep-dive on a technical question. Structured findings with sources and confidence levels.

Participates

Etalides

HITL gates

None

🔧 Refactor Design

Restructure code without changing behavior. Impact analysis, scope review, implementation.

Participates

Daedalus Hefesto Athena

HITL gates

Scope review

Use talk_to() for single-Daimon consultations. Use run_workflow() for multi-phase tasks that need coordination and approval gates.

Daimons

The Team

Six specialized agents. Each has its own model configuration, tool access, and a SOUL.md that defines precisely what it does — and what it must never do.

Hermes Orchestrator

The only agent the user speaks to directly. Decomposes tasks, routes to the right Daimon, and synthesizes results. Owns .eter/.hermes/.

→ No implement code → No direct web search → No skip session close

Ariadna Project Manager

Maintains CURRENT.md and LOG.md. Detects blockers before they stop work. Provides session onboarding status on every open.

→ No architectural decisions → No code writing → No direct user contact

Hefesto Senior Developer

Receives specs from Hermes, spawns atomic sub-agents (Ergates) via delegate_task(role=...), consolidates results, and runs tests.

→ No design decisions → No ambiguous specs (report first) → Tracks via TASKS.md

Etalides Web Researcher

Uses web_search + web_extract. Every finding requires a source URL and a confidence level. Output is always structured: Findings / Sources / Confidence.

→ No opinions or recommendations → ≤10 links / standard mode → Append-only RESEARCH.md

Daedalus UX/UI Designer

Designs user flows, layout specs, and HTML/CSS prototypes. Performs UX review post-implementation to catch regressions. Ensures WCAG compliance.

→ No production code → No tech stack decisions → Minimum steps per flow

Athena Security Engineer

STRIDE threat modeling, OWASP review, dependency CVE auditing. Flags risks to Ariadna as sprint blockers. Activates proactively on new endpoints or dependencies.

→ No code implementation → All CVE search via Etalides → Risk before deployment

Pipeline

The 5-phase lifecycle

Every workflow follows a structured pipeline. Each phase has a clear owner, produces an artifact, and gates before the next phase begins.

1

IDEA

Hermes

2

RESEARCH

Etalides

findings review

3

DESIGN

Daedalus

design review

4

PLAN

Ariadna

plan approval

5

CODE

Hefesto

final review

1. IDEA

Hermes

User, Hermes

—

2. RESEARCH

Etalides

Etalides, Athena

Findings review

3. DESIGN

Daedalus

Daedalus, Hermes

Design review

4. PLAN

Ariadna

Ariadna, Hermes

Plan approval

5. CODE

Hefesto

Hefesto + all as needed

Final review

Phases run sequentially. Each phase produces an artifact (RESEARCH.md, DESIGN.md, PLAN.md, TASKS.md) stored in the project's .eter/ directory. No phase starts before the previous one's artifact exists.

Provider-Agnostic

Any model. Any provider.

Aether Agents doesn't prescribe a model. Any provider exposing an OpenAI-compatible API works. Each Daimon gets its own .env file — you can run Hermes on GPT-4o and Hefesto on a local vLLM instance, or use a single model for everything. Change it anytime.

OpenAI

https://api.openai.com

OPENAI_API_KEY

Anthropic

https://api.anthropic.com

ANTHROPIC_API_KEY

Google Gemini

https://generativelanguage.googleapis.com

GEMINI_API_KEY

Moonshot (Kimi)

https://api.moonshot.cn

MOONSHOT_API_KEY

OpenRouter

https://openrouter.ai

OPENROUTER_API_KEY

Ollama (local)

http://localhost:11434

No key needed

vLLM (local)

http://localhost:8000

No key needed

This is not an exhaustive list. Any OpenAI-compatible endpoint works.

Installation

Get started

1

Clone and install

git clone https://github.com/DarkArty07/Aether-Agents.git
cd Aether-Agents
python3 -m venv venv
source venv/bin/activate
pip install -e .

2

Configure each profile's .env

Each Daimon has its own .env.example. Copy it, fill in your API keys.

cp home/profiles/hermes/.env.example home/profiles/hermes/.env
# Repeat for ariadna, hefesto, etalides, daedalus, athena

3

Set HERMES_HOME and run

export HERMES_HOME=~/Aether-Agents/home

# Use the verification script
bash scripts/start.sh

# Or run directly
HERMES_HOME=~/Aether-Agents/home hermes --profile hermes

4

Test a specific Daimon

HERMES_HOME=~/Aether-Agents/home hermes --profile hefesto
HERMES_HOME=~/Aether-Agents/home hermes --profile ariadna