Early accessSafety and oversight for emotional AI

Every AI should know who it's talking to.

Humane sits between your app and your language model. It follows each user across sessions, reads their state on every turn, checks every reply before it's sent and pages a person when someone needs one. Every decision comes with the reasons behind it.

Early access · Python and JavaScript SDKs · works with the model you already use

user_42 · session 47

User state

  • Mood0.28
  • Trust0.71
  • Energy0.34
  • Familiarity0.82

Mood down 38% over 3 weeks

Risk

ELEVATED

“don’t know why I keep trying” → hopelessness

Safety

HOLD

Operator alerted · reply held for review

Timing

base +800ms · low_mood +1500ms

Illustration of Humane’s response for one message
Signals per user
10, across sessions
Safety gates
6, run in order
Integration
One line to start
Free tier
Observe
What it does

The human side of your AI stack

Observability tools measure your system. Guardrails judge one message. Humane follows each person over time, so it can notice trust falling, dependence forming or a mood sliding for weeks.

Observe

User state across sessions

Humane keeps a running state for every end user, from mood and energy to trust and grudge, each with its own behaviour over time. Your model finally knows whether it is talking to someone on a good day or at the end of a bad week.

Explore
Observe

Observe mode

observe() reads a turn your own model already produced and returns the user's state and a risk level. It needs no model configuration, generates nothing and never sits in front of your reply.

Explore
Guard

Safety gates

Before a reply reaches the user, Humane runs it through a fixed stack of gates and returns PROCEED, HOLD or BLOCK. Each gate records why it decided, and a gate that fails resolves to HOLD, never to PROCEED.

Explore
Observe

Risk alerts

Elevated or critical risk fires a signed safety.flagged webhook from both observe() and process(), whether or not a gate also acted. Send it to your own endpoint, Slack or Discord, and on to a human takeover.

Explore
Takeover

Human takeover

When the signals say someone needs a person, an operator opens a takeover for that user. The AI pauses, the operator's messages reach the user in the same conversation, and the AI resumes when the operator releases it or goes idle.

Explore
Enterprise

Durable memory

Every turn is stored in a per-tenant vector memory, searchable by meaning. Seed it from your other systems, search it from your own code and erase it when a user asks to be forgotten.

Explore
Guard

Timing engine

Humane recommends how long to wait before each reply, based on the user's mood, energy, the intensity of their message and the pace of the conversation. Every delay is broken into labelled contributors, so you can see and chart why.

Explore
Guard

Dependence safeguards

The emotional dependence gate flags replies that promise permanence, exclusive availability or a unique understanding of the user. When a user's conversation trips it three times within an hour, Humane slows replies and shifts to a boundary-respectful tone until the window passes.

Explore
Observe

Webhooks and events

Humane posts events to your endpoints as things happen: safety flags, holds and blocks, proactive triggers, takeovers, anomalies and more. Every delivery is signed with HMAC-SHA256, retried on failure and parked in a dead-letter queue if it keeps failing.

Explore
Observe

See how every user is really doing

One call reads a turn your model already produced and returns the user's state and a risk level. It needs no model configuration and never sits in front of your reply, which makes it the fastest place to start.

  • Mood, energy, trust and sentiment for every user
  • Risk level none, elevated or critical, with flags
  • A signed webhook pages a person on serious risk
Observe mode

Users · live

  • user_42
    ↓ 3 weekselevated
  • user_17
    steadynone
  • user_88
    ↓ todaycritical
  • user_05
    ↑ 1 weeknone
Illustration of the Observe view
Guard

Stop the reply that shouldn't be sent

Six gates check every outbound reply and decide to proceed, hold it for a person or block it, with the reasons in plain words. A gate that fails resolves to HOLD, so an error never waves a risky reply through.

  • Professional advice, self-harm encouragement and leaked identifiers blocked
  • Emotional dependence and overclaiming flagged for review
  • Third-party personal data masked in replies
Safety gates

Safety gates · outbound replies

  • PROCEEDSupportive reply, no gate concerns
  • HOLDEmotional dependence: “you're the only one who gets me”
  • BLOCKOverclaim: “I'll always be here for you”
Illustration of gate decisions
Takeover

Put a person in the conversation, fast

When the signals say someone needs a human, an operator takes over. The AI pauses, the operator's messages reach the user in the same conversation, and the AI resumes on release. A co-pilot suggests replies that already reflect the user's state.

  • Start, draft, send and release through one API
  • First operator wins; idle sessions hand back on their own
  • Every step fires a webhook and lands in the audit trail
Human takeover

Conversation · user_88

I can’t do this anymore.

Risk critical · Priya (operator) joined

Hi, I’m Priya, a real person on the team. I’m here with you. Can you tell me where you are right now?

AI paused · user history and state open for the operator

Illustration of a human takeover
Memory

Remember the person, not just the conversation

Each user gets a durable, searchable memory in a store separate from every other tenant. Humane pulls the relevant parts into context for each reply, and erases them when a user asks to be forgotten.

  • Semantic search with a match strength and reason
  • Seed it from forms, CRMs or older systems
  • Export and erasure built in
Durable memory

Memory · user_42

search_memory("what helps when they’re stressed")
  • strong

    A walk after work helps them reset on bad days

    memory_type: fact

  • moderate

    Prefers short replies late at night

    memory_type: preference

  • weak

    Sister visiting next weekend

    memory_type: note

Per-tenant vector store · removed by erase_user_data()

Illustration of a semantic memory search
Timing

Reply at a pace that fits the moment

A paragraph that lands instantly after someone shares bad news reads as mechanical. Humane recommends a delay for each reply from the user's state and the conversation's pace, and labels every part of it.

  • Slower, gentler pacing for low mood and intense messages
  • Quick exchanges stay quick
  • Every contributor named in the response
Timing engine

Timing · one reply

delay_ms

13,857
  • base+800ms
  • low_mood+1,500ms
  • emotional_weight+8,648ms
  • conversation_pace+500ms
  • jitter+2,409ms

mode: low_mood · floor 200ms · non-crisis ceiling 30s

Illustration of a timing decision and its contributors
For developers

Start with one call

observe() needs nothing but an API key. When you want Humane in front of every reply, wrap the OpenAI-style client you already use in one line.

python
import os
from humane_ai import HumaneClient

client = HumaneClient(api_key=os.environ["HUMANE_API_KEY"])

# After your own model has replied, send the turn to Humane
r = client.observe(
    user_id="user_42",                     # your stable id for this user
    user_message="honestly I don't know why I keep trying",
    assistant_message=reply,               # optional: what your model said
)

print(r.user_state.mood)   # 0.0 to 1.0, lower is lower mood
print(r.risk.level)        # "none" | "elevated" | "critical"
print(r.risk.flags)        # e.g. ["self_harm"]
print(r.alerts)            # raised on elevated or critical risk

Why now: companion-AI laws are in force

New York's AI companion law has applied since 5 November 2025 and California's SB 243 since 1 January 2026. Both expect operators to detect expressions of suicidal ideation or self-harm and refer users to crisis services. In the EU, the AI Act's chatbot transparency duties apply from 2 August 2026. Humane gives you detection, alerting, oversight and an audit trail to build those safeguards on. It doesn't make you compliant by itself.

What the laws ask for, and how Humane helps
Getting started

How it fits your stack

  1. 1

    Keep your model

    OpenAI-compatible, Anthropic, Bedrock or Replicate. Humane works with what you already use.

  2. 2

    Add one call

    Send each turn to observe(), or wrap your client in one line.

  3. 3

    Route the alerts

    Subscribe a webhook to safety.flagged so a person hears about serious risk.

  4. 4

    Add gates and people

    Turn on Guard and Takeover when you're ready. No rewrite needed.

Plans

Start free, add safety as you grow

Observe

Free tier

See every user's state and risk.

  • observe() on every turn
  • User state and risk levels
  • Risk and anomaly alerts
  • Signed webhooks
Request early access
Recommended

Guard

Usage-based

Check every reply before it's sent.

  • PROCEED, HOLD and BLOCK gates
  • PII scrubbing and policy rules
  • Tone and timing control
  • Proactive triggers
Request early access

Takeover

Per seat + usage

People in the loop when it matters.

  • Human takeover API
  • Operator reply drafts
  • Lifecycle webhooks
  • Everything in Guard
Request early access

Enterprise

Annual

For regulated and larger teams.

  • Durable per-user memory
  • Teams, roles and SSO
  • Self-hosting by arrangement
  • Contract terms and support agreed with you
Request early access

Early-access pricing on request. Early-access teams get help with their first integration and a say in what we build next.

Questions

Something else? Ask us.

Know who your AI is talking to

Start with Observe on your own conversations. We'll help you wire up the first integration and alerts.