Skip to Content
DocumentationCompanion MemoryAI training, inference & jobs

AI training, inference & jobs

Companion Memory does three kinds of AI work. It calls language and embedding models to answer you, label your records and make them searchable. It trains one small model of its own, a per-person forecast of how your day usually goes. And it runs a large set of background jobs that keep the search index, the forecasts, your task list and your insight cards up to date.

If you want the plain-language tour first, read How your personal AI runs.

This page describes Companion Memory main and Companion Hub dev as of 12 November 2026. The latest releases, Memory v2026.11.11 and Hub v0.3.11, predate some of it: on v2026.11.11 and desktop v0.1.10 the HBPE keyword fast path is still on by default, and the HBPE /decision/* routes, the task activity classifier, proposed tasks on the suggestion slate, ci login and the ci train, ci inference and ci audit commands are missing. Hub v0.3.11 has no training module at all.

Your records, the models Memory trains and the jobs that process them stay on your appliance. The exceptions are listed under What stays on your hardware: place lookups go through Companion Portal by default, map tiles load from a map provider, and the fallback labeling model is downloaded once from Hugging Face.

This page uses the same four status labels as Personas:

  • Works today: the capability is on by default.
  • Behind a setting: the capability is in the code, but it is off until an owner or operator turns it on.
  • Not yet: the capability is not built, or it is built but not connected to the product.
  • Planned: the design is documented, and the code does not exist yet.

For the plain-language version of the training story, read How Companion learns.

At a glance

ComponentWhat it doesStatusWhere it runs
Chat model (default gemma4:e4b)Answers chat, writes summaries and insight cards, infers answers to your reflectionsWorks todayOllama on the host, or the Hub inference API
Embedding model (nomic-embed-text, 768 dimensions)Turns every searchable record into a vectorWorks todaySame engine as chat, or a pinned embedding endpoint
HBPE forecasterForecasts the next 24 hours in 96 fifteen-minute slots, per personWorks todayhbpe-service container
HBPE recurrence forecastsWeek ahead, things coming due, seasonal patternsWorks todayhbpe-service container
HBPE activity labelerLabels each event with an activity class for the forecasterWorks todayChat endpoint, or a small local model in hbpe-service
Keyword decision fast pathOptional keyword pre-filter in front of the labelerBehind a settinghbpe-service
Quick-decision API (/api/model-routing/decide, /rank)Embedding-based yes/no, choice, score and ranking calls that apps and agents can make; no built-in feature calls itWorks todayMemory API
HBPE /decision/* routesIngress, rerank and activity scoring endpointsNot yet; nothing in Memory calls themhbpe-service
Task activity classifierGives each task an activity class with a regex table; completed tasks then feed the forecasterWorks todayMemory API
Agent memory routes (/api/memory/*)Session context, recall, fragment writes and turn sync for AI tools you connectWorks today; compaction into the graph is Behind a settingMemory API
Decision-model trainer, persona extractor, batched trainer CLITraining scaffolding for future modelsNot yethbpe-service code only
Decision subsystems (ingress, planning, reranking, insight gating)Trained decision models for four kinds of questionPlannedDesign document only
Hub training moduleAccepts training jobs and offers them to paired HubsNot yetCompanion Hub
ci command lineStarts HBPE training and prints calibration and forecasts; also has routing, decision and audit commandsWorks today for training and forecasts; Not yet for routing, decisions and auditYour computer, against the Memory API
pg-boss queues and recurring jobsRun all background workWorks todayMemory API and worker processes
Enrichment ledger (ci.pipeline_state)Tracks which processing stages each record has been throughWorks todayMemory API process
Smart rotationAlternative scheduler for ten kinds of background workBehind a settingMemory API process
Processing stages in the enrichment ledger
44
from ledger
pg-boss queues
about 44
Plus one shared dead-letter queue.
from queues
Recurring jobs in the Memory API
62
17 run only in the worker process.
from schedule
Fifteen-minute slots in a forecast day
96
from forecasts

How work flows through Memory

Records reach Memory in three ways. Archive imports run on four import queues in the worker process. The bulk /api/v1 capture lanes write rows directly and leave indexing until the client calls /api/v1/ingest/finish. Records you create in the app are indexed by live listeners as they are written. After that, the enrichment ledger takes every record through the processing stages that apply to it, and the search index, the forecaster and the planning jobs read the result.

The bulk capture API has 11 POST lanes: events, communications, contents, things, inventory, browser-activity, notes, positions, receipts, product-models and observations (sightings). POST /api/v1/files uploads files and POST /api/v1/ingest/finish starts the deferred indexing and enrichment. The gateway strips the /api prefix, so the controllers themselves are mounted at /v1.

Here is the path one item from an archive takes before you can find it:

  1. UploadYou add a Takeout or chat exportMemory app
  2. UnpackZips are expanded after a disk-space checkimport-unpack
  3. ParseA matching parser turns files into recordsimport-parse
  4. MediaPhotos and files go to the object storeimport-media
  5. PushRecords are written and stage sweeps startimport-push
  6. Keyword indexA full-text row is written for the recordpipeline-index
  7. EmbeddingA 768-dimension vector is writtenpipeline-embed
  8. SearchableThe item shows up in search and chatci_search
From archive upload to searchableImport queues run in the worker process; pipeline queues run in the API process.

A few details about the import stages:

  • Unpack expands .zip archives recursively, because Takeout ships as a zip of zips. A single file or a folder passes through unchanged. Tar and .tgz exports are not handled, so extract them first.
  • Parse picks one of the registered data sources (WhatsApp, Strava, Apple Photos, Notion, Evernote and Google Keep among them). A parser that fails is skipped and the run ends with the status partial.
  • Media uploads bytes to the object store, which hashes them with SHA-256 to avoid storing a file twice. Previews (300 px JPEGs) are made later by the file-preview-generation queue, with the enrich.file_preview stage as a backfill.
  • Push writes records into the ci schema, deduplicated by a source id derived from a content hash, then starts the index and embedding sweeps for what it wrote. Staging data lives in the ci_import schema.

Uploaded documents (csv, doc, docx, md, pdf, txt, xls, xlsx) take a separate path. The file.uploaded event lands on the document-parsing queue, which sends the file to the MarkItDown parser on summary-service port 8002 with a 120-second limit per document, then splits the text into ci.file_chunks.

Background jobs

Two processes from one image

The Memory API image runs in one of three roles, set by CI_ROLE. The default, all, runs everything in one process. Production and staging compose split it into a web container, which serves HTTP and consumes most queues, and a single worker container. The worker exists so that long import parsers do not share an event loop with your requests.

RoleServes HTTPQueues it consumesRecurring jobs it runs
webYesEverything not marked for the worker: pipeline, search index, LLM, planning, sidecars45 of the 62
workerNoimport-unpack, import-parse, import-media, import-push, import-stages, video-playback, derivation-run17 of the 62 (retention, sweeps, BlueBubbles backstop, nightly derivation)
allYesAll of themAll 62

Queues

Memory uses pg-boss version 12, which keeps its jobs in PostgreSQL. Queues are not declared in one list. Each listener that subscribes with a queue name creates that queue at boot, which gives about 44 worked queues plus the shared dead-letter queue. Nothing uses pg-boss’s own scheduler; every recurring job is a NestJS @Cron method that enqueues work.

Every queue starts from one shared policy, and a listener can override it:

SettingDefault
Retries3, starting 10 s apart, with backoff
Job expiry12 hours
Finished jobs kept24 hours
Jobs that never ran kept90 days
After the last retryMoved to dead-letter, kept 30 days
Jobs in flight per process10
Jobs in flight per queue6

The queues that matter most for AI work, grouped by family:

FamilyQueueConsumerSlotsNotes
Importimport-unpack, import-parse, import-media, import-pushImportStageListener1, 1, 2, 1Worker only; 12 h expiry; heartbeat every 30 s, orphan claims reaped after 180 s
Pipelinepipeline-index, pipeline-enrich, pipeline-embedPipelineSliceListenerup to 6 eachSplit by resource: Postgres, CPU and outside providers, embedding model
Searchsearch-index56 live indexing listenersup to 6Indexes records created in the app
Chatllmchat.generate handler1The only interactive queue; 900 s expiry
Background LLMllm-background, image-description, thing-vision, browser-activity-insightLLM listeners1 eachShare one background lane and wait while a chat reply is generated
Sidecarspy-fn-summary, py-fn-hbpePythonFunctionDispatchListener1 for summarySummary: 30 min expiry. HBPE: 8 h expiry, 2 retries 300 s apart
PlanningplanningPlanningJobsListener1Todo scan, inbox scan and the other planning jobs
Rotationsmart-rotationSmartRotationListenerdefaultUsed only when smart rotation is on, plus context prompts
ConnectorsetlSyncOrchestratordefaultCloud connector syncs
Documentsdocument-parsingFileDocumentParseListenerdefaultMarkItDown text extraction

What waits for chat

Chat has its own queue with one slot, so a chat reply never sits behind background work on that queue. Other work protects chat in different ways, and some of it does not yield at all:

WorkHow it relates to chat
llm-background, image-description, thing-vision, browser-activity-insightWaits while a chat reply is being generated. A job that has already started finishes first.
Planning scans (todo scan, inbox scan, todo processing)Calls the chat model directly and does not wait for chat. Limited to one planning job at a time.
Smart rotation graph enrichmentCalls the chat model directly and does not wait for chat.
pipeline-embedDoes not wait for chat. Admission stops while 25 slices are waiting.
Enrichment stages that are not index or embed stagesStart only inside the nightly window (01:00 for 300 minutes, 90 minutes of dispatch).
py-fn-summaryWaits for room on the summary service, not for chat.

The enrichment ledger

ci.pipeline_state records, for every record and every stage that applies to it, which version of the stage last ran and how it ended. Its key is (entity_type, entity_id, stage). Each row stores a stage_version and a status of pending, running, done, skipped, failed or quarantined. A row is due to run when it is missing, when its version is below the stage’s current version, or when it failed and its retry time has come.

There are 44 stages in four families. Each stage reads one source table, so no record goes through all 44.

promote: 14 — places, things, sightings, graph edgespromote14 · places, things, sightings, graph edgesindex: 14 — 7 keyword, 7 embeddingindex14 · 7 keyword, 7 embeddingenrich: 11 — media, previews, geocoding, person linksenrich11 · media, previews, geocoding, person linksclean: 5 — duplicates, identifiers, time repairclean5 · duplicates, identifiers, time repair
Enrichment ledger stages by family
QueueStagesWhich ones
pipeline-index29The 7 keyword index stages, all clean and promote stages, and the three person-link enrich stages
pipeline-enrich8Media dimensions, file preview, video playback, link unfurl, three geocoding directions, location estimate
pipeline-embed7index.embed plus one embedding stage each for communications, events, items, people, files and browser activity

No stage runs OCR, speech-to-text, face recognition or object detection. Things in photos are detected by the vision pass on the thing-vision queue, and sightings from outside detectors arrive through the observations lane.

How the ledger is driven:

MechanismRule
TickPipelineTickCron runs every 5 minutes, at second 20, under a Postgres advisory lock. It starts at most 4 sweeps per tick, in an order that respects declared dependencies between stages (for example, geocoding before a place is promoted).
CadenceIndex stages and graph-edge promote stages run any hour; index.embed also runs as records arrive. Most other local stages run nightly inside the enrichment window. The four stages that call outside services (three geocoding directions and link unfurl) run weekly inside the window, with caps.
WindowOpens at 01:00 server time for 300 minutes and spends at most 90 minutes dispatching. Each person gets a 20-minute turn, least recently served first.
BackpressureNew slices stop being admitted while 500 (index), 100 (enrich) or 25 (embed) are waiting, and resume at 75% of that.
RetriesA failed stage retries after 60 seconds, doubling up to 6 hours, and is quarantined after 5 attempts. Failures caused by an unreachable provider or embedding model back off from 15 minutes and are never quarantined.

Re-running a stage after a version bump

Stage versions are plain integers in versions.ts; clean.duplicate_detect is at version 8, for example. When a developer raises a stage’s number, the next sweep finds every row with a lower stage_version and runs that stage again over the whole corpus, and quarantined rows for that stage get another chance. The embedding stages take their version from the embedding model and vector width, so changing CI_EMBED_MODEL re-embeds everything.

Operators can watch and steer the ledger through /api/pipeline: state, runs (with pause, resume and cancel), dead letters with replay, and quarantine release.

When recurring jobs run

The Memory API declares 62 recurring jobs. The chart shows the ones that drive AI work. Times are on the server clock, which is UTC in the shipped images unless you set TZ.

Memory00:0006:0012:0018:0024:00Runs a dayFire due reminders — Every minute · 1,440 runs · MemoryFire due reminders1,440 runsPipeline tick — Every 5 minutes · 288 runs · MemoryPipeline tick288 runsInbox scan — Every 30 minutes · 48 runs · MemoryInbox scan48 runsHourly summaries — At 00:05, 01:05, 02:05, 03:05, 04:05, 05:05, 06:05, 07:05, 08:05, 09:05, 10:05, 11:05, 12:05, 13:05, 14:05, 15:05, 16:05, 17:05, 18:05, 19:05, 20:05, 21:05, 22:05, 23:05 · 24 runs · MemoryHourly summaries24 runsDaily metrics — At 00:10, 01:10, 02:10, 03:10, 04:10, 05:10, 06:10, 07:10, 08:10, 09:10, 10:10, 11:10, 12:10, 13:10, 14:10, 15:10, 16:10, 17:10, 18:10, 19:10, 20:10, 21:10, 22:10, 23:10 · 24 runs · MemoryDaily metrics24 runsEvent-now check — At 00:15, 01:15, 02:15, 03:15, 04:15, 05:15, 06:15, 07:15, 08:15, 09:15, 10:15, 11:15, 12:15, 13:15, 14:15, 15:15, 16:15, 17:15, 18:15, 19:15, 20:15, 21:15, 22:15, 23:15 · 24 runs · MemoryEvent-now check24 runsActions and verify-done — At 00:45, 01:45, 02:45, 03:45, 04:45, 05:45, 06:45, 07:45, 08:45, 09:45, 10:45, 11:45, 12:45, 13:45, 14:45, 15:45, 16:45, 17:45, 18:45, 19:45, 20:45, 21:45, 22:45, 23:45 · 24 runs · MemoryActions and verify-done24 runsInsight cards — At 00:30, 03:30, 06:30, 09:30, 12:30, 15:30, 18:30, 21:30 · 8 runs · MemoryInsight cards8 runsTodo processing — At 00:00, 06:00, 12:00, 18:00 · 4 runs · MemoryTodo processing4 runsDaily summary — At 00:10 · 1 run · MemoryDaily summary1 runWeekly summary — At 00:15 (Mondays) · 1 run, Mondays · MemoryWeekly summary1 run, MondaysMonthly summary — At 00:20 (1st of the month) · 1 run, 1st of the month · MemoryMonthly summary1 run, 1st of the monthHBPE nightly — At 02:30 · 1 run · MemoryHBPE nightly1 runHBPE bootstrap sweep — At 03:00 · 1 run · MemoryHBPE bootstrap sweep1 runImage description sweep — At 03:20 · 1 run · MemoryImage description sweep1 runNightly derivation — At 04:40 · 1 run · MemoryNightly derivation1 runTodo scan — At 06:00 · 1 run · MemoryTodo scan1 run
JobRuns onScheduleRuns a day
Fire due remindersMemoryEvery minute1,440 runs
Pipeline tickMemoryEvery 5 minutes288 runs
Inbox scanMemoryEvery 30 minutes48 runs
Hourly summariesMemoryAt 00:05, 01:05, 02:05, 03:05, 04:05, 05:05, 06:05, 07:05, 08:05, 09:05, 10:05, 11:05, 12:05, 13:05, 14:05, 15:05, 16:05, 17:05, 18:05, 19:05, 20:05, 21:05, 22:05, 23:0524 runs
Daily metricsMemoryAt 00:10, 01:10, 02:10, 03:10, 04:10, 05:10, 06:10, 07:10, 08:10, 09:10, 10:10, 11:10, 12:10, 13:10, 14:10, 15:10, 16:10, 17:10, 18:10, 19:10, 20:10, 21:10, 22:10, 23:1024 runs
Event-now checkMemoryAt 00:15, 01:15, 02:15, 03:15, 04:15, 05:15, 06:15, 07:15, 08:15, 09:15, 10:15, 11:15, 12:15, 13:15, 14:15, 15:15, 16:15, 17:15, 18:15, 19:15, 20:15, 21:15, 22:15, 23:1524 runs
Actions and verify-doneMemoryAt 00:45, 01:45, 02:45, 03:45, 04:45, 05:45, 06:45, 07:45, 08:45, 09:45, 10:45, 11:45, 12:45, 13:45, 14:45, 15:45, 16:45, 17:45, 18:45, 19:45, 20:45, 21:45, 22:45, 23:4524 runs
Insight cardsMemoryAt 00:30, 03:30, 06:30, 09:30, 12:30, 15:30, 18:30, 21:308 runs
Todo processingMemoryAt 00:00, 06:00, 12:00, 18:004 runs
Daily summaryMemoryAt 00:101 run
Weekly summaryMemoryAt 00:15 (Mondays)1 run, Mondays
Monthly summaryMemoryAt 00:20 (1st of the month)1 run, 1st of the month
HBPE nightlyMemoryAt 02:301 run
HBPE bootstrap sweepMemoryAt 03:001 run
Image description sweepMemoryAt 03:201 run
Nightly derivationMemoryAt 04:401 run
Todo scanMemoryAt 06:001 run
When Memory's AI-related jobs run in a dayUTC unless TZ is set. Seconds offsets are left out. The enrichment window (01:00 to 06:00) is a gate, not a job, so it is not drawn.

Some jobs are not on the chart because they run every minute or depend on a flag. Answer inference for your reflections checks every minute and dispatches each person at most once every 20 minutes. Connector syncs start every minute and run pending syncs every 30 seconds. The HBPE bootstrap also runs once, 30 seconds after the API starts. The full list of jobs, with what each one does, is in What runs in the background, and when.

Smart rotation

Behind a setting: smart rotation is an opt-in scheduler. It is controlled by the smart.rotation feature flag (ENABLE_SMART_ROTATION), which is off in the shipped configuration. While it is off, the fixed jobs above do the same work, and the ten smart-rotation jobs return without doing anything.

When it is on, each of its ten work types gets its own schedule. Each run takes up to 10 people in turn and enqueues one job per person on the smart-rotation queue, with a pg-boss priority. Question feed and answer inference are skipped while 500 or more jobs are waiting on the default and smart-rotation queues. It does not handle imports, enrichment or planning.

Work typeSchedule when onPriorityWhat it does
Question feed:00, :20, :40 every hour-2Queues the next reflection question
Answer inference:07, :27, :47 every hour-2Infers answers on llm-background
Schedule syncHourly at :14+2Refreshes the schedule suggestion slate
SummariesHourly at :22+2Hourly summary, and the dossier when it is stale
InsightsEvery 3 hours at :45+2Insight cards with your trust-mode volume
Graph linkEvery 2 hours at :05+5Links people, messages and events
Graph enrichEvery 6 hours at :10+5Relationship enrichment with the chat model
Context promptEvery 4 hours at :30+5Prepares the next context question
Hydrate answers, hydrate thingsDaily at 03:05 and 03:15+5Cross-table hydration

Inference

Which model serves which work

WorkModelServed byStatus
Chat, tools, background extractiongemma4:e4b by default, or your choice in Settings → ModelNative Ollama at OLLAMA_HOST, or any OpenAI-compatible base in LLM_API_BASEWorks today
Utility work (titles, classification)LLM_UTILITY_MODEL, which defaults to the chat modelSame as chatWorks today
Embeddingsnomic-embed-text, 768 dimensions, batches of 32LLM_EMBEDDING_API_BASE if set, else the chat backend if it serves the model, else OllamaWorks today
Vision (image descriptions, things)The chat model when it supports imagesSame as chat; images are sent at 1280 px on the long edgeWorks today
Summaries, insights, actions, dossiersSUMMARY_LLM_MODEL, else the chat modelsummary-service port 8001, through the same endpointWorks today
HBPE activity labelsThe chat model through HBPE_LABEL_API_BASE or LLM_API_BASEOtherwise a local Qwen3.5-0.8B (Q8_0 GGUF) through llama.cpp inside hbpe-serviceWorks today
On-device chat in the phone appsA small on-device modelLiteRT-LM inside the Android and iOS apps; the server never calls itWorks today

On a Hub install, the Hub fills in these settings for you. Memory’s app manifest maps the Hub’s chat model, utility model, embedding model, inference base URL and context size onto the variables above, so the API, the worker, summary-service and hbpe-service all talk to the Hub’s OpenAI-compatible endpoint. By default that endpoint is the Hub’s pool proxy. The Hub serves chat from Ollama, vLLM, Lemonade or oMLX, and uses LocalAI only for speech and image generation. How Companion Hub runs apps and models covers the Hub side.

The labeler never sends more than 6 requests a minute to the shared endpoint, and it waits up to 600 seconds for a running chat turn. While it is on the local fallback model, it checks the endpoint again every 300 seconds and switches back when it answers. The fallback model is downloaded from Hugging Face the first time it is needed.

A chat turn

You send a message to POST /api/llm/generate. The API saves your message, enqueues a chat.generate job on the llm queue and streams the reply back as server-sent events. GET /api/llm/threads/:id/stream re-attaches to a reply that is still running. Before the model runs, the API builds one block of context, marked as untrusted data, from:

  • grounded recall over your memories (see Search and recall);
  • your active tasks (up to 20);
  • the next 8 slots of your HBPE forecast, when the hbpe flag is on, which it is by default;
  • up to 8 open feed actions and 4 recent summaries;
  • up to 5 computed statistics with at least 50% data coverage.

The model then runs its tool loop. The first response must start within 90 seconds, or the request is retried, up to 3 attempts in all. Nothing on this path has been timed for speed.

The tool gate after a lookup

Inside a chat turn, every tool call made after the first round of tool calls carries a followsLookup flag, whatever the earlier calls returned. The tool gate in tool-core uses it to decide whether a call needs your approval. After a lookup the gate does not refuse a call; it runs it or queues it for approval. Searches of your own memory always run.

Trust settingA write after a lookupA read that reaches a third-party service after a lookupA read from another server you own (such as your Mac)
CautiousAsks youAsks youAsks you
Balanced (the default)Asks youAsks youRuns
Hands-offRunsRunsRuns

Queued calls wait in ci.pending_actions and show up as approval cards on the Approvals page. The flag is set in OllamaService, evaluated in tool-core’s toolGate.ts, and applied in PendingActionService.

Search and recall

Search reads two polymorphic index tables, each keyed by (entity_type, entity_id): ci_search.vectors holds a full-text tsvector with a GIN index, and ci_search.embeddings holds a 768-dimension vector with an HNSW index. Both cover every indexable type, from messages and events to receipts, tasks and file chunks.

ModeHow it ranksWho uses it
autoPicks keyword for 3 words or fewer, boosted for 4 to 7, semantic for 8 or moreThe default
keywordPostgres ts_rank with websearch_to_tsquery, terms joined with ORShort queries
boostedts_rank with the embedding similarity as a multiplier of at most 1.5Recall seeds
semanticCosine distance on the embeddingLong queries, recall fallback
hybridRuns keyword and semantic in parallel and averages normalized scores 50/50; a hit from one side only counts halfThe chat’s database-search tool

Keyword ranking is Postgres ts_rank, not BM25. Reciprocal rank fusion (with k = 60) exists as an option, but no caller turns it on, and no decision model reranks search results.

Recall, which chat uses, works in three steps. It seeds with boosted search (falling back to semantic), expands one hop through the graph, and adds a separate message channel. That channel is re-sorted by age with a 90-day half-life and a floor of 0.25, unless you turn recency weighting off. There is no social-distance weighting.

The HBPE forecasting service

HBPE (Hierarchical Behavioral Prediction Engine) runs as the hbpe-service container on port 8002; its Python package is ci-hbpe. The API calls it with a shared sidecar secret. It has no scheduler of its own: the API’s jobs send it work through the py-fn-hbpe queue, and it calls back when a run ends. Between runs it listens for new events in Postgres, re-tokenizes today and clears its forecast cache.

RouteWhat it returnsModel behind it
GET /histogramTomorrow or today as 96 fifteen-minute slots, with a probability per activity classThe served forecaster (see below)
GET /forecastThe week ahead, as the chance each recurring activity happens on each dayRecurrence statistics, rebuilt nightly
GET /forecast/dueRecurring things that are coming due or overdueRenewal model over the gaps between occurrences
GET /forecast/seasonalMonth-of-year patternsSeasonal statistics
GET /forage, POST /forage/ask, /ingest, /sample, /pin/{name}, DELETE /forage/pinThe active-inference samplerForage model
POST /functions/run, GET /runs/{id}Starts and reports nightly and bootstrap runsNone
GET /healthHealthNone
POST /decision/ingress, /decision/rerank, /decision/l0Keyword scores for intent, commitment, sensitivity, relevance and activity classKeyword engine; see The /decision/* routes

The eight activity classes are WORK, EXERCISE, SOCIAL, ERRAND, LEISURE, TRANSIT, SLEEP and UNKNOWN. Only /histogram uses a trained model. For that route, the service picks the model on each request:

In practice the logistic head is what you usually see. It is a scikit-learn multinomial logistic regression over 40 features: time-of-day harmonics, the weekday, whether it is a weekend, what you were doing in the same slot yesterday and a week ago, and a recency histogram. It is refit for each forecast date on your history, with empty slots filled from the sleep rhythm you gave at onboarding, so a few days of history are enough. The code prefers it because of one offline walk-forward comparison recorded in a code comment; it is not scored live. Its displayed label is adjusted against how common each class is, while the stored probabilities are not.

  • Whatever model is chosen, the forecast is smoothed with an HMM pass, and the cluster probabilities in it come from the transformer whenever a checkpoint exists.
  • The q10, q50 and q90 fields are the spread of the transformer’s confidence across the history windows it averaged. When the logistic head is served they collapse to one value.
  • The ONNX session uses default execution providers, which means CPU in the shipped compose stacks. GPU access for HBPE is opt-in through a ROCm compose overlay.
  • Results are cached per person and per date.

Decision layers (“System 1”)

The code uses “System 1” for fast scoring that answers fixed questions (yes or no, pick one, score 0 to 2) in one pass instead of generating text. Three separate pieces carry that name. None of them uses a trained decision model, because none has been trained.

PieceWhat it isStatus
Quick-decision APIPOST /api/model-routing/decide and /rank. Embeds the text once and compares it with cached candidate vectors (softmax at a fixed temperature of 0.12), with a hashed-trigram fallback when the embedder is downWorks today for apps and agents; no Memory feature calls it
HBPE keyword fast pathScores keyword hits in an event’s title and description, and skips the labeling model’s activity-class (L0) call when one class reaches 0.75Behind a setting
HBPE /decision/ingress, /rerank, /l0Endpoints for intent, commitment, sensitivity, relevance and activity class. Without an external engine they return keyword scoresNot yet; nothing in Memory calls them

The quick-decision API

The code calls this service ContrastiveDecisionService. Settings → Model has two switches for it under “Memory governance & decision engines”: “Contrastive fast decisions (System 1)” and “Generative LLM decisions (System 2)”. Both are on by default, and they only affect these two routes.

With both on, a request runs in hybrid mode. The service compares embeddings first. When that answer is a close call, with the probabilities of the top two options less than 0.15 apart, it averages it half and half with a second score. That second score is meant to come from a language model, but no language-model evaluator is registered, so it is a word-overlap score between the input and each option. With only the generative switch on, every answer is that word-overlap score. Apps and agents can call the routes, but chat, search and ingest do not. The ci inference decide and rank commands target them too, but do not work as shipped; see The ci command line. Ranking does not wait for a close call: in hybrid mode /rank always averages the embedding score half and half with the word-overlap score.

The HBPE keyword engine

DecisionModelClient can call an outside engine at <endpoint>/v1/systemone with a 5-second timeout, but nothing ships such an engine and no deployment sets the endpoint. Without one it uses LocalDecisionEngine, which counts keyword substrings, applies a softmax and marks every result as calibrated. It does not read the question text: every yes/no question scores the same commitment words, and every 0-to-2 question scores the same urgency words. One keyword hit gives an activity class about 0.51, under the 0.75 bar; two hits give about 0.89. Substring matches misfire, so “brunch” counts as exercise because it contains “run”.

SettingDefault todayWhat it does
HBPE_ENABLE_DECISION_MODELSfalseTurns the keyword fast path on in front of the labeler
HBPE_DECISION_MODEL_ENDPOINT or DECISION_MODEL_URLunsetBase URL of an outside decision engine
HBPE_DECISION_CONFIDENCE_THRESHOLD0.75Lowest keyword (or outside engine) score at which the fast path uses its activity class; UNKNOWN never counts

With the fast path off, the labeling model sees only the events that need it. Workouts, sleep, trips and place visits get a fixed activity class from their kind, music, video and social activity never reach the chat model, and calendar entries and other free text go to the labeler. Setting HBPE_ENABLE_DECISION_MODELS=true lets an activity label that reaches the threshold on keyword scores be stored without asking the labeler; the code says to do that only once a trained model serves the endpoint. On v2026.11.11 and desktop v0.1.10 the fast path is still on by default. The activity-cluster (L1) label always comes from the labeling model.

The /decision/* routes

Not yet: hbpe-service serves the three routes, and the Memory API has matching client methods with a 3-second timeout, but nothing in Memory calls those methods; only tests do. Each suite is a separate call, and rerank scores passages one at a time. Because the routes use the keyword engine above, a passage with the words “remind”, “deadline” and “today” outranks a passage that actually matches the query.

The code describes System 1 as taking under 10 ms. Nobody has measured that, and there is no served model to measure.

The task activity classifier

Works today: taskL0Classifier is a weighted regex table (a title match counts 2, a description or notes match counts 1) that sets ci.tasks.l0_class when a task is created, updated or completed. It does not use the decision engine. Completed tasks with a class become tokens for the HBPE forecaster, but a task counts only on a day that already has another event or an hourly summary. Proposed tasks carry their class onto the schedule suggestion slate. The first time hbpe-service reads completed tasks, it checks once whether any task has a class other than UNKNOWN. If none does, it skips task tokens until it restarts.

Planned decision subsystems

A design document in the Memory repository groups future trained decision models into four subsystems. None of them is built. is_commitment and is_relevant appear in the HBPE question suites behind the /decision/* routes above, and is_commitment, urgency and privacy_level appear in the persona extractor’s example labels. Nothing in the product calls any of them.

SubsystemQuestions it would answerStatus
A: Memory ingressshould_store, memory_partition, privacy_levelPlanned
B: Planning and commitmentsis_commitment, action_type, urgency, needs_confirmationPlanned
C: Reranking and fact deprecationis_relevant, contradiction_status, temporal_decayPlanned
D: Proactive insight gatinginsight_utility, user_interruptibility, delivery_channelPlanned

Training

What learns from your data today

Two things in Memory learn from your history, and both live in hbpe-service:

  • The HBPE transformer, trained once when you have enough history, recalibrated and exported, then adjusted nightly with a small adapter (Works today).
  • The logistic head described above, refit from your labelled history each time a forecast date is built (Works today).

Training needs labelled events. The labeler gives each event an activity class, and the serializer turns each day into a sequence of tokens on the 96-slot grid: a start-of-day marker, one token per labelled event, the declared sleep window, and an end-of-day marker. A completed task that has an activity class also counts as an event, placed at the time it was completed. A task counts only on a day that already has another event or an hourly summary. Slots with no event have no token.

The transformer

The model is one transformer encoder over a day’s tokens, with two token levels: L0 activity classes and L1 activity clusters. Attention is hierarchical, so a level only attends to its own level and lower ones. It has two linear output heads, one for L0 and one for L1.

SettingValue
Model width256
Layers and heads6 layers, 8 heads
Feed-forward width1024
Dropout0.1
Slots per day96 (15 minutes each)

A cold-start bootstrap runs these steps. Labeling keeps going past errors; training stops on the first error.

  1. Label events and summaries, then serialize the token stream. If there are no tokens, stop.
  2. Split the days: the most recent 14 are held out as a test set, and 15% of the rest, sampled evenly across weekdays, are used for validation.
  3. Pretrain on L0 as a masked autoencoder: 75% of each day’s maskable L0 tokens are hidden and the model learns to fill them in.
  4. Train L0 and L1 jointly. The L1 loss for each slot is weighted by the model’s probability of the true L0 class there.
  5. Fit one temperature for calibration by grid search over 0.1 to 5.0 in 100 steps, minimising validation loss. Expected calibration error is reported against a target of 0.08, but not enforced.
  6. Export to ONNX (opset 17) as FP32 and statically quantized INT8. INT8 is used only if its L0 top-1 accuracy on the test days is within 1 percentage point of FP32.
  7. Train an initial adapter.
Training settingPretrainingJoint training
OptimizerAdamW, weight decay 0.01AdamW, weight decay 0.01
Learning rate1e-4, cosine decay to a tenth5e-5, cosine decay to a tenth
EpochsUp to 50, stop after 7 without improvementUp to 50, stop after 7 without improvement
BatchOne day per stepOne day per step
Precisionfp32fp32
Gradient clipping1.01.0

Training uses CUDA if it is available, then Apple MPS, then the CPU. The pipeline budgets 2,700 seconds for training and 300 for export, but those are guesses written into the code, and the code itself says the budgets are optimistic by about three times. Your time depends on how much history you have and on your hardware.

The nightly adapter

Each night HBPE trains a LoRA adapter (rank 8, alpha 16, on the attention projections) for one epoch on yesterday’s tokens only, with the main model frozen and a learning rate of 5e-5. Because yesterday is a single batch, that is one optimizer step. The adapter is saved if the loss is finite, after the previous copy is archived. The last three archived copies are kept as lora_<uuid>.pt.vNNNN files. There is no validation step and no automatic rollback; an older copy can be restored by hand. The adapter is reset when the base model, its architecture or the cluster vocabulary changes.

The nightly adapter changes served forecasts only on the PyTorch fallback path or after the next ONNX export, and export runs only when the model is rebuilt.

When training runs

  1. Cron fires02:30, one job per personMemory API
  2. LabelNew events get activity classes, 4 h budgethbpe-service
  3. SerializeDays become token sequenceshbpe-service
  4. Retrain if neededOnly with no checkpoint or a changed vocabularyhbpe-service
  5. AdapterOne LoRA step on yesterdayhbpe-service
  6. ActualsYesterday's labels fill in what happenedhbpe-service
  7. RecurrenceWeek, due and seasonal profiles rebuilthbpe-service
  8. ScorePast forecasts scored for the gatehbpe-service
One nightly HBPE runEach step keeps going if an earlier one fails. The job can run for up to 8 hours.
  • Nightly at 02:30, for every onboarded person, as shown above.
  • At 03:00, and 30 seconds after the API starts, a sweep bootstraps anyone without a checkpoint and retrains anyone whose checkpoint has an older architecture.
  • On demand, through the triggerHbpe GraphQL mutation, or ci train run from the ci command line.

One pipeline runs at a time in hbpe-service. Labeling sends at most 6 requests a minute to the shared model endpoint and spends at most 4 hours a night. The transformer is not served until you have 16 days of history and a checkpoint; until then you see a baseline or the logistic head.

The D3 serve gate

The gate runs on each forecast request and only chooses between the transformer and two baselines. It reads the latest scores in hbpe.prediction_score, which the nightly scoring step writes by comparing logged forecasts with what happened over the last 14 days.

ModelWhat it predicts for a slot
B0How often each class occurred in that slot across your history
B1How often each class occurred in that slot on that weekday
B2B1’s distribution for the previous slot, pushed one step through a per-daypart transition matrix

All baselines are Laplace-smoothed. The transformer is served only if its Brier score is at least 0.02 below the better of B1 and B2, and its calibration error is no more than 0.02 above theirs. Otherwise the baseline with the lower Brier score is served. With no scores yet, the transformer is served if a checkpoint exists, and B1 if not. Top-1 accuracy is recorded for information only.

“What happened” here means the label the nightly labeler stored for that slot, or your declared sleep window, so the scores measure agreement with those labels. The Forecast panel’s calibration report reads the same table and calls its basis “self-consistency-vs-qwen-labels”.

The walk-forward harness in ci.hbpe.evaluation is a separate tool a developer runs by hand (python -m ci.hbpe.evaluation --user <uuid>). It scores every day that has at least 14 earlier days against the baselines, the logistic head and optionally the transformer, and prints whether the transformer clears the gate. No pipeline step calls it.

Files HBPE keeps for you

Per-person files live in $MODELS_DIR/hmt/users/<uuid>/ (/app/models in the container):

FileContents
l0_mae_checkpoint.ptThe pretrained L0 model
hmt_checkpoint.ptThe jointly trained model
hmt_calibrated.ptThe same model with its temperature
hmt_fp32.onnx, hmt_int8.onnxThe exported graphs
lora_<uuid>.pt and up to 3 .vNNNN copiesThe live adapter and its archived versions
architecture.json, calibration_report.json, onnx_export_report.jsonReports read at load time

The ci command line

The ci command line (backend/apps/cli) is an HTTP client for the Memory API. It signs in with an API key, which ci login can save for you. Three of its command groups touch AI work:

CommandWhat it doesWhat it callsStatus
ci train runQueues your nightly HBPE run, which bootstraps the transformer first if you have no checkpoint. Says so if a run is already queued or running.triggerHbpe mutationWorks today
ci train calibrationPrints the latest serve-gate scores and their history (14 by default): Brier score, calibration error, top-1 and top-3 accuracy, coverage and the drift flagpredictionCalibration queryWorks today
ci train rebuild-placesRebuilds your stay-point clusters and the place-to-place transitions behind next-place predictionsrebuildPlaces mutationWorks today
ci inference forecastPrints the day forecast (the first 12 slots unless you pass --limit), or with --week, --due or --places the week ahead, the due list or likely next placesforecast, weekForecast, dueForecast and placeForecast queriesWorks today
ci inference tiers, decide, rankMeant to list model-routing tiers, plan a route, and run the quick-decision APIGET /model-routing/tiers, POST /model-routing/plan, /decide and /rankNot yet
ci audit pipeline, ci audit dead-letters, ci audit jobsMeant to print enrichment-ledger coverage by stage, dead-lettered jobs, and queue and cron statusGET /pipeline/state, /pipeline/dead-letters and /jobs/dashboardNot yet

The training and forecast commands report an error when the hbpe feature flag is off; it is on by default.

The routing, decision and audit commands were written against request and reply shapes the API does not use. decide sends a type field where the API expects primitive, so the API refuses every request. tiers, rank and the three audit commands read fields the replies do not have and fail while printing; with --json they print the reply as it came. tiers --plan also sends option names the API drops, so only the input-token estimate reaches the planner.

None of these commands, nor ci login, ci logout and ci whoami, is in v2026.11.11.

Training code that is not connected yet

Several pieces of training code are merged but cannot do anything for you yet:

PieceWhat it does todayStatus
Batched trainer and train_runner CLITrains the same transformer 16 days per batch from a JSONL file and prints progress lines for Hub. No calibration or export, and nothing writes the input file.Not yet
UnslothDecisionTrainerChecks whether Unsloth is installed, then writes decision_model_meta.json with fixed numbers (Brier 0.08, ECE 0.03, accuracy 0.94). It trains nothing, and Unsloth is not a dependency.Not yet
PersonaDataExtractorReads two fixed paths in a personal data export, group-chat message files and a Takeout zip (Tasks and Saved lists), and turns them into keyword-labelled decision questions (intent, commitment, urgency, privacy, activity). There is no redaction step. Only tests call it, and the tests that read a real export run only when HBPE_PERSONA_EXPORT_DIR names one.Not yet
Persona and decision-model planA plan for small decision models trained on your history, grouped into the four planned decision subsystemsPlanned
Hub training module (/api/training)Accepts a job, checks battery power and macOS thermal state once, and when GPU memory looks short asks Ollama to unload models and starts anyway. It runs python3 -m ci.hbpe.model.train_runner. Its routes need a signed-in user, and starting or cancelling a job needs someone who can manage the Hub. It validates each job manifest and refuses a job id that is already queued or running. The manifest check also accepts Unsloth job types, but every job starts the same HBPE trainer. Job state is kept in memory only. The Hub image has no Python or HBPE package, and Memory never submits jobs.Not yet
Hub peer offloadSends a job to a connected, enabled pool peer when the job allows offload, outbound pooling is on and the local check fails. The peer accepts dataset and checkpoint paths only inside its own training data folder, so the data must already be on that Hub; nothing copies datasets between Hubs. The sending Hub can read that job’s status from the peer, but nothing asks for it, and no result is sent back. When a peer refuses a job, the error names the peer and its reason.Not yet
Hub training-jobs libraryA job manifest, state machine, placement ranking and evaluation gate. Nothing imports it.Not yet

What does not exist yet:

  • No decision model has been trained or served, and no feedback (accepted tasks, search clicks, label corrections) is collected for one.
  • No supervised fine-tuning of a chat model on your messages exists.
  • No training job runs across Hubs yet. The peer offload above is not connected yet (Not yet), so in practice Hub Pool shares inference requests only.
  • No nightly adapter is validated or rolled back automatically.

Training your own models has the short version of this section.

Planning, insights, reflections and review

Planning jobs

Works today: six planning jobs run on the planning queue, one at a time, for every onboarded person while planning.enabled is on (the default). The scans call the chat model directly.

JobWhenWhat it does
Todo scanDaily at 06:00Searches your memories for things that look like tasks, classifies them with the chat model (at most 8 calls a run), and creates tasks
Inbox scanEvery 30 minutesReads unprocessed email, text and chat messages for commitments; creates tasks or adds notes to matching ones
Todo processingEvery 6 hoursChecks up to 40 active tasks a run against your recent memories and asks the chat model whether to append, revise, re-parent or complete each one
Event-now checkHourly at :15Looks for cancel phrases (“cancelled”, “couldn’t attend”) in recent memories around task-linked blocks and suggests revisions to calendar events. It does not re-ask a question you declined for the same block
Verify doneHourly at :45Looks at task-linked calendar blocks that ended in the last 36 hours (up to 30) for evidence the task was done: done phrases (“finished”, “wrapped up”) in recent memories that name the task. It does not re-ask a question you declined for the same block
Fire remindersEvery minuteClaims due reminders in one database statement, so each is sent once, and sends them

Todo scan and inbox scan skip a to-do whose title is close to one you already have. Inbox scan ignores conversations with AI tools you connect. Todo scan reads what you said to such a tool, but not the tool’s replies, so a task is never made from an agent’s own words.

Your Autonomy setting (Settings → Autonomy; the code calls it the trust setting) decides whether a suggestion is applied or waits for you:

Trust settingNew task from a scanMarking a task donePlacing a task on the calendar
CautiousProposed for reviewProposed for reviewProposed for review
Balanced (the default)Created as open at confidence 0.55 or aboveProposed for review (needs 0.85)Proposed for review
Hands-offCreated as open at confidence 0.7 or aboveDone automatically on attributed evidencePlaced automatically at 0.7 or above

Verify done rates attributed evidence at 0.8 and anything else at 0.55, so only hands-off completes tasks on its own. After each scan, stale proposals are either moved to today or archived, and a proposal you already accepted is skipped.

Placing a task uses a first-fit search with no language model. Starting today, or on the day you asked for, it looks at each of the next 7 days by default, weekends included, for the first gap in your work hours (09:00 to 17:00 by default, in your time zone) that fits the task’s estimate (30 minutes by default). The earliest start is rounded up to the next 15 minutes, and a task can start right when an earlier event ends. Nothing is placed in the past or over a timed event; all-day events do not block time. There is no daily cap and no buffer between blocks.

The schedule suggestion slate

SuggestionSyncService builds a table of suggested calendar slots, ci.event_candidates. It is Behind a setting: it runs only with smart rotation on, as described below. It reads four sources, at most 25 from each:

SourceWhat becomes a suggestion
Feed actionsEach action that has not been dismissed
Insight cardsEach key action on an insight card
HBPE due listRecurring things due within 3 days or overdue, at confidence 0.6 or above, not already booked
Proposed tasksTop-level tasks still waiting for review on the Plan board, with their activity class

The sync runs hourly at :14 only when smart rotation is on, or when a client calls the syncScheduleSuggestions mutation; the shipped web app does not call it. No page lists the slate. Open suggestions reach you as context questions such as “I have a plan for you for Thursday: …”, and answering yes accepts the suggestion. When smart rotation is on and you use hands-off, the top three suggestions at 0.7 or above are booked automatically between 08:00 and 20:00 your time.

Declining a suggestion with “never” stops the same idea (same title and description after normalizing) from being suggested again from any source. “Not now” snoozes it for 24 hours and “wrong time” for 6. When you dismiss the feed action, or accept or decline the proposed task, that an open suggestion came from, the suggestion is retired with the reason source_dismissed, which does not stop the idea from coming back.

HBPE also keeps its own forecasts consistent with your calendar. A due item that already has a matching event is marked as scheduled instead of overdue, booked events are pinned into the week forecast, and calendar repeat rules seed due dates for activities with too little history.

AI tools you connect

AI tools you connect, such as Claude Desktop, Cursor, OpenClaw or Hermes, reach Memory with an API key in two ways. The MCP server at /api/mcp offers Memory’s tools, for example brief.list, forecast.read, places.next, suggestions.list and planning.scheduleTask. The agent memory routes under /api/memory give the tool your context and keep its notes. The code calls the context route L0 and the recall route L1; Connect Companion Memory groups the other routes as L2.

RouteWhat it doesStatus
GET /api/memory/contextYour profile block and up to 24 lines of your next-24-hour HBPE forecast, with no clock-dependent lines, so an agent can cache it for a session. The server wraps it as untrusted context.Works today
POST /api/memory/recallSearches your memory for the current turnWorks today
POST /api/memory/writeSaves a note (a fragment) with one of eight categories: fact, decision, goal, constraint, architecture, state, preference or observation. The category is guessed from the text when none is sent.Works today
GET /api/memory/conflictsLists fragments marked as conflictingWorks today
POST /api/memory/driftLists fragments that mention file paths you changed, and can mark them as conflictingWorks today
POST /api/memory/turnStores each message of an agent conversation as a chat message. The id comes from the message’s content, so a resent turn is skipped.Works today
CompactionEvery 5 minutes, turns up to 100 written fragments into people, places, other entities and the relationships between them in your graph with the chat model, 4 fragments per call. POST /api/memory/compact runs it on demand.Behind a setting (agent.memory.compaction); the route works today

A write compares the new fragment with up to 100 of your active ones. When both fill the same slot with different values (where you live, where you work, your role, the tool you mainly use, or a preference), the older one is marked superseded. When the two say nearly the same thing and one negates the other without a word such as “now” or “no longer”, the older one is marked as conflicting. This check is on unless you turn off memory governance in Settings → Model. Compaction drops any extracted name that is not written in the fragments it read, because small models tend to copy names from the prompt’s examples.

Tools called through /api/mcp meet the same approval gate as chat tools (see The tool gate after a lookup). A call that needs your approval returns TOOL_QUEUED and waits on the Approvals page. A call from an installed app always waits for you before anything irreversible, whatever your Autonomy setting, and an app’s key cannot approve it.

A day with the planning jobs

Put together, the jobs above run a daily loop. Every step below works today.

  1. Connector syncs pull in new mail, messages and calendar entries, and AI tools post their conversations to /api/memory/turn.
  2. Inbox scan (every 30 minutes) and todo scan (06:00) find to-dos. Your Autonomy setting decides whether each one joins your task list or waits in Proposed.
  3. Chat adds your tasks, forecast, open feed actions and recent summaries to every turn. An outside tool gets your profile and forecast from /api/memory/context and can call tools such as brief.list and suggestions.list. Suggestions are ranked by how often you accepted earlier ones from the same rule.
  4. Schedule on the Plan board, or the planning.scheduleTask tool, puts a task in the first free gap as described above. On Hands-off, confident new to-dos are placed on their own.
  5. Tool calls your Autonomy setting holds back wait on the Approvals page until you approve or decline them.
  6. Reminders go out every minute. Verify done (hourly at :45) and todo processing (every 6 hours) look for evidence that a task is done and then suggest completing it, or complete it on Hands-off.

Insights, metrics and reflections

Four things produce the cards and answers you see. Daily metrics and metric answers are computed before any language model runs; insight cards and reflections are written by the chat model.

OutputHow it is madeWhen
Insight cardsinsights_generation in summary-service asks the chat model for one insight at a time from recent graph changes, the next 14 days of events, summaries, relationships, messages and your dossier. Skipped when nothing is new or there are fewer than 2 context items. At most 5 per run.Every 3 hours at :30
Daily metrics and anomalies13 daily metrics are computed in SQL. Three detectors (a robust z-score over 28 days, a CUSUM change detector over 90 days, and a forecast-divergence check) and four suggestion rules turn them into templated feed cards, at most 3 a day.Hourly at :10
Metric answers in chatComputed first, then phrased by a template narrator. An LLM narrator exists but is not used.Each chat turn
ReflectionsAnswers to the reflection question catalogue, inferred by the chat model from your data. Answers below 0.4 confidence are dropped; the rest are kept or sent to review by your trust setting.Answer inference, at most every 20 minutes per person
  • An insight may list related entity ids suggested by the model. They are checked only for being well-formed ids, not for whether those entities exist.
  • The anomaly detectors need at least 14 days with enough data. A suggestion is promoted only with a same-day anomaly or a solid correlation behind it, one at a time, and each suggestion rule learns from accept or dismiss feedback you give in chat.
  • Context questions can carry computed numbers, such as “You had 3 conversations yesterday vs about 8 most days”. The chat model is told to copy those numbers unchanged, but nothing checks that it does.
  • Reflection thresholds: cautious never promotes an answer automatically, balanced promotes at 0.55 and hands-off at 0.7, and anything below 0.55 always goes to review.

Where the results show up

PlaceWhat you seeStatus
ChatPlan, forecast, brief and stats context on every turn, plus tools for anomalies, insights and suggestionsWorks today
Context questionsYes-or-no questions built from suggestions, metrics and placesWorks today
Self → Stats (/self/stats)Computed cards such as most messaged person and busiest channelWorks today
Self → Reflections (/self/reflections)The question catalogue and your typed or inferred answersWorks today
Planning → Calendar (/plan/calendar)Your HBPE week rhythm behind the hours. Picking a time opens a drawer with Predictions, the forecast line for that slot, and Possibilities, tasks you can place thereWorks today
Brief (/today)Feed actions, a question, a context prompt, insight and summary cardsBehind a setting (today.page)
Forecast (/forecast)The 96-slot strip, the week ahead and the due listBehind a setting (forecast.page)

Review surfaces

These are the places where you confirm or correct what the background jobs produced:

SurfaceRouteWhat you decide
Plan board/plan/tasksAccept a proposed task into the backlog, decline it (archives it), plan, schedule or defer it, and accept or decline suggested changes
People merge suggestions/memory/people”Merge into one person” or “Not the same person”
Places/memory/placesSave a suggested known place with a label and kind; “Merge into one place” or “Not the same place” for duplicates
Things and sightings/memory/things”Merge into one thing” or “Not the same thing”; for sightings, “This is…” to link one to a thing you own, or “Not a thing”
Asks/asksApprove, answer with less, or decline a question from another person; manage standing grants
Approvals/approvalsApprove or decline tool calls the trust setting held back

People

The clean.duplicate_detect stage files candidate pairs in ci.merge_candidates from shared handles (scored 0.8), name overlap (0.5), phone numbers (0.85) and profile URLs. Pairs with a shared email, an exact phone match or the same LinkedIn URL are merged automatically, by the review query and by an hourly job, unless the merge would touch your own record or join two people whose names share nothing. A merge moves identifiers, messages, events and relationships onto one record and writes an audit row. “Not the same person” writes a block so the pair is not suggested again.

Places

Known places are suggested from where your events happen and where you are at night; home or work is suggested only after 3 weeks of routine. Confirming home also recomputes up to 180 days of daily metrics so time at home appears. Duplicates are places with the same provider id, or the same name within 150 m.

Things

Duplicates share a serial or model identifier, the same catalog product and name, or the same brand and model bought the same day. Sightings come from the vision pass, from outside detectors and from imports. A sighting the resolver matches at 0.8 or above is linked automatically and updates the thing’s last-seen time and place; the review card holds the ones that are neither confirmed nor resolved.

Receipts

The receipts pages are for browsing. Physical line items become things automatically after extraction.

Asks

“Answer with less” offers three caps: at most yes or no, at most how many, and at most a summary. Approve answers one ask; standing grants are made on the Grants tab, and asks they match are answered automatically. Every final outcome writes one append-only row to ci.ask_audit, with no digest. See Asking and sharing architecture.

Last updated on