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
| Component | What it does | Status | Where it runs |
|---|---|---|---|
Chat model (default gemma4:e4b) | Answers chat, writes summaries and insight cards, infers answers to your reflections | Works today | Ollama on the host, or the Hub inference API |
Embedding model (nomic-embed-text, 768 dimensions) | Turns every searchable record into a vector | Works today | Same engine as chat, or a pinned embedding endpoint |
| HBPE forecaster | Forecasts the next 24 hours in 96 fifteen-minute slots, per person | Works today | hbpe-service container |
| HBPE recurrence forecasts | Week ahead, things coming due, seasonal patterns | Works today | hbpe-service container |
| HBPE activity labeler | Labels each event with an activity class for the forecaster | Works today | Chat endpoint, or a small local model in hbpe-service |
| Keyword decision fast path | Optional keyword pre-filter in front of the labeler | Behind a setting | hbpe-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 it | Works today | Memory API |
HBPE /decision/* routes | Ingress, rerank and activity scoring endpoints | Not yet; nothing in Memory calls them | hbpe-service |
| Task activity classifier | Gives each task an activity class with a regex table; completed tasks then feed the forecaster | Works today | Memory API |
Agent memory routes (/api/memory/*) | Session context, recall, fragment writes and turn sync for AI tools you connect | Works today; compaction into the graph is Behind a setting | Memory API |
| Decision-model trainer, persona extractor, batched trainer CLI | Training scaffolding for future models | Not yet | hbpe-service code only |
| Decision subsystems (ingress, planning, reranking, insight gating) | Trained decision models for four kinds of question | Planned | Design document only |
| Hub training module | Accepts training jobs and offers them to paired Hubs | Not yet | Companion Hub |
ci command line | Starts HBPE training and prints calibration and forecasts; also has routing, decision and audit commands | Works today for training and forecasts; Not yet for routing, decisions and audit | Your computer, against the Memory API |
| pg-boss queues and recurring jobs | Run all background work | Works today | Memory API and worker processes |
Enrichment ledger (ci.pipeline_state) | Tracks which processing stages each record has been through | Works today | Memory API process |
| Smart rotation | Alternative scheduler for ten kinds of background work | Behind a setting | Memory API process |
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.
flowchart TB
Archive["Archive upload<br/>Takeout, chat exports"] --> ImportQ["import-unpack, parse,<br/>media, push queues<br/>(worker process)"]
Bulk["Bulk capture API<br/>11 /api/v1 lanes"] --> Tables[("ci.* tables<br/>PostgreSQL 18")]
Live["Records made in the app"] --> Tables
Live -->|"search-index listeners"| Index[("ci_search<br/>keyword + vector index")]
ImportQ --> Tables
Tables e1@--> Ledger["Enrichment ledger<br/>pipeline-index, enrich, embed"]
e1@{ animate: true }
Ledger --> Index
Tables -->|"file.uploaded"| Parse["document-parsing queue<br/>summary-service /parse"]
Tables --> HBPE["hbpe-service<br/>labels, training, forecasts"]
Index --> Chat["Search, recall and chat"]
HBPE --> Chat
Tables --> Plan["Planning jobs<br/>tasks and suggestions"]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:
- UploadYou add a Takeout or chat exportMemory app
- UnpackZips are expanded after a disk-space checkimport-unpack
- ParseA matching parser turns files into recordsimport-parse
- MediaPhotos and files go to the object storeimport-media
- PushRecords are written and stage sweeps startimport-push
- Keyword indexA full-text row is written for the recordpipeline-index
- EmbeddingA 768-dimension vector is writtenpipeline-embed
- SearchableThe item shows up in search and chatci_search
A few details about the import stages:
- Unpack expands
.ziparchives recursively, because Takeout ships as a zip of zips. A single file or a folder passes through unchanged. Tar and.tgzexports 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-generationqueue, with theenrich.file_previewstage as a backfill. - Push writes records into the
cischema, 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 theci_importschema.
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.
| Role | Serves HTTP | Queues it consumes | Recurring jobs it runs |
|---|---|---|---|
web | Yes | Everything not marked for the worker: pipeline, search index, LLM, planning, sidecars | 45 of the 62 |
worker | No | import-unpack, import-parse, import-media, import-push, import-stages, video-playback, derivation-run | 17 of the 62 (retention, sweeps, BlueBubbles backstop, nightly derivation) |
all | Yes | All of them | All 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:
| Setting | Default |
|---|---|
| Retries | 3, starting 10 s apart, with backoff |
| Job expiry | 12 hours |
| Finished jobs kept | 24 hours |
| Jobs that never ran kept | 90 days |
| After the last retry | Moved to dead-letter, kept 30 days |
| Jobs in flight per process | 10 |
| Jobs in flight per queue | 6 |
The queues that matter most for AI work, grouped by family:
| Family | Queue | Consumer | Slots | Notes |
|---|---|---|---|---|
| Import | import-unpack, import-parse, import-media, import-push | ImportStageListener | 1, 1, 2, 1 | Worker only; 12 h expiry; heartbeat every 30 s, orphan claims reaped after 180 s |
| Pipeline | pipeline-index, pipeline-enrich, pipeline-embed | PipelineSliceListener | up to 6 each | Split by resource: Postgres, CPU and outside providers, embedding model |
| Search | search-index | 56 live indexing listeners | up to 6 | Indexes records created in the app |
| Chat | llm | chat.generate handler | 1 | The only interactive queue; 900 s expiry |
| Background LLM | llm-background, image-description, thing-vision, browser-activity-insight | LLM listeners | 1 each | Share one background lane and wait while a chat reply is generated |
| Sidecars | py-fn-summary, py-fn-hbpe | PythonFunctionDispatchListener | 1 for summary | Summary: 30 min expiry. HBPE: 8 h expiry, 2 retries 300 s apart |
| Planning | planning | PlanningJobsListener | 1 | Todo scan, inbox scan and the other planning jobs |
| Rotation | smart-rotation | SmartRotationListener | default | Used only when smart rotation is on, plus context prompts |
| Connectors | etl | SyncOrchestrator | default | Cloud connector syncs |
| Documents | document-parsing | FileDocumentParseListener | default | MarkItDown 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:
| Work | How it relates to chat |
|---|---|
llm-background, image-description, thing-vision, browser-activity-insight | Waits 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 enrichment | Calls the chat model directly and does not wait for chat. |
pipeline-embed | Does not wait for chat. Admission stops while 25 slices are waiting. |
| Enrichment stages that are not index or embed stages | Start only inside the nightly window (01:00 for 300 minutes, 90 minutes of dispatch). |
py-fn-summary | Waits 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.
| Queue | Stages | Which ones |
|---|---|---|
pipeline-index | 29 | The 7 keyword index stages, all clean and promote stages, and the three person-link enrich stages |
pipeline-enrich | 8 | Media dimensions, file preview, video playback, link unfurl, three geocoding directions, location estimate |
pipeline-embed | 7 | index.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:
| Mechanism | Rule |
|---|---|
| Tick | PipelineTickCron 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). |
| Cadence | Index 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. |
| Window | Opens 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. |
| Backpressure | New slices stop being admitted while 500 (index), 100 (enrich) or 25 (embed) are waiting, and resume at 75% of that. |
| Retries | A 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.
| Job | Runs on | Schedule | Runs a day |
|---|---|---|---|
| Fire due reminders | Memory | Every minute | 1,440 runs |
| Pipeline tick | Memory | Every 5 minutes | 288 runs |
| Inbox scan | Memory | Every 30 minutes | 48 runs |
| Hourly summaries | Memory | 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 |
| Daily metrics | Memory | 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 |
| Event-now check | Memory | 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 |
| Actions and verify-done | Memory | 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 |
| Insight cards | Memory | At 00:30, 03:30, 06:30, 09:30, 12:30, 15:30, 18:30, 21:30 | 8 runs |
| Todo processing | Memory | At 00:00, 06:00, 12:00, 18:00 | 4 runs |
| Daily summary | Memory | At 00:10 | 1 run |
| Weekly summary | Memory | At 00:15 (Mondays) | 1 run, Mondays |
| Monthly summary | Memory | At 00:20 (1st of the month) | 1 run, 1st of the month |
| HBPE nightly | Memory | At 02:30 | 1 run |
| HBPE bootstrap sweep | Memory | At 03:00 | 1 run |
| Image description sweep | Memory | At 03:20 | 1 run |
| Nightly derivation | Memory | At 04:40 | 1 run |
| Todo scan | Memory | At 06:00 | 1 run |
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 type | Schedule when on | Priority | What it does |
|---|---|---|---|
| Question feed | :00, :20, :40 every hour | -2 | Queues the next reflection question |
| Answer inference | :07, :27, :47 every hour | -2 | Infers answers on llm-background |
| Schedule sync | Hourly at :14 | +2 | Refreshes the schedule suggestion slate |
| Summaries | Hourly at :22 | +2 | Hourly summary, and the dossier when it is stale |
| Insights | Every 3 hours at :45 | +2 | Insight cards with your trust-mode volume |
| Graph link | Every 2 hours at :05 | +5 | Links people, messages and events |
| Graph enrich | Every 6 hours at :10 | +5 | Relationship enrichment with the chat model |
| Context prompt | Every 4 hours at :30 | +5 | Prepares the next context question |
| Hydrate answers, hydrate things | Daily at 03:05 and 03:15 | +5 | Cross-table hydration |
Inference
Which model serves which work
| Work | Model | Served by | Status |
|---|---|---|---|
| Chat, tools, background extraction | gemma4:e4b by default, or your choice in Settings → Model | Native Ollama at OLLAMA_HOST, or any OpenAI-compatible base in LLM_API_BASE | Works today |
| Utility work (titles, classification) | LLM_UTILITY_MODEL, which defaults to the chat model | Same as chat | Works today |
| Embeddings | nomic-embed-text, 768 dimensions, batches of 32 | LLM_EMBEDDING_API_BASE if set, else the chat backend if it serves the model, else Ollama | Works today |
| Vision (image descriptions, things) | The chat model when it supports images | Same as chat; images are sent at 1280 px on the long edge | Works today |
| Summaries, insights, actions, dossiers | SUMMARY_LLM_MODEL, else the chat model | summary-service port 8001, through the same endpoint | Works today |
| HBPE activity labels | The chat model through HBPE_LABEL_API_BASE or LLM_API_BASE | Otherwise a local Qwen3.5-0.8B (Q8_0 GGUF) through llama.cpp inside hbpe-service | Works today |
| On-device chat in the phone apps | A small on-device model | LiteRT-LM inside the Android and iOS apps; the server never calls it | Works 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
hbpeflag 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 setting | A write after a lookup | A read that reaches a third-party service after a lookup | A read from another server you own (such as your Mac) |
|---|---|---|---|
| Cautious | Asks you | Asks you | Asks you |
| Balanced (the default) | Asks you | Asks you | Runs |
| Hands-off | Runs | Runs | Runs |
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.
| Mode | How it ranks | Who uses it |
|---|---|---|
auto | Picks keyword for 3 words or fewer, boosted for 4 to 7, semantic for 8 or more | The default |
keyword | Postgres ts_rank with websearch_to_tsquery, terms joined with OR | Short queries |
boosted | ts_rank with the embedding similarity as a multiplier of at most 1.5 | Recall seeds |
semantic | Cosine distance on the embedding | Long queries, recall fallback |
hybrid | Runs keyword and semantic in parallel and averages normalized scores 50/50; a hit from one side only counts half | The 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.
| Route | What it returns | Model behind it |
|---|---|---|
GET /histogram | Tomorrow or today as 96 fifteen-minute slots, with a probability per activity class | The served forecaster (see below) |
GET /forecast | The week ahead, as the chance each recurring activity happens on each day | Recurrence statistics, rebuilt nightly |
GET /forecast/due | Recurring things that are coming due or overdue | Renewal model over the gaps between occurrences |
GET /forecast/seasonal | Month-of-year patterns | Seasonal statistics |
GET /forage, POST /forage/ask, /ingest, /sample, /pin/{name}, DELETE /forage/pin | The active-inference sampler | Forage model |
POST /functions/run, GET /runs/{id} | Starts and reports nightly and bootstrap runs | None |
GET /health | Health | None |
POST /decision/ingress, /decision/rerank, /decision/l0 | Keyword scores for intent, commitment, sensitivity, relevance and activity class | Keyword 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:
flowchart TB
Req["GET /histogram"] --> Logit{"Logistic head can be fit?<br/>200+ labelled slots, 2+ classes"}
Logit -->|"yes"| ServeLogit["Serve the logistic head"]
Logit -->|"no"| Learning{"Checkpoint and<br/>16+ days of history?"}
Learning -->|"no: still learning"| Base["Serve a baseline"]
Learning -->|"yes"| Gate{"D3 gate: transformer beats<br/>the better of B1 and B2?"}
Gate -->|"yes"| HMT["Serve the transformer<br/>INT8 ONNX, else FP32, else PyTorch"]
Gate -->|"no"| Better["Serve the better baseline"]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,q50andq90fields 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.
| Piece | What it is | Status |
|---|---|---|
| Quick-decision API | POST /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 down | Works today for apps and agents; no Memory feature calls it |
| HBPE keyword fast path | Scores keyword hits in an event’s title and description, and skips the labeling model’s activity-class (L0) call when one class reaches 0.75 | Behind a setting |
HBPE /decision/ingress, /rerank, /l0 | Endpoints for intent, commitment, sensitivity, relevance and activity class. Without an external engine they return keyword scores | Not 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”.
| Setting | Default today | What it does |
|---|---|---|
HBPE_ENABLE_DECISION_MODELS | false | Turns the keyword fast path on in front of the labeler |
HBPE_DECISION_MODEL_ENDPOINT or DECISION_MODEL_URL | unset | Base URL of an outside decision engine |
HBPE_DECISION_CONFIDENCE_THRESHOLD | 0.75 | Lowest 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.
| Subsystem | Questions it would answer | Status |
|---|---|---|
| A: Memory ingress | should_store, memory_partition, privacy_level | Planned |
| B: Planning and commitments | is_commitment, action_type, urgency, needs_confirmation | Planned |
| C: Reranking and fact deprecation | is_relevant, contradiction_status, temporal_decay | Planned |
| D: Proactive insight gating | insight_utility, user_interruptibility, delivery_channel | Planned |
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.
| Setting | Value |
|---|---|
| Model width | 256 |
| Layers and heads | 6 layers, 8 heads |
| Feed-forward width | 1024 |
| Dropout | 0.1 |
| Slots per day | 96 (15 minutes each) |
A cold-start bootstrap runs these steps. Labeling keeps going past errors; training stops on the first error.
- Label events and summaries, then serialize the token stream. If there are no tokens, stop.
- 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.
- 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.
- Train L0 and L1 jointly. The L1 loss for each slot is weighted by the model’s probability of the true L0 class there.
- 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.
- 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.
- Train an initial adapter.
| Training setting | Pretraining | Joint training |
|---|---|---|
| Optimizer | AdamW, weight decay 0.01 | AdamW, weight decay 0.01 |
| Learning rate | 1e-4, cosine decay to a tenth | 5e-5, cosine decay to a tenth |
| Epochs | Up to 50, stop after 7 without improvement | Up to 50, stop after 7 without improvement |
| Batch | One day per step | One day per step |
| Precision | fp32 | fp32 |
| Gradient clipping | 1.0 | 1.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
- Cron fires02:30, one job per personMemory API
- LabelNew events get activity classes, 4 h budgethbpe-service
- SerializeDays become token sequenceshbpe-service
- Retrain if neededOnly with no checkpoint or a changed vocabularyhbpe-service
- AdapterOne LoRA step on yesterdayhbpe-service
- ActualsYesterday's labels fill in what happenedhbpe-service
- RecurrenceWeek, due and seasonal profiles rebuilthbpe-service
- ScorePast forecasts scored for the gatehbpe-service
- 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
triggerHbpeGraphQL mutation, orci train runfrom thecicommand 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.
| Model | What it predicts for a slot |
|---|---|
| B0 | How often each class occurred in that slot across your history |
| B1 | How often each class occurred in that slot on that weekday |
| B2 | B1’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):
| File | Contents |
|---|---|
l0_mae_checkpoint.pt | The pretrained L0 model |
hmt_checkpoint.pt | The jointly trained model |
hmt_calibrated.pt | The same model with its temperature |
hmt_fp32.onnx, hmt_int8.onnx | The exported graphs |
lora_<uuid>.pt and up to 3 .vNNNN copies | The live adapter and its archived versions |
architecture.json, calibration_report.json, onnx_export_report.json | Reports 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:
| Command | What it does | What it calls | Status |
|---|---|---|---|
ci train run | Queues 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 mutation | Works today |
ci train calibration | Prints 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 flag | predictionCalibration query | Works today |
ci train rebuild-places | Rebuilds your stay-point clusters and the place-to-place transitions behind next-place predictions | rebuildPlaces mutation | Works today |
ci inference forecast | Prints 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 places | forecast, weekForecast, dueForecast and placeForecast queries | Works today |
ci inference tiers, decide, rank | Meant to list model-routing tiers, plan a route, and run the quick-decision API | GET /model-routing/tiers, POST /model-routing/plan, /decide and /rank | Not yet |
ci audit pipeline, ci audit dead-letters, ci audit jobs | Meant to print enrichment-ledger coverage by stage, dead-lettered jobs, and queue and cron status | GET /pipeline/state, /pipeline/dead-letters and /jobs/dashboard | Not 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:
| Piece | What it does today | Status |
|---|---|---|
Batched trainer and train_runner CLI | Trains 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 |
UnslothDecisionTrainer | Checks 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 |
PersonaDataExtractor | Reads 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 plan | A plan for small decision models trained on your history, grouped into the four planned decision subsystems | Planned |
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 offload | Sends 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 library | A 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.
| Job | When | What it does |
|---|---|---|
| Todo scan | Daily at 06:00 | Searches your memories for things that look like tasks, classifies them with the chat model (at most 8 calls a run), and creates tasks |
| Inbox scan | Every 30 minutes | Reads unprocessed email, text and chat messages for commitments; creates tasks or adds notes to matching ones |
| Todo processing | Every 6 hours | Checks 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 check | Hourly at :15 | Looks 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 done | Hourly at :45 | Looks 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 reminders | Every minute | Claims 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 setting | New task from a scan | Marking a task done | Placing a task on the calendar |
|---|---|---|---|
| Cautious | Proposed for review | Proposed for review | Proposed for review |
| Balanced (the default) | Created as open at confidence 0.55 or above | Proposed for review (needs 0.85) | Proposed for review |
| Hands-off | Created as open at confidence 0.7 or above | Done automatically on attributed evidence | Placed 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:
| Source | What becomes a suggestion |
|---|---|
| Feed actions | Each action that has not been dismissed |
| Insight cards | Each key action on an insight card |
| HBPE due list | Recurring things due within 3 days or overdue, at confidence 0.6 or above, not already booked |
| Proposed tasks | Top-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.
| Route | What it does | Status |
|---|---|---|
GET /api/memory/context | Your 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/recall | Searches your memory for the current turn | Works today |
POST /api/memory/write | Saves 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/conflicts | Lists fragments marked as conflicting | Works today |
POST /api/memory/drift | Lists fragments that mention file paths you changed, and can mark them as conflicting | Works today |
POST /api/memory/turn | Stores 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 |
| Compaction | Every 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.
- Connector syncs pull in new mail, messages and calendar entries, and AI tools post their conversations to
/api/memory/turn. - 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.
- 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/contextand can call tools such asbrief.listandsuggestions.list. Suggestions are ranked by how often you accepted earlier ones from the same rule. - Schedule on the Plan board, or the
planning.scheduleTasktool, puts a task in the first free gap as described above. On Hands-off, confident new to-dos are placed on their own. - Tool calls your Autonomy setting holds back wait on the Approvals page until you approve or decline them.
- 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.
| Output | How it is made | When |
|---|---|---|
| Insight cards | insights_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 anomalies | 13 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 chat | Computed first, then phrased by a template narrator. An LLM narrator exists but is not used. | Each chat turn |
| Reflections | Answers 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
| Place | What you see | Status |
|---|---|---|
| Chat | Plan, forecast, brief and stats context on every turn, plus tools for anomalies, insights and suggestions | Works today |
| Context questions | Yes-or-no questions built from suggestions, metrics and places | Works today |
Self → Stats (/self/stats) | Computed cards such as most messaged person and busiest channel | Works today |
Self → Reflections (/self/reflections) | The question catalogue and your typed or inferred answers | Works 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 there | Works today |
Brief (/today) | Feed actions, a question, a context prompt, insight and summary cards | Behind a setting (today.page) |
Forecast (/forecast) | The 96-slot strip, the week ahead and the due list | Behind a setting (forecast.page) |
Review surfaces
These are the places where you confirm or correct what the background jobs produced:
| Surface | Route | What you decide |
|---|---|---|
| Plan board | /plan/tasks | Accept 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/places | Save 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 | /asks | Approve, answer with less, or decline a question from another person; manage standing grants |
| Approvals | /approvals | Approve 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.