Hippocortex — Billing & Pricing

Version: 2.0.0 Date: 2026-03-25

1. Pricing Tiers

	Free	Pro	Unlimited	Team
Price	€0/mo	€9.99/mo	€29.99/mo	€299/mo
Captures/month	5,000	25,000	Unlimited	Unlimited
Synthesize/day	75	5,000	Unlimited	Unlimited
Learn/day	7	50	Unlimited	Unlimited
Agents	3	Unlimited	Unlimited	Unlimited
Collective Brain	—	✓	✓	✓
Vault	—	✓	✓	✓
Advanced Analytics	—	—	✓	✓
Seats	1	1	1	Up to 10
Orgs & RBAC	—	—	—	✓
Namespaces	—	—	—	✓
Audit Logs	—	—	—	✓
Lifecycle Policies	—	—	—	✓
Behavioral Intelligence	—	—	—	✓
API Rate Limits	Standard	Standard	Higher	Higher
Support	Ticket	Priority Ticket (24h)	Priority Ticket (12h)	Priority Ticket (12h)
Status	Available	Available	Available	Coming Soon

2. Feature Comparison

Feature	Free	Pro	Unlimited	Team
Event Capture	✓	✓	✓	✓
Memory Compilation	✓	✓	✓	✓
Context Synthesis	✓	✓	✓	✓
Knowledge Artifacts	✓	✓	✓	✓
Gateway	✓	✓	✓	✓
SDK (JS + Python)	✓	✓	✓	✓
OpenClaw Plugin	✓	✓	✓	✓
Collective Brain	—	✓	✓	✓
Vault (Encrypted)	—	✓	✓	✓
Secret Detection	—	✓	✓	✓
Advanced Analytics	—	—	✓	✓
Organizations & RBAC	—	—	—	✓
Memory Namespaces	—	—	—	✓
Policy Engine	—	—	—	✓
Audit Logging	—	—	—	✓
Lifecycle Policies	—	—	—	✓
Behavioral Intelligence	—	—	—	✓

3. Billing Unit: Events

An event is a single capture() call that passes the dedup guard and is ingested into the memory pipeline.

Counted as events:

Messages, tool calls, tool results, file edits, test runs, command executions, browser actions, API results
Each event in a batch counts individually

NOT counted:

Duplicate events (rejected by dedup guard)
Failed ingestion attempts
learn() calls (counted separately, included in plan)
synthesize() calls (counted separately, included in plan)
GET /artifacts or GET /metrics calls (read-only)
Vault queries and reveals (read-only)

4. Metering Architecture

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│   Capture    │────▶│   Redis      │────▶│   Billing    │
│   Service    │     │   Counter    │     │   Service    │
│              │     │   (atomic)   │     │   (hourly    │
│  increment   │     │              │     │    flush)    │
│  on ingest   │     │  per-tenant  │     │              │
└──────────────┘     └──────────────┘     └──────┬───────┘
                                                  │
                                           ┌──────▼───────┐
                                           │   Postgres   │
                                           │   usage_     │
                                           │   counters   │
                                           └──────┬───────┘
                                                  │
                                           ┌──────▼───────┐
                                           │   Stripe     │
                                           │   (monthly   │
                                           │    invoice)  │
                                           └──────────────┘

4.1 Real-Time Counting

# Redis key pattern
hippocortex:usage:{tenant_id}:{yyyy-mm}:events → INCR on each ingest
hippocortex:usage:{tenant_id}:{yyyy-mm}:syntheses → INCR on each synthesis
hippocortex:usage:{tenant_id}:{yyyy-mm}:compilations → INCR on each learn
hippocortex:usage:{tenant_id}:daily:{yyyy-mm-dd}:events → INCR (for daily caps)

4.2 Hourly Flush

A billing worker flushes Redis counters to PostgreSQL hourly:

INSERT INTO usage_records (tenant_id, period_hour, events, syntheses, compilations)
VALUES ($1, date_trunc('hour', now()), $2, $3, $4)
ON CONFLICT (tenant_id, period_hour)
DO UPDATE SET
    events = usage_records.events + EXCLUDED.events,
    syntheses = usage_records.syntheses + EXCLUDED.syntheses,
    compilations = usage_records.compilations + EXCLUDED.compilations;

4.3 Quota Enforcement

On each capture request:
1. INCR Redis counter → get current count
2. If count > plan.eventsLimit:
   - Free tier: Return 429 quota_exceeded
   - Pro/Unlimited: Return 429 quota_exceeded (hard cap)
   - If count == 80% of limit: Queue webhook "quota.warning"
   - If count == 100% of limit: Queue webhook "quota.exceeded"

5. Stripe Integration

5.1 Products & Prices

Products:
  hippocortex_pro:
    price: €9.99/mo (recurring)
    metadata: { events_limit: 25000, tier: "pro" }

  hippocortex_unlimited:
    price: €29.99/mo (recurring)
    metadata: { events_limit: -1, tier: "unlimited" }

  hippocortex_team:
    price: €299/mo (recurring)
    metadata: { events_limit: -1, tier: "team", seats: 10 }

5.2 Billing Cycle

Monthly cycle (subscription anniversary date):
1. Day 1: Reset event counters
2. Day 1: Charge base subscription
3. Invoice sent via Stripe

5.3 Upgrade/Downgrade

Upgrade: Immediate. Prorated charge for remaining days. New limits apply instantly.
Downgrade: End of current billing period.
Cancel: End of current billing period. Data retained for 30 days, then purged.

6. Free Tier Limits

The free tier is designed for evaluation and prototyping:

Resource	Limit	Enforcement
Captures	5,000/mo	Hard cap (429 after)
Synthesize	75/day	Hard cap
Learn	7/day	Hard cap
Agents	3	Hard cap
Storage	30-day retention	Auto-purge
Dashboard	Basic metrics only	Feature gate

Free tier purpose: Get developers to experience the capture → learn → synthesize loop. Convert to Pro when they need production volume or advanced features.

7. Usage Dashboard

The billing section of the developer dashboard shows:

┌────────────────────────────────────────────────────────┐
│  Current Period: Mar 1 – Mar 31, 2026                  │
│  Plan: Pro (€9.99/mo)                                  │
│                                                        │
│  Captures:   ████████░░░░░░░░░░░░  18,500 / 25,000    │
│  Synthesize: ████░░░░░░░░░░░░░░░░   2,100 / 5,000/day │
│  Learn:      ██░░░░░░░░░░░░░░░░░░      12 / 50/day    │
│                                                        │
│  Next billing date: Apr 1, 2026                        │
│                                                        │
│  [View detailed usage] [Download invoice] [Upgrade]    │
└────────────────────────────────────────────────────────┘

8. Billing Data Model

CREATE TABLE subscriptions (
    id              UUID PRIMARY KEY,
    tenant_id       UUID NOT NULL REFERENCES tenants(id),
    stripe_sub_id   TEXT NOT NULL,
    plan            TEXT NOT NULL,           -- free, pro, unlimited, team
    status          TEXT NOT NULL,           -- active, past_due, canceled
    current_period_start TIMESTAMPTZ NOT NULL,
    current_period_end   TIMESTAMPTZ NOT NULL,
    created_at      TIMESTAMPTZ NOT NULL,
    canceled_at     TIMESTAMPTZ
);

CREATE TABLE usage_records (
    tenant_id       UUID NOT NULL,
    period_hour     TIMESTAMPTZ NOT NULL,
    events          BIGINT DEFAULT 0,
    syntheses       BIGINT DEFAULT 0,
    compilations    BIGINT DEFAULT 0,
    PRIMARY KEY (tenant_id, period_hour)
);

CREATE TABLE invoices (
    id              UUID PRIMARY KEY,
    tenant_id       UUID NOT NULL,
    stripe_inv_id   TEXT NOT NULL,
    period_start    TIMESTAMPTZ NOT NULL,
    period_end      TIMESTAMPTZ NOT NULL,
    base_amount     INTEGER NOT NULL,       -- cents (EUR)
    total_amount    INTEGER NOT NULL,       -- cents (EUR)
    status          TEXT NOT NULL,           -- draft, open, paid, void
    created_at      TIMESTAMPTZ NOT NULL
);