A self-improving AI agent that learns your systems, loads what it needs, and gets out of your way. Forked from Nous Research's Hermes Agent — the agent with the built-in learning loop — and extended with modular capability loading, conservation-aware execution, and PLATO room-native architecture.
Hermes Construct does everything Hermes Agent does: runs on a $5 VPS, talks to you through Telegram or Discord, creates skills from experience, searches its own conversations, and works with any model (OpenRouter, z.ai/GLM, OpenAI, your own endpoint). Then it adds a module system on top: the agent watches what tasks come in, loads the tools those tasks need, and unloads them when they're no longer useful. You don't configure modules manually. The agent configures itself.
Hermes Construct = Hermes Agent + modular intelligence.
If you already know Hermes Agent, here's what's new:
| Feature | What It Does | Why It Matters |
|---|---|---|
| Module system | Load and unload capability packs at runtime | The agent decides what it needs per task. You don't pre-configure. |
| Conservation tracking | Every operation has an energy cost; the agent stays within budget | Prevents runaway API costs and infinite loops |
| Crackle pattern detection | Detects emergent patterns across task outputs after execution | Finds anomalies you didn't know to look for |
| Negative space testing | Defines behaviors the agent must never exhibit and enforces them | Catches problems traditional testing misses |
| Topology probing | Spectral analysis of how your components/systems connect | Measures whether the space between your services is healthy |
| Room-native architecture | Each task context is an isolated "room" with its own model settings | The environment adapts to the task, not the other way around |
| Ensign agents | Lightweight monitoring agents on cheap models that watch for anomalies | Expensive models only wake up when something needs attention |
| PLATO tutor | "Close enough" meaning matching (from the original 1970s PLATO system) | Evaluates agent output without exact string matching |
| ARM deployment | Cross-compiled for aarch64 (Oracle Cloud, Jetson, Raspberry Pi) | Run on $5/month ARM instances instead of GPU clusters |
If you don't know Hermes Agent yet, read on — everything below works on top of the standard Hermes install.
The name comes from an idea: the agent should be a construct — a structure you assemble from parts, not a monolith you install and hope fits. In our ecosystem, a "construct" is an agent whose capabilities are modular, loadable, and self-managing.
The original Hermes Agent already has skills (self-created Python scripts the agent writes during use). Hermes Construct extends this with compiled Rust modules that the agent loads and unloads at runtime, each providing a specific analytical or monitoring capability.
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
source ~/.bashrcgit clone https://github.com/SuperInstance/hermes-construct.git
cd hermes-constructcp .env.example .env
# Edit .env: add your API keys (the agent never sees them directly)
# Supported providers: OpenRouter, z.ai/GLM, Kimi/Moonshot, OpenAI, NovitaAI, any OpenAI-compatible endpoint# Cross-compile from x86
cargo build --release --target aarch64-unknown-linux-gnu
# Or build on the ARM machine directly
cargo build --release
./target/release/hermes-construct# Python entrypoint (full Hermes Agent features)
python cli.py
# Or the Rust binary (lightweight, ARM-friendly)
cargo run --releaseModules are the core addition. Here's the flow:
- You run a task — "Analyze my CI build times for the last month"
- The agent reads the task and determines it needs: pattern detection (crackle-runtime), budget tracking (conservation-checker), and topology analysis (cathedral-probe)
- The agent loads those modules — they snap into the runtime with a standard ABI (Application Binary Interface — a shared interface that lets different parts talk to each other)
- The agent runs the analysis using the loaded modules
- When the task is done, the agent unloads the modules — they're not consuming memory or API calls anymore
You didn't configure anything. The agent read the task, understood what it needed, loaded it, used it, and put it away.
| Module | What It Provides | Install |
|---|---|---|
| crackle-runtime | Emergent pattern detection across task outputs | cargo add crackle-runtime |
| negative-space-testing | Forbidden behavior checking — test what code doesn't do | cargo add negative-space-testing |
| conservation-checker | Track quantities that must not decrease (budget, energy, quota) | cargo add conservation-checker |
| cathedral-probe | Spectral topology analysis of component graphs | cargo add cathedral-probe |
| spacemap | Forbidden output zone checking — like a firewall for data | cargo add spacemap |
Each module works standalone in any Rust project. You don't need Hermes Construct to use them. They're listed here because Hermes Construct knows how to load them automatically.
A "room" is an isolated task context with its own:
- Model settings — temperature, max tokens, system prompt style
- Available tools — only what the room's task needs
- Conservation budget — how many API tokens/energy the room can spend
- JEPA gravity — a single number (f64) that captures "what shape of response works here." From that one number, the system derives temperature, prompt style, and sampling strategy. The model doesn't change — the room changes how it uses the model. This is fine-tuning without touching weights.
JEPA stands for Joint Embedding Predictive Architecture — a machine learning technique where a model learns by predicting how representations change, rather than memorizing specific outputs. In this context, it means the room predicts what kind of response works and adjusts accordingly.
The agent moves between rooms as tasks change. Each room is sandboxed — it can't see what isn't in its universe. This is filesystem-level isolation, not permission systems. A room that analyzes CI builds can't accidentally access your email room's context.
An "ensign" (named after the naval rank — a junior officer on watch) is a lightweight monitoring agent that runs on a cheap model and watches for anomalies. When something needs real attention, the ensign escalates to a more powerful model.
Think of it like a night security guard who radios the manager only when something unusual happens. Most of the time, the guard handles everything alone. The manager sleeps peacefully.
// ensigns/glm-flash.json — a cheap, fast ensign
{
"model": "glm-flash",
"alert_level": "yellow",
"cost_per_1k_tokens": 0.001,
"escalation_model": "claude-opus-4-8"
}The ensign stays at "yellow alert" (actively monitoring) even when the system is running fine — because the cost of missing a real problem always exceeds the cost of watching carefully.
Everything. Hermes Construct is a strict superset:
- ✅ All of Hermes Agent's features (CLI, TUI, Telegram, Discord, Slack, WhatsApp, Signal)
- ✅ Self-improving learning loop (skills, memory, session search)
- ✅ Scheduled automations (cron)
- ✅ Subagent spawning for parallel work
- ✅ Six terminal backends (local, Docker, SSH, Singularity, Modal, Daytona)
- ✅ Model-agnostic (OpenRouter, z.ai, OpenAI, Kimi, MiniMax, Hugging Face, custom endpoints)
- ✅ Voice memo transcription
- ✅ Desktop app with file drag-and-drop
We track upstream closely. See UPSTREAM-MERGE-AUDIT.md for the current sync status.
We're building toward a self-configuring agent that requires zero manual setup after onboarding. The full plan is in ROADMAP.md:
- Foundation — stabilize the fork, merge upstream security fixes
- Module system — runtime load/unload with standard ABI
- Self-configuration — agent reads tasks and loads what it needs
- Onboarding experience — first-run wizard with role presets
- Ecosystem — third-party module support and community contributions
- OpenConstruct — The agent onboarding platform (built on NVIDIA's OpenShell)
- AI Writings — 950+ stories and essays exploring AI creativity, constraint theory, and the philosophy of emergence
- SuperInstance Wiki — Ecosystem documentation and beta tester diaries
MIT — same as upstream Hermes Agent.
Hermes Construct is adapted from Nous Research's Hermes Agent (MIT) by SuperInstance.