Changelog

New features, improvements, and fixes across MemHub and the Memory API.

Personal access keys

MemHub + API

If you're building your own agent, you can now authenticate to MemHub with a personal access key instead of the interactive browser login a headless loop can't do. Mint one with a single API call, drop it in an environment variable, and point any MCP client — or a plain HTTP call — at MemHub as yourself.

A key acts as you, at one seat's throughput — so it's a teammate, not a firehose for a multi-tenant app. You can scope a key read-only, hold several at once (mint a new one and revoke the old to rotate without downtime), and revoke any of them instantly. It drives MemHub's own memory over the MCP server or the REST API, and can mint and manage your Memory API keys — read the guide.

Features1
  • API keys — rotate a key in place: one call mints a new secret (keeping the key's name and owner) and revokes the old one, instead of recreate-then-revoke by hand.
Improvements4
  • Billing — credit history filters by date range and carries totals.
  • Retrieval quality — self-echo filtering, anchor junk filtering, and anchor candidate selection.
  • exclude_conv_id on recall_facts_by_entities, to leave the current conversation out of its own recall.
  • API keys — a rotated key stays attributable to its owner; rotating a legacy ownerless key assigns it to whoever rotated it, so it's no longer admin-only to manage.
Security2
  • API keys — fixed a bug where a revoked key kept authenticating; revocation now takes effect immediately rather than up to ten minutes later.
  • API keys — creating, revoking, and rotating a key now fail closed: a request that resolves no signed-in user is rejected rather than treated as an admin.

Buy compute credits up front, with auto-reload

MemHub + API

You can now buy compute credits up front rather than settling overage after the fact, and set auto-reload so a long-running agent doesn't stall mid-task. Auto-reload takes a monthly cap, so topping up automatically can't run away from you.

Memory API usage now reconciles into the same credit balance as MemHub — one number for both products instead of two meters to reason about. Credit purchases appear on your invoice, and the top-up history is filterable by date range.

Improvements2
  • Reads and writes now go through a single shared mem_all collection.
  • Metered API-subscription machinery is retired in favour of unified credits.

One meter: compute credits

MemHub + API

MemHub used to meter messages, runs, and API calls separately, which made it impossible to answer "what is this costing me?" without adding up three numbers. There is now one meter: compute credits, with an itemized spend log showing what each run consumed.

Overage is card-gated rather than surprising, Pro and Scale no longer cap members (only Free does, at 5), and the Free plan's agent-brain limit went from 3 to 15. Annual billing is two months free — the old "20%" copy was wrong.

Improvements1
  • Directive fields are served on the fact response.

Features1
  • Native GET /mem-manager/usage/summary, and self-serve management for the API subscription.
Improvements1
  • Breaking: the directive scope field was renamed scope_repo → scope, then wired through as namespace on the API surface.
Fixes1
  • Embeddings — truncation is bounded on UTF-8 bytes rather than characters.

Directive recall — memory that fires before the mistake

API
curl -X POST https://api.xtrace.ai/v1/memories/trigger \
  -H "Authorization: Bearer $XTRACE_API_KEY" \
  -d '{"query": "deploying the billing service", "namespace": "backend"}'

Procedural memory is only useful if it arrives before the agent acts, not when someone thinks to search for it. POST /v1/memories/trigger returns the lessons and procedures relevant to the work at hand, keyed off the entities in play — separate from ordinary semantic search, which now lives behind typed search groups.

Directives are filtered at capture time, so what comes back is what survived the keep/drop pass rather than everything ever written down.

Features3
  • New 2026-generation tiers, including Scale at $399, with per-org overage charging. Legacy customers are grandfathered.
  • Procedural recall is split out of /search into POST /v1/memories/trigger.
  • Async ingest write path via SQS and Lambda.
Improvements4
  • Quota and overage meter against the billing period rather than the calendar month.
  • Breaking: "recall" is renamed "search" across the customer-facing surface.
  • Breaking: X-Org-Id is dropped — the org is derived from the key.
  • The ZeroEntropy reranker is removed from the team path.
Security1
  • Rate limiting — valid API keys are no longer demoted into the unauthenticated 3/min bucket.

Features4
  • Facts can expire.
  • created_at time filtering and a since window on memory search.
  • Artifact versioning through parent_id.
  • Hybrid search — dense and lexical combined with reciprocal rank fusion.
Fixes1
  • Embeddings — per-input tokens are capped at the embedding client.

Improvements1
  • Pairwise consolidation runs at flush, cutting duplicate facts.
Fixes1
  • Persistence — NUL bytes are scrubbed and blank messages fall back to a zero vector instead of erroring.
Security1
  • Per-message rate limiting.