{% extends "main.html" %} {% block tabs %} {{ super() }} {% endblock %} {% block content %}{% endblock %} {% block hero %}
Local-first · Governed · Inspectable

The agent kernel that
stays legible after the run.

Approve before side effects. Inspect receipts after execution. Roll back when needed.
Same model loop. Different operator contract.

Install in one command
curl -fsSL https://raw.githubusercontent.com/heggria/Hermit/main/install-macos.sh | bash
Get Started GitHub
Generic Agent
  • Chat-first sessions
  • Direct model-to-tool execution
  • Transcript as context
  • Tool logs as "audit"
  • Memory as sticky notes
Hermit
  • Task-first durable work
  • Policy, approval & scoped authority
  • Artifacts, beliefs & working state
  • Receipts, proofs & proof bundles
  • Evidence-bound memory governance

Why Hermit

Task-First Kernel

All meaningful work flows through durable Task objects. CLI, chat, scheduler, webhook, and adapters converge on the same task semantics.

Governed Execution

The model proposes actions. The kernel decides whether they are allowed, whether they need approval, and what authority envelope they get.

Receipts & Proofs

Important actions produce receipts. Proof summaries and proof bundles make the action chain inspectable. Supported receipts can be rolled back.

Rollback Recovery

Rollback-aware recovery for supported receipt classes. Undo actions when needed instead of hoping the model got it right.

Artifact-Native Context

Context is compiled from artifacts, working state, beliefs, memory records, and task state — not just transcript history.

Evidence-Bound Memory

Memory is not an ungoverned scratchpad. Durable memory promotion is tied to evidence, scope, retention, and invalidation rules.

See It In Action

One task, still visible afterward.

Terminal 
# Run a task
$ hermit run "Summarize the current repository"

# Inspect the task record
$ hermit task list
$ hermit task show <task_id>

# View receipts and proof
$ hermit task receipts --task-id <task_id>
$ hermit task proof <task_id>

# Roll back if needed
$ hermit task rollback <receipt_id>
Hermit task show, proof, and rollback terminal screenshot

The Governed Execution Path

Task → Step → Policy → Approval → Authority → Execution → Receipt → Proof / Rollback

Models propose actions, the kernel authorizes, then the executor runs. No direct model-to-tool execution.

Built For Work That Matters

💻

Local Coding Agent

Asks before writing outside the workspace. Every file change produces a receipt.

⏰

Scheduled Assistant

Produces artifacts and keeps an inspectable task ledger across scheduled runs.

💬

Channel Operator

Approvals and task continuity matter when connected to Feishu, Slack, or other channels.

🧠

Memory Runtime

Durable memory cites evidence. Memory promotion is governed, not a free-for-all scratchpad.

Ready to make agent work inspectable?

Hermit is open source (MIT) and shipping today.

Get Started Read the Docs
{% endblock %}