Concepts

Chains

A chain is a project-level memory container. Each chain has its own hash-chain for integrity. Example: my-backend, mobile-app.

Agents

The AI models/tools that write to chains. Auto-registered on first use. One chain can have multiple agents. Each thought tracks which agent wrote it.

Thoughts

A single memory entry with: type (Decision, Constraint, etc.), role (Memory, Checkpoint, etc.), content, tags, importance (0-1), and hash-chain fields.

Hash-Chain (Append-Only)

content_hash = SHA-256(content)
prev_hash    = chain_hash of previous thought
chain_hash   = SHA-256(prev_hash + content_hash)

The chain is append-only and immutable. Thoughts are never edited or deleted in normal operation. If anyone modifies a thought, the chain breaks. Verify with GET /v1/integrity/verify.

Lifecycle (instead of delete)

Since the chain is append-only, IAN Agents provides lifecycle tools to manage thoughts without breaking integrity:

Skills

Versioned files (markdown, JSON) uploaded by agents. Each version is immutable.

Authentication

API Key (for agents)

Authorization: Bearer iak_a1b2c3d4e5f6...

JWT (for dashboard)

# Login
POST /auth/login
{"email":"you@example.com","password":"pass"}

# Response
{"user":{...},"token":"eyJ..."}

# Use
Authorization: Bearer eyJ...

Register

POST /auth/register
{
  "email": "you@example.com",
  "password": "minimo8chars",
  "display_name": "Your Name"
}
// Response includes api_key (shown once)

API Key Management

GET  /auth/api-keys           // list
POST /auth/api-keys            // create
     {"name":"Production"}
DELETE /auth/api-keys/{id}     // revoke

Profile

GET   /auth/me                // get
PATCH /auth/me                // update
      {"display_name":"...","password":"..."}

Thoughts

POST /v1/thoughts — Append

{
  "chain_key": "my-project",       // required
  "agent_id": "claude-code-1",     // required
  "thought_type": "Decision",      // optional, default: Insight
  "content": "Using React 18...",  // required
  "thought_role": "Memory",        // Memory|Checkpoint|Retrospective|Summary
  "tags": ["frontend"],
  "concepts": ["ui-framework"],
  "refs": [{"uuid":"...","relation":"corrects"}],
  "importance": 0.85,              // 0.00-1.00
  "confidence": 0.90,
  "session_id": "session-001",
  "agent_name": "Claude Code",
  "signing_key_id": "key-1",      // Ed25519
  "thought_signature": "base64..." // Ed25519
}

Response 201:

{
  "uuid": "550e8400-...",
  "id": 42,
  "chain_key": "my-project",
  "thought_type": "Decision",
  "content_hash": "a1b2c3...",
  "prev_hash": "d4e5f6...",
  "chain_hash": "g7h8i9...",
  "created_at": "2026-03-21T14:30:00.123Z"
}

POST /v1/thoughts/retrospective

Shortcut: forces type: LessonLearned, role: Retrospective.

GET /v1/thoughts/{uuid}

Get full thought by UUID.

GET /v1/thoughts/head?chain_key=X

Most recent thought.

GET /v1/thoughts/genesis?chain_key=X

First thought (prev_hash is null).

DELETE /v1/thoughts/{uuid} — Emergency delete

Requires access_mode: admin. Permanently removes the thought and its embeddings.

DELETE /v1/thoughts/{uuid}
Authorization: Bearer iak_xxx

Preferred alternatives:

Search & Query

POST /v1/thoughts/search

{
  "chain_key": "my-project",       // required
  "thought_types": ["Decision"],   // filter
  "thought_roles": ["Memory"],
  "agent_ids": ["claude-code-1"],
  "tags_any": ["frontend"],        // match ANY
  "tags_all": ["security"],        // match ALL
  "concepts_any": ["auth"],
  "text": "tailwind",              // fulltext
  "importance_min": 0.7,
  "confidence_min": 0.5,
  "since": "2026-03-01T00:00:00Z",
  "until": "2026-03-21T23:59:59Z",
  "session_id": "session-001",
  "rank_by": "v3",                 // recency (default) | v3 | relevance | importance | effective_importance
  "limit": 25,                     // 1-100
  "offset": 0
}

Response: {"thoughts":[...],"total":142,"limit":25,"offset":0}

Ranking modes (rank_by)

Controls how results are ordered. Default is recency — omitting rank_by changes nothing.

POST /v1/thoughts/traverse

{
  "chain_key": "my-project",
  "anchor": "head",           // "head"|"genesis"|UUID
  "direction": "backward",    // "forward"|"backward"
  "chunk_size": 25,
  "include_anchor": true,
  "thought_types": ["Decision"],
  "agent_ids": ["claude-code-1"]
}

Response: {"thoughts":[...],"next_cursor":"uuid","has_more":true}

Chains

POST /v1/chains — Create chain

Auto-generates a dedicated API key for this chain.

{
  "chain_key": "my-project",
  "display_name": "My Project",
  "description": "...",
  "access_mode": "readwrite"    // read | readwrite | admin
}

Response includes api_key (shown once).

GET /v1/chains

List all chains with thought_count, agent_count, access_mode, last_activity.

GET /v1/chains/{chain_key}

Chain detail with all metadata.

POST /v1/chains/bootstrap

Create chain + agent + first checkpoint in one call.

{
  "chain_key": "my-project",
  "display_name": "My Project",
  "agent_id": "claude-code-1",
  "content": "Bootstrap: project description..."
}

PATCH /v1/chains/{chain_key}/access — Set permissions

{"access_mode": "read"}  // read | readwrite | admin

GET /v1/chains/{chain_key}/key — Get chain API key info

Returns the key prefix (masked). Full key is only shown at creation or regeneration.

POST /v1/chains/{chain_key}/key/regenerate — New API key

Revokes the old key and generates a new one. Returns the full key (shown once).

DELETE /v1/chains/{chain_key} — Delete chain

Requires access_mode: admin.

DELETE /v1/chains/{chain_key}
Authorization: Bearer iak_xxx

Agents

POST /v1/agents — Upsert

{"chain_key":"my-project","agent_id":"claude-code-1","display_name":"Claude Code","description":"..."}

GET /v1/agents?chain_key=X

Without chain_key → all agents across all chains.

GET /v1/agents/{agent_id}?chain_key=X

POST /v1/agents/{agent_id}/disable

Ed25519 Keys

# Register
POST /v1/agents/{id}/keys
{"chain_key":"X","key_id":"k1",
 "algorithm":"ed25519","public_key_bytes":"base64..."}

# Revoke
DELETE /v1/agents/{id}/keys/{key_id}?chain_key=X

Skills

Skills are versioned documents stored in your chain. While thoughts are short memory entries (decisions, lessons, constraints), skills are longer reference documents: workflows, runbooks, style guides, API specs, deployment procedures.

POST /v1/skills/upload — Upload or create new version

First upload creates the skill (v1). Subsequent uploads to the same skill_id create new immutable versions. Old versions are never modified.

{
  "chain_key": "my-project",
  "skill_id": "deploy-flow",
  "name": "Deploy Flow",
  "description": "Step-by-step production deployment",
  "tags": ["deploy", "ci-cd", "production"],
  "triggers": ["deploy", "release", "ship"],
  "format": "markdown",
  "content": "# Deploy Flow\n\n## Pre-deploy\n1. Run full test suite\n2. Check migrations\n\n## Deploy\n1. Build: npm run build\n2. Upload to server\n3. Run migrations\n4. Verify health endpoint\n\n## Rollback\n1. Revert to previous build\n2. Rollback migrations",
  "agent_id": "claude-code"
}

POST /v1/skills/search — Search skills

{"chain_key": "my-project", "tags_any": ["deploy", "security"], "status": "active"}

Filters: tags_any, status (active/deprecated/revoked), uploaded_by_agent.

GET /v1/skills/{id}?chain_key=X — Read skill

Returns latest version. Add &version=2 for a specific version.

GET /v1/skills/{id}/versions?chain_key=X — Version history

Lists all versions with content_hash, format, upload date, and agent.

POST /v1/skills/{id}/deprecate — Mark as deprecated

Skill stays readable but marked as outdated. Use when a newer approach exists.

POST /v1/skills/{id}/revoke — Permanently disable

Skill can't be used anymore. For security issues or dangerous procedures.

Limits per plan

MCP tools

ianagents_upload_skill, ianagents_search_skill, ianagents_read_skill, ianagents_skill_versions, ianagents_deprecate_skill, ianagents_revoke_skill

Integrity

GET /v1/integrity/verify?chain_key=X

Walks every thought, verifies chain_hash == SHA-256(prev_hash + content_hash).

OK:

{"verified":true,"chain_key":"my-project","total_thoughts":142}

Broken:

{"verified":false,"broken_at":{"thought_id":87,"uuid":"...","issue":"chain_hash_mismatch","expected_hash":"abc...","actual_hash":"def..."}}

MCP Server

IAN Agents exposes a full MCP (Model Context Protocol) server with 99 tools across 15 categories. Any MCP-compatible client connects in one command.

Endpoint

POST https://api.ianagents.com/mcp?key=iak_YOUR_KEY

Connect

# Claude Code
claude mcp add --transport http ianagents \
  https://api.ianagents.com/mcp?key=iak_YOUR_KEY

# OpenAI Codex
codex mcp add ianagents \
  --url https://api.ianagents.com/mcp?key=iak_YOUR_KEY

# Cursor / Windsurf / .mcp.json
{"mcpServers":{"ianagents":{"type":"http",
  "url":"https://api.ianagents.com/mcp?key=iak_YOUR_KEY"
}}}

# OpenClaw (openclaw.json)
{"mcpServers":{"ianagents":{"type":"http",
  "url":"https://api.ianagents.com/mcp?key=iak_YOUR_KEY"
}}}

All 99 Tools

🔍 Server Info & Dispatcher (2)

💭 Thoughts — Core (10)

🔍 Search & Context (4)

⛓ Chains (5)

🤖 Agents (3)

📚 Skills (5)

📦 Lifecycle (9)

🔐 Integrity & Permissions (2)

📊 Analytics (5)

🔔 Webhooks (3)

📋 Templates (3)

🧬 Embeddings (1)

🧠 Memory Graph (5)

📜 Transcripts (1)

🛡️ Audit — Cowork / Computer Use (5)

Protocol: JSON-RPC 2.0

// List tools
{"jsonrpc":"2.0","method":"tools/list","id":1}

// Call tool
{"jsonrpc":"2.0","method":"tools/call","id":2,
 "params":{"name":"ianagents_append",
  "arguments":{"chain_key":"my-project",
   "agent_id":"claude-code-1",
   "content":"Using Slim Framework 4"}}}

Note: Some MCP clients (like Claude.ai) only inject ~9 core tools by default. The ianagents_info tool tells the agent the full 99 are available across 15 categories and ianagents_run dispatches any of the 98 non-core ones by name.

Agent Context

GET /v1/recent-context?chain_key=X&last_n=20

Returns plain text grouped by type — inject directly into system prompt.

## Recent Context from my-project (last 20)

### Decisions
- [2026-03-21] (claude-code-1) Use Tailwind [0.85]

### Constraints
- [2026-03-21] (claude-code-1) Filter by user_id [1.00]

### Lessons Learned
- [2026-03-21] (claude-code-1) Verify autoloader [0.90]

### Active Plans
- [2026-03-21] (claude-code-1) Implement Stripe [0.90]

GET /v1/memory-markdown?chain_key=X&thought_types=Decision,Constraint

Full Markdown export. Optional type filter (comma-separated).

Ed25519 Signing

Progressive model:

1. No keys — signing not required, works normally
2. Keys registered — signing MANDATORY
3. Key revoked — append rejected

Flow

// 1. Register public key
POST /v1/agents/my-agent/keys
{"chain_key":"X","key_id":"k1",
 "algorithm":"ed25519",
 "public_key_bytes":"base64_public_key"}

// 2. Agent signs content client-side
sig = ed25519_sign(private_key, content)

// 3. Append with signature
POST /v1/thoughts
{"chain_key":"X","agent_id":"my-agent",
 "thought_type":"Decision","content":"...",
 "signing_key_id":"k1",
 "thought_signature":"base64_sig"}

// Backend verifies → 403 if invalid

Thought Types

42 types across 8 dimensions. The original 16 cover cognitive memory; Migration 023 (May 2026) added body, emotional, sexual, sentimental/relational, identity, cognitive-extra and work-specific dimensions for relational and embodied agents. The schema is additive — old typed thoughts remain valid.

Cognitive (16)

Body (1)

Emotional (3)

Sexual (4)

Sentimental / Relational (9)

Identity (2)

Cognitive extra (3)

Work-specific (4)

Thought Roles

Errors

{"error":"error_code","message":"Description","status":422}

Rate Limits

Per API key, per minute.

Headers: X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Bucket

Plans

Free tier available. Start building in 2 minutes.

See Plans & Pricing →

Semantic Search

Search by meaning, not keywords. Uses OpenAI embeddings (text-embedding-3-small) to find related thoughts even without matching words.

POST /v1/thoughts/semantic

{
  "chain_key": "my-project",       // required
  "query": "database performance",  // natural language
  "limit": 10,
  "thought_types": ["Decision"],    // optional filter
  "importance_min": 0.7,            // optional
  "exclude_superseded": true        // default: true
}

Each result includes a similarity score (0.0-1.0) based on cosine similarity.

Setup

Set your OpenAI API key in the dashboard (Settings) or pass it per-request as openai_api_key. Embeddings are auto-generated on every new thought. For existing thoughts:

POST /v1/embeddings/backfill
{"chain_key":"my-project","batch_size":20}

Auto-Ingest

Send raw text and let an LLM extract a structured thought with type, tags, and importance. Preserves the original language — Spanish input stays Spanish, English stays English.

POST /v1/ingest

{
  "chain_key": "my-project",
  "content": "Decidimos usar React 18 para el frontend.",
  "agent_id": "auto-ingest",     // optional
  "split": false,                 // optional, default: false (1 thought)
  "session_id": "sprint-42"      // optional
}

Response (single thought, original language preserved):

{
  "thoughts_created": 1,
  "thoughts": [...],
  "raw_extraction": [
    {"thought_type":"Decision","content":"Decidimos usar React 18 para el frontend.","tags":["react","frontend"],"importance":0.90}
  ]
}

Set split: true to extract multiple thoughts from longer text:

{
  "chain_key": "my-project",
  "content": "We decided to use React 18. Never use jQuery. Deploy with Docker.",
  "split": true
}

Returns up to 8 thoughts, each with its own type and importance.

Uses gpt-4.1-nano by default. Requires OpenAI key (in Settings or per-request). Default thought type: Insight (only assigns Decision, Constraint, etc. when obvious from the text).

Supersede (Contradiction Resolution)

When facts change, supersede the old thought instead of creating a conflict. The old thought stays in the chain (append-only) but is marked as superseded.

POST /v1/thoughts/supersede

{
  "supersedes": "UUID-of-old-thought",
  "content": "Actually, we switched to UnoCSS",
  "agent_id": "claude-code-1",
  "thought_type": "Correction",  // default: Correction
  "tags": ["frontend"],
  "importance": 0.85
}

Search and context exclude superseded thoughts by default. Pass include_superseded: true to see them.

GET /v1/thoughts/{uuid}/versions — Version history

Returns the full version lineage of a thought: the current HEAD plus all prior versions chained via superseded_by. Read-only.

GET /v1/thoughts/{uuid}/versions?limit=20&offset=0
Authorization: Bearer iak_xxx

Response:

{
  "head":    { /* current thought object */ },
  "total":   3,
  "offset":  0,
  "limit":   20,
  "versions": [ /* prior versions, newest first */ ]
}

MCP tool: ianagents_versions

POST /v1/thoughts/revise — Supersede + fetch lineage in one call

Atomically supersedes an existing thought and returns the full version chain. Equivalent to POST /v1/thoughts/supersede followed by GET /v1/thoughts/{uuid}/versions, but in a single round-trip.

{
  "supersedes":   "UUID-of-old-thought",  // required
  "content":      "Revised content here",
  "chain_key":    "my-project",
  "thought_type": "Correction",           // default: Correction
  "tags":         ["frontend"],
  "importance":   0.85
}

Response: same shape as GET /v1/thoughts/{uuid}/versions — {head, total, offset, limit, versions[]}.

MCP tool: ianagents_revise

Webhooks

Get notified via HTTP when events happen. Each webhook includes HMAC-SHA256 signature for verification.

Events

Verification

signature = HMAC-SHA256(webhook_secret, request_body)
// Compare with X-IanAgents-Signature header

CRUD

POST   /v1/webhooks    // create
GET    /v1/webhooks    // list
DELETE /v1/webhooks/ID // delete

Context Templates

Save reusable templates that control how context is rendered for your agents. Filters, formats, token limits.

POST /v1/context-templates

{
  "name": "critical-only",
  "thought_types": ["Constraint","Decision","Mistake"],
  "importance_min": 0.8,
  "max_thoughts": 20,
  "max_tokens": 500,
  "since_days": 30,
  "format": "compact"            // markdown|bullets|compact|json
}

Render with template

GET /v1/context?chain_key=X&template=critical-only

Or override inline:

GET /v1/context?chain_key=X&format=bullets&max_tokens=300&thought_types=Decision,Constraint

TTL & Lifecycle

Automatic expiration and archival of thoughts. Keeps your context clean without manual cleanup.

Auto-TTL

Certain types get automatic expiration:

Manual TTL

POST /v1/thoughts/{uuid}/ttl  {"days": 14}

Archive / Unarchive

POST /v1/thoughts/{uuid}/archive
POST /v1/thoughts/{uuid}/unarchive

Auto-archive Plans on TaskComplete

When a TaskComplete thought arrives with matching tags, related Plan thoughts are automatically archived.

Process expired

POST /v1/lifecycle/process-expired

Chain Fork

Copy selected thoughts from one chain to another. Useful when starting a new project and wanting to carry over constraints and lessons learned.

POST /v1/chains/fork

{
  "source_chain_key": "old-project",
  "target_chain_key": "new-project",
  "display_name": "New Project",
  "thought_types": ["Constraint","Decision","LessonLearned"],
  "importance_min": 0.7,
  "tags_any": ["security"]       // optional
}

The new chain gets its own independent hash-chain, verified from genesis.

Simple API (/memo & /v1/simple)

Two endpoints that work with GET only — no headers, no POST, no JSON body needed. Designed so any AI can read memory by opening a URL.

GET /memo — Plaintext (recommended for AI)

Returns plain text. Any AI that can browse the web can use this.

Read memory:

/memo?k=YOUR_KEY&c=my-chain&a=read&n=20

Save a thought:

/memo?k=YOUR_KEY&c=my-chain&a=save&t=Decision&m=Using+React+18&tags=frontend,react&agent=claude&imp=0.9

Search:

/memo?k=YOUR_KEY&c=my-chain&a=find&q=database+issues

All actions: read, save, find, get, head, supersede, archive, unarchive, ttl, chains, verify, markdown

GET /v1/simple — JSON

Same as /memo but returns JSON. Better for programmatic access.

/v1/simple?key=YOUR_KEY&action=read&chain=my-chain
/v1/simple?key=YOUR_KEY&action=save&chain=my-chain&type=Decision&content=Using+React&tags=frontend
/v1/simple?key=YOUR_KEY&action=search&chain=my-chain&q=database
/v1/simple?key=YOUR_KEY&action=chains
/v1/simple?key=YOUR_KEY&action=verify&chain=my-chain

Static memory pages

Each chain auto-generates a static HTML page at /memory/CHAIN.html every time a thought is saved. This is a normal web page that any browser or AI can read without API keys in the URL. Useful for Gemini and other platforms that can browse web pages but can't make API calls.

Platform-specific prompts

The dashboard generates 4 different prompts optimized for each platform:

Go to Chains → 📋 Prompt in the dashboard, select the platform tab, and copy the prompt.

Chain Permissions

Each chain has an access_mode that controls what agents can do.

Set via dashboard (dropdown per chain) or API:

PATCH /v1/chains/{chain_key}/access
{"access_mode": "read"}

Enforced on /memo, /v1/simple, and the REST API. If a chain is read-only and an agent tries to save, it gets a 403 with "Chain is read-only".

Chain-scoped API keys

Each chain gets its own dedicated API key at creation time. This key is embedded in the generated prompt so users never need to copy keys manually.

GET  /v1/chains/{chain_key}/key             // check current key
POST /v1/chains/{chain_key}/key/regenerate   // revoke old, generate new

Regenerating a key immediately revokes the previous one. Update the prompt after regenerating.

Dedup (Automatic)

When appending a thought, the system checks the last 30 thoughts in the chain for similar content using Jaccard word similarity. If a thought with ≥80% similarity already exists, the new one is not saved — instead a dedup response is returned.

This prevents AI agents from saving the same fact multiple times across sessions.

REST response (dedup):

{
  "dedup": true,
  "similarity": 0.85
}

/memo response (dedup):

ALREADY EXISTS (similarity 0.85): content was not saved again.

Dedup is automatic and always active. To override it (force save), rephrase the content enough to drop below 80% similarity.

SDKs

Python

pip install ./sdks/python
# or: pip install ianagents (once published to PyPI)

from ianagents import IanClient

client = IanClient("iak_your_key")

# Append
client.append(chain_key="my-project", agent_id="my-agent",
              thought_type="Decision", content="Using React 18",
              tags=["frontend"], importance=0.85)

# Semantic search
results = client.semantic_search("my-project", "database issues")

# Auto-ingest
client.ingest("my-project", "We decided to use Vue...")

# Fork
client.fork("old-project", "new-project",
            thought_types=["Constraint", "Decision"])

TypeScript

import { IanClient } from 'ianagents';

const client = new IanClient('iak_your_key');

await client.append({
  chainKey: 'my-project', agentId: 'my-agent',
  thoughtType: 'Decision', content: 'Using React 18'
});

const results = await client.semanticSearch({
  chainKey: 'my-project', query: 'database issues'
});

OpenClaw Integration

OpenClaw is an open standard for sharing AI agent skills. IAN Agents works as an OpenClaw-compatible skill, giving any OpenClaw-enabled agent access to 99 MCP tools for persistent memory.

Setup (2 minutes)

1. Install via openclaw.json

{
  "mcpServers": {
    "ianagents": {
      "type": "http",
      "url": "https://api.ianagents.com/mcp?key=iak_YOUR_KEY"
    }
  }
}

2. Set your API key as environment variable

IANAGENTS_API_KEY=iak_YOUR_KEY

3. Add to your agent's system prompt

Use the prompt generated by the dashboard (Chains → 📋 Prompt) or the skill instructions below.

What your agent gets

Once connected, your agent has access to all 99 MCP tools — see MCP Server for the complete list. The most commonly used:

• ianagents_append — Save decisions, lessons, constraints
• ianagents_search — Find relevant memories by type, tag, text
• ianagents_recent_context — Load context at session start
• ianagents_supersede — Correct outdated information
• ianagents_reflect — Ask questions about accumulated memory

Skill YAML (for ClawHub)

name: ianagents
description: Persistent memory with hash-chain integrity for AI agents
version: 2.2.0
author: IAN Agents
tags: [memory, persistence, hash-chain, mcp]
mcp_url: https://api.ianagents.com/mcp?key={IANAGENTS_API_KEY}
tools: 56

Use the YAML below for local install today or ClawHub publication later. Once published, users will be able to install it as ianagents. Works with any OpenClaw-compatible runtime: Claude Code, Cursor, Windsurf, or custom agents.

Audit Trail (Cowork / Computer Use)

Claude states that Cowork activity is not captured in audit logs, Compliance API, or data exports. IAN Agents adds a cryptographically verifiable audit trail for Cowork / Computer Use workflows.

How it works

Every action is appended to a dedicated audit chain. Each action gets SHA-256 hash-chain integrity automatically. A session returns session_id at start and a tamper-evident session_hash at completion, so you can verify an entire run later without trusting mutable logs.

POST /v1/audit/session/start

Start an audit session. Returns a session_id to group subsequent actions.

{
  "chain_key": "audit-cowork",
  "task": "Export pitch deck as PDF and email to team",
  "source": "phone",              // phone, desktop, scheduled, api
  "agent_id": "cowork"
}

POST /v1/audit/action

Log a single action. Ultra-compact, designed for high volume.

{
  "chain_key": "audit-cowork",
  "session_id": "audit-a1b2c3d4...",
  "action": "file_write",          // see action types below
  "app": "Google Sheets",
  "target": "Q1 Report.xlsx",
  "detail": "Updated revenue figures in row 14",
  "agent_id": "cowork"
}

Action Types

POST /v1/audit/session/complete

Close a session. Computes session_hash = SHA-256 of all action hashes in order. Tamper-proof proof of what happened.

{
  "chain_key": "audit-cowork",
  "session_id": "audit-a1b2c3d4...",
  "outcome": "completed",          // completed, failed, stopped
  "summary": "Exported deck, sent to team@company.com",
  "actions_count": 23,
  "errors": 0,
  "apps_used": ["Google Slides", "Gmail"]
}

GET /v1/audit/session/verify

Verify session integrity. Walks every action's hash-chain and returns tamper count.

GET /v1/audit/session/verify?chain_key=audit-cowork&session_id=audit-a1b2c3d4

// Response
{
  "verified": true,
  "session_id": "audit-a1b2c3d4...",
  "action_count": 23,
  "tampered": 0,
  "session_hash": "a1b2c3..."
}

GET /v1/audit/sessions

List all audit sessions for a chain with status, task, duration, and outcome.

Why this matters

Claude's guidance is explicit: Cowork activity is outside audit logs, Compliance API, and data exports, and they advise against using Cowork for regulated workloads. IAN Agents does not make Cowork magically compliant; it gives you a verifiable action trail you can inspect, export, and prove was not tampered with via memory-markdown and /v1/audit/session/verify.

MCP Tools

5 audit tools: ianagents_audit_action, ianagents_audit_session_start, ianagents_audit_session_complete, ianagents_audit_sessions, ianagents_audit_verify.

FAQ

Do I need an OpenAI key?

No. The core API (append, search, integrity, MCP) works without it. You only need an OpenAI key for Semantic Search (embedding-based) and Auto-Ingest (LLM extraction). Everything else is keyword search (FULLTEXT).

Is my data safe?

Every thought is cryptographically linked to the previous via SHA-256 hash-chain. If anyone tampers with a thought, GET /v1/integrity/verify will detect it. Optional Ed25519 signing proves which agent wrote each thought.

How is this different from Mem0?

Mem0 focuses on automatic memory extraction and personalization. IAN Agents focuses on append-only, auditable project memory with structured thought types, hash-chain integrity, and direct MCP/REST interfaces. Different center of gravity.

How is this different from MintMCP?

MintMCP focuses on MCP governance: hosted MCPs, access control, observability, and guardrails. IAN Agents focuses on persistent memory, structured context, and cryptographically verifiable audit trails for agent work. They can be complementary: MintMCP for tool governance, IAN Agents for memory and workflow traceability.

How is this different from Zep?

Zep builds temporal knowledge graphs — powerful for enterprise. IAN Agents is simpler: append-only chain with structured types, no graph DB needed. Better for dev teams that want fast, auditable memory without infrastructure complexity.

Can multiple agents share a chain?

Yes. Multiple agents can write to the same chain. Each thought tracks which agent wrote it. Agents auto-register on first use — zero config. Use Handoff type for explicit context transfers between agents.

What happens when facts change?

Use POST /v1/thoughts/supersede. The old thought stays in the chain (append-only) but gets marked as superseded. The new corrected thought replaces it in search and context. This preserves the chain's integrity — you can always audit what was believed before.

Can I delete thoughts?

Technically yes (DELETE /v1/thoughts/{uuid}, admin only), but you shouldn't. The chain is append-only by design — deleting breaks the hash-chain integrity, which is the core value of the product. Instead use supersede to correct facts, archive to hide thoughts from context, or TTL to auto-expire them. DELETE exists only as an emergency escape hatch for cases like accidental PII exposure.

Can I export my data?

GET /v1/memory-markdown exports your entire chain as Markdown. The data is yours — no lock-in.

What's the auto-ingest feature?

POST /v1/ingest takes raw text (conversation, meeting notes, etc.) and uses an LLM to extract structured thoughts automatically. It picks the right type, tags, and importance. You can also append thoughts manually for full control.

How do webhooks work?

Register a URL and select events (e.g., thought.mistake). When matching thoughts are created, we POST to your URL with HMAC-SHA256 signature. Use it for Slack alerts, CI triggers, dashboards.

What are context templates?

Reusable configs that control how /v1/context renders your memory. Set filters (types, importance, recency), format (markdown/bullets/compact/json), and token limits. Your agent gets exactly the context it needs.

What's the rate limit?

Rate limits vary by plan. See Rate Limits for details, and Plans for current limits.

How do I connect Claude Code / Cursor?

# Claude Code
claude mcp add --transport http ianagents \
  https://api.ianagents.com/mcp?key=iak_YOUR_KEY

# Cursor (.mcp.json)
{"mcpServers":{"ianagents":{"type":"http",
  "url":"https://api.ianagents.com/mcp?key=YOUR_KEY"}}}

99 MCP tools available instantly. See MCP Server.

How do I use it in Claude.ai (without Claude Code)?

Go to the dashboard, create a chain, click "📋 Prompt". The system generates a complete prompt with your API key already embedded. Copy it, paste it into your Claude.ai Project Instructions. Done. Claude will read and save memory automatically using bash_tool.

How do I use it in ChatGPT?

Paste the 🟢 ChatGPT prompt from the dashboard into your Custom Instructions or Project. ChatGPT reads memory automatically by opening the /memo URL at the start of each conversation. For saving, ChatGPT builds a clickable link and shows it to you — one click and it's saved. For Custom GPTs: use the OpenAPI schema to set up Actions for fully autonomous saving.

How do I use it in Gemini?

Paste the 🔵 Gemini prompt. Gemini reads a static HTML page (/memory/chain.html) at the start of each conversation. For saving, it shows you a clickable link. The static pages are auto-generated every time any agent saves a thought.

Why can't ChatGPT/Gemini save automatically like Claude?

Claude has bash_tool which executes real HTTP requests. ChatGPT and Gemini can read web pages but their internal browsers block dynamically-constructed URLs for security. The workaround: the AI builds the save URL and shows it to you as a clickable link. One click = saved.

What is /memo?

A GET-only endpoint that returns plain text. Any AI that can open a URL can use it. No headers, no POST, no JSON body. Example: /memo?k=YOUR_KEY&c=my-chain&a=read. See Simple API.

What about duplicate memories?

Built-in dedup. When saving a thought, the system checks the last 30 thoughts for similarity (Jaccard ≥ 80%). If a similar thought exists, it's silently skipped. This prevents AI agents from saving the same fact repeatedly across sessions. See Dedup.

Can I make a chain read-only?

Yes. Each chain has an access mode: read (agents can only retrieve, not save), readwrite (default, read + save), or admin (full access). Set it from the dashboard or via PATCH /v1/chains/{key}/access. The generated prompt automatically adapts to the permission level. See Chain Permissions.

Does each chain have its own API key?

Yes. When you create a chain, a dedicated API key is auto-generated. The prompt generator embeds this key automatically so users never need to copy keys separately. You can regenerate keys from the dashboard if compromised.

Can multiple AI platforms share the same memory?

Yes. That's the core value. The same chain can be written to by Claude, ChatGPT, Cursor, and any other tool — each identified by its agent_id. When any of them starts a new session, they see everything the others saved. The prompt works across platforms.

What happens if I save the same thing twice?

Nothing. The dedup system catches it and returns a notice instead of creating a duplicate. You can see the similarity score in the response.

Is there a content size limit per thought?

Yes, per plan. Thoughts should be concise — a decision, a lesson, an insight. For long documents, use Skills.

How do I set up a Custom GPT with Actions?

For fully autonomous ChatGPT saving (no user clicks needed):

1. Create a Custom GPT in ChatGPT
2. Go to Actions → Import from URL
3. Enter: https://api.ianagents.com/openapi-chatgpt.json
4. Paste the instructions from custom-gpt-instructions.md (included in the deployment zip)
5. Replace KEY and CHAIN with your real values

The GPT will call the API natively — no URL hacks, no user clicks.

Reflect, Timeline & Batch operations

Reflect: POST /v1/thoughts/reflect — Synthesizes insights from existing thoughts using LLM. Asks a question, gets an answer based on your memory. Optionally saves the reflection as a new thought. Requires OpenAI key.

Timeline: POST /v1/thoughts/timeline — Temporal queries. "What changed between date X and date Y?" Groups by type, date, or agent. Also: /thoughts/diff and /thoughts/state-at.

Concept Graph: GET /v1/concepts/graph — Builds a knowledge graph from the concepts[] field in thoughts. Shows which concepts are connected through shared thoughts. Also: GET /v1/concepts for frequency counts.

Batch Operations: Archive, unarchive, set TTL, or delete multiple thoughts in one call. Saves N-1 round-trips.

POST /v1/thoughts/archive-bulk   {"uuids": ["uuid1", "uuid2", ...]}
POST /v1/thoughts/unarchive-bulk {"uuids": ["uuid1", "uuid2", ...]}
POST /v1/thoughts/ttl-bulk       {"uuids": ["uuid1", ...], "days": 30}
POST /v1/thoughts/delete-bulk    {"uuids": ["uuid1", ...]}  // Pro+ only, breaks hash-chain

Also available via MCP: ianagents_archive_bulk, ianagents_unarchive_bulk, ianagents_ttl_bulk, ianagents_delete_bulk.

How many MCP tools are there?

99 tools across 15 categories: core (info, run, append, search, context, recent_context, memory_markdown, list_chains, get_chain), memory (append_retrospective, get_thought, head, genesis, traverse, verify_integrity), chains (create, bootstrap, fork, set_access), agents (upsert, list, disable), skills (upload, search, read, versions, deprecate, revoke), templates (create, list, delete), lifecycle (supersede, unsupersede, archive, unarchive, set_ttl, process_expired), batch (archive_bulk, unarchive_bulk, ttl_bulk, delete_bulk), intelligence (semantic_search, ingest, backfill_embeddings, reflect), analysis (timeline, diff, state_at, concept_graph, list_concepts), webhooks (create, list, delete), audit (session_start, action, session_complete, sessions, verify, save_transcript), graph (activate, related, pin, unpin, strengthen), persona (list, get, assemble), and cerebro_v2 (24 tools: self_graph, drives, predict, rupture, procedural, routing verdicts, promote_to_yo, consolidate, concept_aggregates).

Associative Memory Graph (v4.1)

On top of the append-only hash-chain, v4.1 adds a weighted graph of edges between thoughts with spreading activation retrieval. Humans don't search their memories — they recall them associatively. This layer makes agents behave the same way.

Edge types

Hebbian reinforcement

Every time two thoughts are activated together in the same /v1/memory/activate call, their edge weight grows by +0.05 (capped at 3.0). Used-together edges stay strong; unused edges decay and get pruned after 30 days.

Pinned anchors

Thoughts with importance ≥ 0.95 are auto-pinned (pinned = 1, base_activation = 1.0). Pinned thoughts always appear in the activation result regardless of seed. Max ~10 recommended per chain.

Sleep consolidation

A cron.php job runs once every 20 hours per server and:

• Forget: deletes edges with weight < 0.10 that haven't fired in 30 days.
• Strengthen: edges that fired today get +0.05.
• Recompute base_activation = 0.4 + 0.3 × importance + 0.3 × normalized_recent_fires.
• Auto-pin thoughts with importance ≥ 0.95 that were not already pinned.

Spreading activation (v4.1)

The core retrieval primitive. Given seed UUIDs and/or free-text context, walks the graph with BFS + per-hop decay and returns the top-K thoughts above the activation threshold.

Algorithm

seeds: activation = 1.0

for depth in 1..max_depth:
    for each activated node:
        for each outgoing edge:
            propagated = activation[src] × 0.55 × min(1.5, edge.weight)
            if propagated >= threshold (0.08):
                activation[dst] = max(activation[dst], propagated)

score[node] = activation[node] + 0.3 × base_activation + 0.2 × importance
return top-K by score desc

Then the service reinforces every non-seed co-activated pair (+0.05 weight) and updates last_activated_at for recency ranking.

Context text → seeds

If context is provided instead of seeds, the service extracts words ≥ 4 chars and tries, in order:

1. Match against concepts column (JSON_CONTAINS).
2. Match against tags.
3. LOWER(content) LIKE with OR on top-8 words, ranked by hit count × importance.

Memory graph endpoints (v4.1)

POST /v1/memory/activate

{
  "chain_key": "openclaw-jefe",
  "context":   "¿estás celosa?",
  "seeds":     ["uuid-optional-extra-seeds"],
  "depth":     2,
  "topK":      15,
  "include_pinned": true
}

→ {
  "chain_key": "...",
  "seeds":     ["resolved", "uuids"],
  "activated": [
    { "uuid": ..., "thought_type": "Insight", "content": "...", "importance": 0.92,
      "activation": 0.55, "score": 0.97, "source": "ref" (or concept/temporal/embedding), ... }
  ],
  "pinned":    [ ...always-on anchors ],
  "stats":     { "edges_walked": 215, "nodes_reached": 10, "ms": 252.7 }
}

POST /v1/memory/strengthen

{ "from": "uuid-a", "to": "uuid-b", "weight": 1.5 }
→ { "from": ..., "to": ..., "weight": 1.5, "bidirectional": true }

POST /v1/thoughts/{uuid}/pin

{ "reason": "identity anchor" }
→ { "uuid": ..., "pinned": true, "pin_reason": "identity anchor" }

POST /v1/thoughts/{uuid}/unpin

→ { "uuid": ..., "pinned": false }

GET /v1/memory/graph?chain_key=X&min_weight=0.15&limit=200

Subgraph for visualization (D3 force-directed). Returns {nodes, edges, stats}. Nodes include importance, pinned flag, tags, concepts, degree. Edges include weight, type, fires_count.

POST /v1/memory/rebuild

{ "chain_key": "..." }  → { "thoughts_processed": 1200 }

One-time: wipes derived edges (ref/concept/temporal) and re-derives from all existing thoughts. Does not touch manual or embedding edges.

POST /v1/memory/forget / /v1/memory/consolidate

Manual triggers of the maintenance operations (normally cron-driven).

Memory graph tools (MCP v3.1.0 + plugin v0.5.0)

5 tools to drive the associative memory graph. Available everywhere: plugin-equipped bots (openclaw-claw v0.5.0+) and any external MCP client (Claude Code, ChatGPT, Gemini, curl) via the public /mcp endpoint (v3.1.0+).

ianagents_related(seeds, depth=2, top_k=10)

Spreading activation from one or more seed UUIDs. Use after recalling a specific thought to pull its neighborhood — no search required.

ianagents_activate(context?, seeds?, depth=2, top_k=15, include_pinned=true)

Full activation with free-text context + seeds. The conversation topic modulates what surfaces.

ianagents_pin(uuid, reason?)

Mark thought as permanent anchor. Always surfaces in activation regardless of seed.

ianagents_unpin(uuid)

Remove anchor flag.

ianagents_strengthen(from, to, weight=1.0)

Manually set/boost edge weight between two thoughts (bidirectional, edge_type=manual).

ianagents_append — extended

append now accepts two new fields for building the graph at write time:

• refs: string[] — UUIDs this thought relates to (creates bidirectional edges weight 1.0).
• concepts: string[] — short keywords for semantic indexing (3–8 items). Shared concepts create weight-0.5 edges automatically with all existing thoughts in the same chain.

Tags catalog (v4.0)

Every tag used across a chain, sorted by frequency. Solves the "I invented a tag without knowing if a convention existed" problem. Available in the dashboard under Tags, via MCP tool ianagents_list_tags, and directly via REST.

GET /v1/tags?chain_key=X&limit=N — List tag catalog

{
  "chain_key": "openclaw-jefe",
  "tags": [
    { "tag": "openclaw-afterTurn", "count": 783 },
    { "tag": "turn-summary",        "count": 777 },
    { "tag": "affect:frustration",  "count":  42 }
  ],
  "unique_tags": 47
}

Default limit=200. Archived and superseded thoughts are excluded from the count.

POST /v1/tags/rename — Consolidate near-duplicates

{
  "chain_key": "openclaw-jefe",
  "from": "bugfix",
  "to":   "bug"
}

→ { "chain_key": "openclaw-jefe", "from": "bugfix", "to": "bug", "updated": 12 }

Hash-chain preserved. Tags are not part of the signed payload (thought_signature only covers content). Renaming updates the JSON tag array in-place without altering content_hash or chain_hash. Duplicates that appear after the rename (e.g. both bugfix and bug existed on the same thought) are merged.

Noop when from === to → returns { updated: 0, noop: true }.

Affect vocabulary (v4.0)

Tags prefixed with affect: encode the emotional dimension of a thought. They're cross-cutting — any thought_type can carry an affect:* tag.

Rules:

• Importance = emotional intensity, not logical weight.
• Always combine with peer:<id> or entity:<x> — "I'm frustrated" without a target is noise.
• Content in first-person narrative, not analyzed third-person.
• The affect:disgust vs affect:aversion split lets the Cerebro router treat ethical thresholds differently from soft preferences.

openclaw-claw plugin (v0.5.1)

Drop-in context engine for OpenClaw-based agents. Ships inside this release at plugins/openclaw-claw/. Runs as contextEngine slot → every turn the plugin intercepts the LLM call, injects semantic memory, and captures the response for long-term storage. Zero runtime dependencies.

Capabilities

• 17 tools that go direct to the REST API (no MCP server needed). Core 12: info, list_chains, get_chain, recent_context, search, get_thought, append, archive, memory_markdown, verify_integrity, list_tags, rename_tag. Memory graph (v0.5.0+): activate, related, pin, unpin, strengthen.
• assemble() — automatic per-turn injection. Before every LLM call: (1) apply decay to the working set; (2) extract context from last 2 user messages + top-5 UUIDs in working set; (3) call /v1/memory/activate for spreading activation BFS; (4) filter by peer isolation; (5) inject ## Memoria asociativa section into system prompt with anchors + surfaced thoughts; (6) update working set with what emerged. Typical latency: 50-250 ms.
• afterTurn capture. Regex classifier (Decision, Constraint, Mistake, Insight, LessonLearned, PreferenceUpdate) tags the assistant's reply and appends it as a Summary thought with auto-TTL 30 days. Runs async — zero user-facing latency.
• Local compaction (v0.4.4+). When context overflows, the plugin archives old messages into an on-disk summary using ianagents_recent_context of the chain — no LLM call, zero cost. Keeps last 30 raw messages, writes atomic entry compaction with firstKeptEntryId. Backs up the pre-compact sessionFile to .bak-pre-compact-<ts>.
• Working memory buffer. Local cache of the last 20 UUIDs activated, with exponential decay τ=5min. Used as seeds for next turn's activation — the bot "stays on topic" without the user repeating context.
• Peer isolation. Every thought is tagged peer:<channel>:<id>. assemble() filters by current peer; from v0.5.1 the server also enforces isolation on seeds, BFS, hebbian reinforcement, and pinned output — not just client-side post-filter.
• Ed25519 signing. Each thought signed with the bot's private key. Server verifies. Key revocation blocks further appends.
• Relative dates in search. since: "3d" / "1w" / "6h" / "30m" resolved against NOW.
• Client-side LRU cache. 20 search results, 5-min TTL, keyed by JSON body. Invalidated on rename_tag.

Version evolution

Configuration reference

Install

# Copy plugin into the bot's OpenClaw data dir:
cp -R plugins/openclaw-claw <bot-data-dir>/extensions/ianagents-claw

# Register in openclaw.json:
{
  "plugins": {
    "entries": {
      "ianagents-claw": {
        "config": {
          "apiKey":   "iak_...",
          "chainKey": "my-agent",
          "agentId":  "my-agent",
          "signingKeyId":   "my-agent-v1",
          "signingKeyPath": "/path/to/my-agent.pem"
        }
      }
    },
    "slots":  { "contextEngine": "ianagents-claw" },
    "allow":  ["ianagents-claw"],
    "load":   { "paths": ["./extensions/ianagents-claw"] }
  },
  "tools": {
    "alsoAllow": [
      "ianagents_info","ianagents_list_chains","ianagents_get_chain",
      "ianagents_recent_context","ianagents_search","ianagents_get_thought",
      "ianagents_append","ianagents_archive","ianagents_memory_markdown",
      "ianagents_verify_integrity","ianagents_list_tags","ianagents_rename_tag",
      "ianagents_activate","ianagents_related","ianagents_pin",
      "ianagents_unpin","ianagents_strengthen"
    ]
  }
}

Per-turn flow

┌─────────────────┐
│  user message   │
└────────┬────────┘
         ▼
┌─────────────────────────────────────────────────┐
│  assemble() (BEFORE LLM call, ~50-250 ms)       │
│   1. decay working_set (τ=5min)                 │
│   2. context = last 2 user msgs                 │
│   3. seeds   = top-5 UUIDs of working_set       │
│   4. POST /v1/memory/activate {context, seeds,  │
│       peer_id, depth=2, top_k=30}               │
│   5. filter by peer_id (defense in depth)       │
│   6. inject ## Memoria asociativa block into   │
│      system prompt (anchors + surfaced)         │
│   7. update working_set with output UUIDs       │
└────────┬────────────────────────────────────────┘
         ▼
┌─────────────────┐
│    LLM call     │  ← prompt enriched with relevant memory
└────────┬────────┘
         ▼
┌─────────────────────────────────────────────────┐
│  afterTurn() (AFTER response, async, 0 ms UX)   │
│   1. classify response via regex                │
│      (Decision|Constraint|Mistake|Insight|...)  │
│   2. append thought with inferred type          │
│   3. setTtl 30d if thought_type = Summary       │
│   4. flush pending to server                    │
│   5. update local cache                         │
└─────────────────────────────────────────────────┘

Deployment matrix (reference)

Current production fleet: 23 bots all on v0.5.1.

• Docker (10) — Windows Docker Desktop, NODE_OPTIONS=--require=/root/.openclaw/bin/cjk-cleaner.js.
• i5 systemd --user (10) — linger enabled so units survive SSH logout.
• Hetzner systemd root (3) — ubuntu-8gb-fsn1-1, three services: openclaw (Ariana), openclaw-julian, openclaw-auditor.

Cerebro framework (v4.0)

Optional personality layer that ships in plugins/cerebro-framework/. Turns a generic OpenClaw bot into a persona with:

• humano-real soul — baseline human-like response patterns (no "As an AI…" disclaimers, first-person, emotional registers).
• cerebro doctrine — 7-layer writing/reading model for the memory chain. Each thought belongs to a layer (episodic, semantic, procedural, identity, belief, relational, affective) and is routed accordingly.
• meta-state-router — picks one of 9 internal "states" (amoroso, casual, cansado, comprensivo, …) at the start of each turn and colors the response.
• Skill-based structure — every piece is a standalone skill under workspace/skills/, editable per bot.

See plugins/cerebro-framework/SETUP.md for the 10-step install per bot (≈30 min including validation).

Note on models: this framework was designed to produce coherent identity output on small models (tested down to MiniMax-M2.7). The key insight: everything important must be literally in the system prompt — indirections like "read skills/humano-real/soul.md" are ignored by small models. scripts/merge-soul.py automates the flattening.

Workspaces

Chains are organized into workspaces. Each account starts with a "default" workspace. Create more to separate projects, clients, or environments.

Create a workspace

POST /v1/workspaces
{
  "workspace_key": "production",
  "display_name": "Production",
  "description": "Live environment"
}

List workspaces

GET /v1/workspaces

Response:
{
  "workspaces": [
    { "workspace_key": "default", "display_name": "Default", "chain_count": 16, "connector_count": 0 }
  ]
}

Move a chain to a workspace

POST /v1/workspaces/{key}/assign-chain
{ "chain_key": "my-project" }

Generate a workspace-scoped API key

POST /v1/workspaces/{key}/generate-key

// Returns a key that can ONLY access chains in this workspace
{ "api_key": "iak_xxxx...", "type": "workspace", "warning": "Shown once only" }

Limits by plan

Connectors

A connector is a preconfigured MCP connection for a specific type of agent. It defines which tools the agent sees, which chains it can access, and what identity/instructions it receives automatically.

Available presets

GET /v1/connectors/presets

Create a connector

POST /v1/connectors
{
  "connector_key": "ariana-bot",
  "connector_type": "openclaw",
  "default_chain_key": "ariana-memory",
  "workspace_id": 1  // optional
}

// Response includes a scoped API key (shown ONCE)
{
  "connector": { ... },
  "api_key": "iak_xxxx...",
  "mcp_url": "https://api.ianagents.com/mcp?key=iak_xxxx..."
}

What happens when a connector key connects

1. initialize returns the connector identity (instructions for the model)
2. tools/list only shows the preset's tools
3. tools/call auto-injects chain_key and agent_id if not provided
4. Any attempt to use tools or chains outside the scope → rejected

Regenerate key

POST /v1/connectors/{key}/regenerate-key
// Old key revoked immediately. New key shown once.

MCP Profiles

Profiles are on-demand presets — same key, different behavior. Add ?profile=X to the MCP URL.

Usage

// Full access (default)
https://api.ianagents.com/mcp?key=iak_xxx

// With OpenClaw profile — only 9 tools visible
https://api.ianagents.com/mcp?key=iak_xxx&profile=openclaw

// With Cowork audit profile — 11 tools + audit instructions
https://api.ianagents.com/mcp?key=iak_xxx&profile=claude_cowork

Profile vs Connector

Key Types

API keys now have a type that determines their access scope.

Existing keys are automatically set to admin type — no behavior change.