OpenHermit Agent Operations Platform

Deploy AI agents as durable, centrally managed production services with isolated workspaces.

Stars
★ 90
Last updated
3d ago
License
MIT
Primary language
TypeScript

At a glance

How it runs
CLISelf-hosted serviceWeb app
Works with
Universal · cross-platformOpenAI API (Partial support)
Cost
Free software; you pay for model usage
Setup effort
High · needs real infrastructure
You'll need
Node.jsPostgreSQLDocker or a supported cloud sandbox providerAn LLM provider or OpenAI-compatible local serverShell / CLINetwork accessLocal filesystemMCP Server
Typical use
An internal platform team needs separate agents for multiple teams or customers, with centrally managed sessions, secrets, and configuration.
Not a fit if
  • Teams seeking a fully managed agent service
  • Individuals unwilling to operate a database and gateway

What does this agent do, and when should you use it?

OpenHermit is an open-source platform for deploying and operating fleets of AI agents. Its Hono Gateway provides the control plane, API, authentication, routing, lifecycle management, and scheduling, with an admin UI at /admin/. Agent sessions, memories, instructions, skills, MCP configuration, schedules, and secrets live in PostgreSQL, while workspace files live in a per-agent sandbox. Sandbox options include self-hosted Docker and E2B, Daytona, or Tenki. Users can interact through the CLI, Web UI, and channels such as Telegram, Discord, and Slack; deployment requires operating the database and gateway and configuring a model provider.

An administrator runs hermit setup to configure the database connection and Gateway credentials, then uses commands such as hermit agents create and start to create and run agents. Each agent's sessions, event history, memories, instructions, skills, MCP servers, secrets, and schedules are stored as PostgreSQL state scoped by agent_id, while code runs in that agent's sandbox workspace. The Gateway exposes session routes under /api/agents/{agentId}, including synchronous requests, SSE, WebSocket RPC, approvals, and checkpoints; channel adapters route messages to agents. Administrators can use the CLI or admin UI to distribute instructions, enable skills and MCP servers, manage schedules, and inspect status. Agent replies are delivered through the CLI, Web UI, or enabled channels.

  1. An internal platform team needs separate agents for multiple teams or customers, with centrally managed sessions, secrets, and configuration.
  2. An operations team wants agents to run recurring summaries or other scheduled jobs and track their run history.
  3. A product team wants users to reach platform agents through Telegram, Discord, or Slack.
  4. An engineering team needs code execution in isolated per-agent workspaces and wants to choose Docker, E2B, Daytona, or Tenki as the sandbox backend.
  5. A research team needs durable web research runs with a reviewed plan, cited evidence in the final report, and pause-and-resume support.

How do you install or deploy this agent?

Install Node.js/npm and prepare PostgreSQL, Gateway credentials, and a model-provider configuration. Install the npm package globally:

npm install -g openhermit

Or install from source:

git clone https://github.com/HCF-S/openhermit.git
cd openhermit
npm install

If using Docker, E2B, Daytona, or Tenki for agent sandboxes, configure the selected backend's runtime as well. The README does not specify a Node.js version.

How do you use this agent?

Set DATABASE_URL, GATEWAY_ADMIN_TOKEN, and GATEWAY_JWT_SECRET, then start the Gateway and Web app and create an agent:

hermit setup
hermit gateway start
hermit web start
hermit status
hermit doctor
hermit agents create main
hermit agents start main
hermit chat --agent main

The Gateway defaults to http://127.0.0.1:4000, with its admin UI at /admin/; the end-user Web app defaults to http://127.0.0.1:4310. Configure a model provider and set its key with hermit config secrets set; for example:

hermit config set model.provider openai
hermit config set model.model gpt-5-mini
hermit config secrets set OPENAI_API_KEY sk-...

An API client can create a session with POST /api/agents/{id}/sessions, then send a message to /api/agents/{id}/sessions/{sessionId}/messages. Use ?stream=true for streaming or connect to that agent's WebSocket RPC endpoint.

What are this agent's strengths and limitations?

Pros
  • Centralizes sessions, memories, instructions, skills, MCP configuration, schedules, and secrets in PostgreSQL, with per-agent scoping and fleet-wide operations.
  • Runs each agent in an isolated sandbox and supports self-hosted Docker plus E2B, Daytona, and Tenki backends.
  • Includes Telegram, Discord, and Slack adapters alongside CLI, Web UI, HTTP/SSE, and WebSocket interfaces.
  • Schedules support timeouts, concurrency policies, and error backoff; Deep Research runs persist, can pause and resume, and produce reports with cited evidence excerpts.
Limitations
  • Self-hosting requires configuring PostgreSQL, Gateway authentication secrets, and a model provider, then operating the services.
  • Deep Research can use many model calls and input tokens; the README provides worst-case budgets, and free model quotas are usually insufficient.
  • Deep Research currently supports HTML/text web sources only; PDFs, uploaded files, and MCP sources are unsupported, and an unclean restart requires manual resume.
  • The README does not specify a minimum Node.js version; cloud sandbox backends also require their provider configuration.

How does this agent compare with similar options?

The README contrasts OpenHermit with file-based CLI agents such as Claude Code, OpenClaw, and Hermes: OpenHermit centralizes internal state in PostgreSQL and provides fleet operations. It does not compare their detailed feature sets or document migration paths.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
OpenHermit Agent Operations Platform This agent 54 · Major gaps CLIFree + model costs ★ 90 3d ago TypeScript —
Dorothy Agent Workbench 48 · Major gaps Desktop appFree + model costs ★ 357 16d ago TypeScript Claude Code
SuperAgentX Workflow Framework 43 · Major gaps Library / SDKFree + model costs ★ 207 4mo ago Python OpenAI API
OpenClaw Chinese Edition 53 · Major gaps CLIFree + model costs ★ 3.8k today JavaScript OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
54/ 100 5-point scale 2.7 / 5
Trust 14/29
Reliability 8/14
Adaptability 10/18
Convention 10/18
Effectiveness 9/13
Verifiability 3/8
Why each dimension lost points
Trust14 / 29 · 2.4/5

least_privilege: docs clearly separate host/docker/e2b/daytona/tenki sandboxes, flag the host backend as devops-only and requiring private access, and layer roles with policy; however safe defaults still depend on the operator tightening policy, so not full marks. user_confirmation: the policy/approval chapter defines allow/deny/require_approval, most-restrictive-wins, and timeout-as-reject, with solid evidence. data_flow_transparency: README and the Internal State table explain PostgreSQL-backed state, encrypted secrets, attachment backends, and env-only credentials. sensitive_data_handling: AES-256-GCM encryption of agent_secrets and channel credentials with credentials kept out of config, but no key rotation or audit detail, deducted. dependency_security: only top-level package.json is visible; no lockfile audit, vulnerability scanning, or SBOM evidence. external_effects: exec, MCP, and channel egress create external side effects; a policy layer exists but approval is not enforced by default, deducted. rollback: checkpoint routes and sandbox soft-delete exist, but soft-delete does not reclaim e2b/daytona remote resources, so rollback semantics are incomplete. source_attribution: README points to Amiko and the repo, but publisher identity is unverified and the FAQ's 'licence is operator-known' conflicts with the MIT declaration, deducted.

Reliability8 / 14 · 2.9/5

self_consistency: README, SKILL.md, and manual agree on CLI commands, env vars, and state model, but the FAQ's licence statement conflicts with LICENSE and the skill's exec backend list (docker/host/e2b) diverges from the five-backend sandbox doc, deducted. dependency_availability: Node>=20, PostgreSQL, a model API key, and optional E2B/Daytona/Tenki/S3/Supabase SDKs are documented, but no lockfile or pinned-version evidence is shown, deducted. failure_messages: the troubleshooting chapter is symptom-first with concrete checks, CLI/gateway code catches errors and sets exit codes, and a doctor command exists; coverage is good but not exhaustive.

Adaptability10 / 18 · 2.8/5

audience_and_scenarios: separate admin and end-user skills plus a manual spanning quickstart to operations make the audience and scenarios clear. capability_boundaries: skill descriptions scope each skill and cross-reference the other, and the tool table lists default role grants, so boundaries are clear. trigger_precision: skill descriptions are single-sentence triggers, but skill-creator's own examples and rules are generic and activation relies on model judgment, deducted. environment_fit: supports local, Docker, cloud sandboxes, multiple model providers, and local Ollama, giving broad environment fit.

Convention10 / 18 · 2.8/5

information_architecture: README is well structured and docs/ plus the numbered manual provide clear navigation. install_notes: global npm install, setup wizard, docker compose Postgres, and a full env var table are present. naming_stability: README uses HCF-S/openhermit while the skill file cites HCF-STUDIOS/openhermit, an inconsistency, deducted. examples_and_faq: Quick Start, CLI reference, FAQ, troubleshooting, and recipes give ample examples. known_limitations: Deep Research explicitly lists PDF unsupported, web-only sources, and manual resume after unclean restart, and the host backend risk is flagged. license: LICENSE is MIT and package.json declares MIT, consistent. versioning_changelog: monorepo version is 0.0.0 with no CHANGELOG or release policy, deducted. maintenance_responsibility: README points to Amiko and contributing guidance, but the publisher is unverified and ownership of maintenance is not clearly established, deducted.

Effectiveness9 / 13 · 3.5/5

output_usability: CLI, API, web UI, and channel adapters are all present, so outputs are directly usable for deployment and operations. marginal_value: it addresses centralized multi-agent state and sandboxed execution, a clear increment over file-based agents. cost_benefit: the Deep Research section gives per-depth token and cost caps plus a local-model path, making cost predictable, though Postgres and model spend are required, so a small deduction.

Verifiability3 / 8 · 1.9/5

claim_traceability: most README claims trace to docs/ and source files, but some performance and cost figures lack stated measurement methods. cross_source_corroboration: README, SKILL.md, and manual corroborate each other in many places, but the repo name and licence wording are inconsistent, deducted. fact_inference_separation: docs mostly separate design from current state, but phrases like 'verified registry ids' lack a checkable source, deducted.

Risks and how to mitigate them
  • Publisher identity is unverified and the repo name differs between README (HCF-S) and the skill file (HCF-STUDIOS); verify provenance before deployment.
  • The host sandbox backend gives unsandboxed shell access to the gateway host and must be paired with private access and strict policy; never use it for general-purpose agents.
  • Default policy does not automatically require approval for exec or MCP calls; operators must explicitly configure require_approval and deny rules.
  • Soft-deleting a sandbox does not reclaim e2b/daytona remote resources, so clean them up manually to avoid ongoing billing.
  • Deep Research is model-intensive, with single extraction calls up to ~50k input tokens; free tiers are usually insufficient, so budget for paid keys.
  • The FAQ says the licence is 'operator-known', conflicting with the MIT declaration; confirm licensing terms before compliant use.
  • No lockfile audit, dependency vulnerability scanning, or SBOM is shown; perform your own dependency security review before production use.
Evidence confidence: Low Reviewed Nov 07, 2026 Reviewed revision c48bc7e2b4a5
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/openhermit.svg)](https://followagents.com/en/agents/openhermit)
<a href="https://followagents.com/en/agents/openhermit"><img src="https://followagents.com/badge/openhermit.svg" alt="FARS review"></a>

FAQ

What infrastructure does OpenHermit need?
The quickstart calls for DATABASE_URL, GATEWAY_ADMIN_TOKEN, and GATEWAY_JWT_SECRET, plus a running Gateway and a configured model provider. Agent workspaces need Docker or a supported cloud sandbox backend.
How much can Deep Research cost?
It depends on depth and model. README worst-case examples range from about $0.14 for quick with gpt-5-mini to about $4.50 for thorough with claude-sonnet-4-5; search charges are separate.
How are secrets stored?
Agent secrets and channel credentials in the database are encrypted with AES-256-GCM using OPENHERMIT_SECRETS_KEY. Without it, the Gateway falls back to per-agent secrets.json for local development secrets, but DB-backed channel credentials are unavailable.
How can users message an agent?
The README lists the CLI, Web UI, and Telegram, Discord, and Slack adapters. Signal, WeChat, and WhatsApp adapters are installed as packages.
Can Deep Research use PDFs or uploaded files as evidence?
Not currently. Deep Research uses web HTML/text sources; PDFs are reported as unsupported, and uploaded files and MCP sources are not supported.
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.