Hermes Loop is the control room for the Hermes Agent.

Agent runs treated like database transactions, not chat sessions.

One design decision drives everything else. A normal chat product treats agent runs like conversations: a transcript, a vibe, "the model said it would do X." Hermes Loop treats them like database transactions: every prompt, every raw response, every tool call, every approval, every memory injection is a discrete row you can query, replay, and prove. The four practical consequences:

Everything else — schema self-correction, retries with exponential backoff, real-cost accounting via live per-model pricing, memory governance, the trust ledger, the evals harness, the worker queue for queued missions — falls out of that one decision. If it's worth doing, it has a row. If it has a row, it's in the receipt.

The capabilities you get because of those four pillars.

A chatbot gives you an answer. A real workflow needs proof.

When the work matters — auditing a website, drafting a refund letter, building a paper-trade thesis, triaging a messy request — a single chat reply isn't enough. You need to know which model ran, which tools it called, which memory it relied on, what went wrong if it failed, and what requires your sign-off before it leaves the desk. None of that is observable when you paste a prompt into a chat box.

Hermes Loop treats every run as a mission: a structured, ordered, validated execution of a crew of agents. Every prompt and every response is persisted. Every tool call is logged and Zod-validated. Every memory injection is recorded. Risky outputs (a draft email, a simulated trade, a report export) wait for you to approve them. When the run is over, a receipt with a deterministic integrity hash captures the whole thing.

Six steps from raw request to verifiable receipt.

1. 1Request

   You type an objective, drop messy text in the inbox, or fire a schedule. Triage classifies messy input and proposes a crew + objective.

2. 2Crew

   Pick a built-in crew (Bug Hunter, Paper Trading Desk, Life Admin) or build a custom one. A crew is an ordered list of specialist agents, each with its own system prompt and Zod schema.

3. 3Job

   In production, the request becomes a RUN_MISSION job. The worker picks it up, runs it serially with retries + exponential backoff, and records every transition.

4. 4Tools + Memory

   Each agent calls Hermes with its prompt + relevant memory. It can request sandboxed tools — browser_qa_audit (Playwright), terminal_exec, python_rpc, web_search (Tavily), vision_analyze (Gemini), image_generate, text_to_speech (ElevenLabs), web_snapshot, document_extract, price_series_lookup, deadline_create, report_export_draft. Tool calls are logged and validated.

5. 5Approval

   Drafts, trade tickets, exports, and gated tools become ApprovalItems. Nothing leaves the desk on its own. You approve, reject, or request changes.

6. 6Receipt

   When the run finishes, a WorkflowReceipt is generated: timeline, cost (real per-model rates), risk score, integrity hash. It rolls up into the trust ledger.

The orchestrator loop, end to end.

The orchestrator runs each agent of the crew in sequence. For every agent, it:

1. Builds a system prompt + user prompt from the agent's spec, the mission objective, prior agents' outputs, the selected memories, and the tool catalog this agent is allowed to use.
2. Calls hermesChat against ${HERMES_API_BASE}/chat/completions with response_format: json_object. Retries 429 / 5xx / network failures with exponential backoff, honouring Retry-After.
3. Parses the JSON. If the model wrapped it in {final: …}or a single named envelope, the orchestrator unwraps it. If JSON is malformed it re-prompts with the parser error.
4. Validates the parsed payload against the agent's Zod schema. On failure, it re-prompts the model with a short list of the specific schema errors and asks for a corrected response. Capped at two corrections per step (audit events: agent.json_parse_retry, agent.schema_correction, agent.output_unwrapped, agent.output_repaired).
5. If the model requested tools and the agent allows them, the tools run server-side. Their output feeds the next round. Tools flagged requiresApproval halt the mission and surface as an ApprovalItem.
6. Persists an AgentRunStep row with the prompt, the raw response, the parsed JSON, latency, and token counts. Emits an AuditEvent.
7. Merges the agent's output into the running context for the next agent.

When all agents finish, the crew-specific finalize step composes a Deliverable (BUG_REPORT, DRAFT, TRADE_JOURNAL, etc.) and the appropriate ApprovalItem(s). The mission moves to WAITING_APPROVAL. The receipt is generated, hashed, and rolled into the trust ledger.

A normal chatbot vs Hermes Loop.

Every object you see in the UI is a real database row.

Hermes Loop is Prisma + SQLite locally, Postgres in production. The schema is the source of truth — you can run prisma studio any time and inspect every row.

UserProfile ─┐
             ├─< Mission ─┬─< MissionAgent
             │            ├─< AgentRunStep   (prompt + rawResponse + parsedOutput + tokens + latency)
             │            ├─< ToolCall       (name, input, output, status, agentRunStepId)
             │            ├─< ApprovalItem   (PENDING | APPROVED | REJECTED | NEEDS_CHANGES)
             │            ├─< Deliverable    (REPORT | DRAFT | TRADE_JOURNAL | BUG_REPORT)
             │            ├─< AuditEvent     (every prompt, response, tool, approval, error)
             │            ├─< MemoryUsage    (which MemoryItems were injected, why)
             │            └─< WorkflowReceipt (status, integrityHash, riskLevel, content blob)
             ├─< AgentJob          (TRIAGE_INBOX | RUN_MISSION | RUN_SCHEDULE | RESUME_AFTER_APPROVAL)
             ├─< ScheduledMission  (cron-like cadences with timezone-aware nextRunAt)
             ├─< MemoryItem        (operator-approved persistent context)
             └─< InboxItem         (raw request → triaged → converted into Mission)

What the desk will and will not do without you.

• No real trading. Paper Trading Desk creates PaperTrade rows with simulatedOnly = true. There is no broker integration.
• No automatic emails. Life Admin creates EMAIL_DRAFT approval items. Nothing is sent — drafts only.
• No silent fallbacks. When Hermes env vars are configured, network/API failures surface as real errors. The demo responder is only used when the env vars are entirely absent.
• SSRF guard on browser_qa_audit. Localhost / private / metadata IPs are blocked by default. The dev-only escape hatch requires both NODE_ENV != production and ALLOW_LOCAL_BROWSER_QA = true.
• Auditability is first-class. Every prompt, every response, every tool call, every approval is a database row. The receipt's integrity hash is deterministic and content-addressed.

If your work needs proof, this is for you.

Every page in the app, one line each.

• DashboardMission status, attention queue, deliverables, audit feed.
• CrewsBuilt-in and custom agent templates.
• ToolsSandbox surface for terminal, Python, web search, vision, images, TTS, integrations.
• TrustAggregate reliability + risk roll-up across all runs.
• InboxDrop messy requests; triage proposes a mission.
• JobsPersistent queue for triage, missions, schedules, resumes.
• MemoryOperator-approved context with usage records, diffs, hygiene.
• ApprovalsThe gate: drafts, trades, exports, gated tools.
• SchedulesCron-like cadences materializing fresh missions.
• ReceiptsPer-mission proof with integrity hash and exports.
• SettingsProvider config, demo workspace, diagnostics & runtime.

Hermes Agent is the autonomy. Hermes Loop is the control room.

Hermes Agent — built by Nous Research — is the autonomous engine. It lives on your server, holds persistent memory, schedules its own work via natural language cron, and spawns isolated subagents with their own conversations, terminals, and Python RPC. It can run on local, Docker, SSH, Singularity, or Modal backends. Native capabilities include web search, browser automation, vision, image generation, text-to-speech, and multi-model reasoning.

Hermes Loop is the operator-facing layer that turns those capabilities into a workflow you can ship: named crews, a job queue, approval gates, workflow receipts, a trust ledger, an evals harness, schema self-correction, retries with backoff, real per-run cost accounting, and an audit trail of every prompt, response, tool call, and approval.

Hermes Agent is open source under MIT. Learn more at hermes-agent.nousresearch.com.

The seven words that make up the whole product.

Mission

One run of a crew end-to-end. Has a status (DRAFT → RUNNING → WAITING_APPROVAL → COMPLETED / FAILED) and a complete persistent trace.

Crew

An ordered sequence of specialist agents — each with a system prompt, a Zod output schema, and an allowed tool list.

Job

A background work item picked up by the worker process. Types: TRIAGE_INBOX, RUN_MISSION, RUN_SCHEDULE, RESUME_AFTER_APPROVAL.

Tool

A sandboxed action agents can request. Live: browser_qa_audit (Playwright), terminal_exec, python_rpc, web_search (Tavily), vision_analyze (Gemini), image_generate, text_to_speech (ElevenLabs), web_snapshot, document_extract, price_series_lookup, deadline_create, report_export_draft.

Memory

Operator-approved persistent context. Selected per mission, recorded, diffable. No implicit retention.

Approval

A user decision gate on a risky output (EMAIL_DRAFT, TRADE_SIMULATION, REPORT_EXPORT, FOLLOW_UP, FORM_ACTION, TOOL_CALL).

Receipt

A WorkflowReceipt: status, timeline, integrity hash, real cost, risk level, full content blob. The proof artifact.

A 3-minute path that exercises everything.

1. 1. Load the demo workspace. Settings → Load demo. Three pre-completed missions, an active schedule, memories, receipts — instant context. Open settings →
2. 2. Run Bug Hunter on /demo-target. Real Playwright crawl, real findings, real Hermes calls. Launch the demo run →
3. 3. Approve the QA report. Watch the mission move from WAITING_APPROVAL to settled, deliverable accepted.
4. 4. Open the receipt for that mission. See the timeline, the integrity hash, the real per-model cost. Open receipts →
5. 5. Open /trust. Watch your run roll into the aggregate reliability picture. Open trust →