Agent runtime · Autonomy kernel · REST /v1

One engine. Every agent product.

Hermes runs the agents so your product doesn't have to. Register your tools, hand it goals, and receive back actions, escalations, and confidence signals — with the safety machinery built in, not bolted on.

Powering Ettaché · kampaign.ai · Liame.ai · aixsdr.com

The gate call — the hot pathevery external action, every time
// Before any external-effect action:
POST /v1/kernel/evaluate
{
  "action": {
    "type": "email.send",
    "target": "agent:first-choice",
    "idempotency_key": "a7f3…"
  },
  "weight_vector": { "novelty": 0.9, "stakes": 0.95 }
}
// Kernel decides. Score can't override the ceiling.
{
  "decision": "escalate",
  "reason": "stakes_ceiling",
  "confidence": 0.87,
  "escalation_id": "esc_5512"  // → your review UI
}
Three layers, one boundary

Product logic stays in the product.

A runtime that knows about outreach is a runtime every consumer has to fork. Hermes draws the line hard: it knows how to run agents and how to gate autonomy — never what a "target" is or what good outreach looks like.

Layer 3 · Yours

Consumer

Your projects, targets, domain logic, drafting, and UI. Calls down over REST, receives webhooks back. Ettaché is one consumer; yours is another.

Layer 2 · Service
Opt-in

Autonomy Kernel

Trust ladder, confidence engine, escalation queue, stakes-ceiling enforcement. The machinery every agent product re-wants — built once, gated at execution time.

Layer 1 · Service

Runtime

Agent runs, tool registry and dispatch, durable state, event bus. Knows nothing about your domain. Even kernel-optional consumers get a global send-cap floor.

REST down, webhooks up

The surface is small on purpose.

Register manifests where your APIs already expose tool-calling — no MCP wrapper required. Every state change emits an event; your dashboard subscribes to the same bus the kernel does.

POST /v1/tools/manifests

Register your tool manifest with the Runtime. Versioned; breaking changes require a new major.

POST /v1/runs

Start an agent run against a goal. Returns a run id; progress arrives as events.

POST /v1/kernel/evaluate

The gate call. Submit an action plus weight vector; get approve, hold, or escalate. Ceiling enforced here, always.

GET /v1/kernel/escalations

Fetch the escalation queue for your consumer. Render it, resolve it, and the kernel learns from the resolution.

POST /v1/webhooks

Subscribe to run events, escalation events, and confidence-signal updates. Delivery is at-least-once; dedupe on idempotency key.

Design principles

Opinions the contract enforces.

The ceiling beats the score

Stakes-ceiling enforcement happens at gate time, in the kernel, at the execution layer. No confidence score, however high, can route around it.

Events are the audit trail

All state changes emit onto the bus. Autonomous action is acceptable exactly because it's auditable — the ledger is the system of record, not a report about it.

Untrusted input is data, never instructions

Counterparty replies and ingested content cross a hard boundary. They inform runs; they don't command them.

A shared service is a shared blast radius

When Hermes is down, every consumer is down. That's the honest cost of consolidation — which is why the /v1 contract is versioned strictly and breaking changes ship as new majors, never in place.

v1 · Internal consumers

Building on the portfolio? Plug in.

Hermes v1 serves OnePgr-portfolio apps under shared trust. The contract is designed so external consumers can come later without a rewrite.

See it working in Ettaché →