An ancient guard's helmet carved in black marble with gold trim, lit by a single warm beam against darkness

Open source · Apache 2.0 · Python + TypeScript

Your AI agents,
under guard.

Ephorate is enterprise Claude monitoring, alerting and runtime policy enforcement — every API call metered, every tool call judged, every decision on one tamper-evident record.

View on GitHub ↗ See the product tour

pip install ephorate anthropic

Every API call, metered.

Model, tokens, cache, latency, cost, stop reason — one metric event per Claude call, straight off your existing client.

Every tool call, judged.

A declarative policy engine returns its verdict before the call executes — not after the damage.

Every decision, on the record.

Hash-chained, tamper-evident, answerable with a link.

The control plane

One dashboard. The whole guard.

Requests, cost, latency, error rate and the day's verdicts — live captures from the real control-plane UI, demo data included.

Animated screenshot: the control-plane dashboard with live request, cost, latency and error-rate tiles and a table of recent alert firings

Subsystem I

Watch everything.

AnthropicMonitor wraps your anthropic.Anthropic client and ships a metric event per Claude API call — model, tokens, cache tokens, latency, cost, stop reason, tools used, errors. The control plane stores them, draws the dashboard, and evaluates threshold alert rules routed to Slack, PagerDuty or any webhook.

  • Cost spikes, p99 latency, error rate, deny surges
  • Per-model and per-agent breakdowns
  • One-line drop-in — no proxy to deploy

Subsystem II

Enforce policy at runtime.

A declarative policy engine evaluates every tool call before it executes and returns allow, deny, transform or require_approval — with a tamper-evident, hash-chained audit log of every decision.

  • Starter bundles: NIST AI RMF, ISO/IEC 42001, EU AI Act
  • agent_abuse_patterns hardening bundle — 36 rules
  • Python + TypeScript SDKs with feature parity
A dark hall of towering black marble columns with warm golden light shafts falling between them

Runtime enforcement

Between the model and its tools
stands a guard.

allow

The call proceeds — and the log remembers it.

deny

Blocked before it executes — not after the damage.

transform

Arguments rewritten in flight — card numbers redacted.

require_approval

A $1,240 refund and a terraform apply to prod both wait for someone with authority to click.

Every verdict lands in a
hash-chained audit log.

Product tour

Security, SRE and compliance
on the same page.

Six more interaction loops, captured live from the control-plane UI.

Monitoring, per model

Requests, tokens, cost, latency and errors bucketed over time and broken down by model — claude-opus-4-8 burning hot in one table, claude-haiku-4-5 humming along in the next.

Animated screenshot: scrolling through per-model request, token, cost and latency tables

Alerts that reach the right pager

Threshold rules over any metric — sum, avg, p50/p95/p99, rate — with windows, cooldowns and per-model or per-agent grouping. Routed to Slack, PagerDuty, email or a webhook.

Animated screenshot: alert rules for cost spikes, p99 latency and error rate, plus acknowledging a firing alert in the history table

A tamper-evident audit trail

Every decision lands in a hash-chained log — who, what tool, which policy, and why. Filters compose and the URL is the permalink, so an auditor's question is answered with a link.

Animated screenshot: filtering the audit log to deny and require_approval decisions

Humans in the loop, one click

When a policy says require_approval, the tool call parks until someone with authority clicks. A $1,240 refund and a terraform apply to prod both wait their turn.

Animated screenshot: approving a pending stripe refund and denying a production deploy

Policies as versioned bundles

Declarative YAML with a predicate AST underneath — matched, evaluated and versioned. Roll a bundle forward, diff what changed, and know which version judged any historical call.

Animated screenshot: browsing policy bundles and opening the payments guardrails YAML

Compliance reports, generated

Framework-mapped reports (with PDF export) straight off the same audit data: decision counts, deny rate, approval rate, controls covered — for the period the auditor actually asked about.

Animated screenshot: live NIST AI RMF, EU AI Act and OWASP LLM control posture, plus compliance evidence reports, one still generating

Policy DSL

Guardrails you can diff.

# policy.yaml
policies:
  - id: refund-cap
    match: { tool: stripe_refund }
    when:
      all:
        - { field: arguments.amount_usd, op: gt, value: 500 }
    decision: require_approval

  - id: pan-redaction
    match: { tool: "*" }
    when:
      any:
        - { field: arguments, op: matches, value: "\b\d{13,19}\b" }
    decision: transform
    transform: { redact: [card_number] }

Quickstart

Two lines into your loop.

# pip install ephorate anthropic
from ephorate import EphorateClient
from ephorate.middleware.anthropic import gate_response

client = EphorateClient(
    bundle_path="policy.yaml",
    audit_log_path="audit.jsonl",
    control_plane_url="https://ephorate.example.com",
)

# in your agent loop:
gated = gate_response(response, client=client,
                      session_id=session_id)

Same runtime path in TypeScript via @ephorate/sdk.

Starter compliance bundles

Day-one coverage for the frameworks
your auditors already name-drop.

Under the hood

Post a guard.

Apache 2.0 — read the code, run the control plane, gate your first agent this afternoon.

Read the code on GitHub ↗