Memory Power
One local user, two Profile scopes and Agent-directed knowledge tools
Each Downcity platform data root has one local User independent of Federation login accounts. City owns base user information; MemoryPower owns User and Agent memories.
Memory Power workspace
The sidebar offers User memory, Processing records and Settings. User memory opens by default; Settings stays fixed in a separate bottom section:
| Entry | Purpose |
|---|---|
| User memory | Manage user agreements and knowledge; default page |
| Processing records | Inspect target=user Jobs, changes, sources and retry results |
| Settings | Knowledge backend, memory processing and maintenance configuration information |
The main navigation has no Agent list or project dimension. User memory contains Agreements and Knowledge tabs, fixed to target=user, without choosing an Agent or Workspace. Agreements displays source blocks and supports viewing and appending. Editing or deleting a source block requires an exact unique match and the version returned by the read; re-read after conflicts. Knowledge supports search, viewing, creation, editing and deletion. User knowledge details open in the current main area, with a return to the list.
The Agent Profile's Memory section contains Agreements, Knowledge and Processing records tabs, fixed to the current Agent's private scope. Agreements displays that Agent's Core Profile as read-only content by default, with refresh and retry after read failures. Knowledge supports browsing, creation, revision and deletion. Processing records contains only Jobs with target=agent owned by that Agent. This entry has no project filter. Access Workspace knowledge through scoped memory tools with target=current_workspace.
Click a memory in the Agent Profile's knowledge list to open its detail in a separate host tab, with revision, deletion, sources and the update time. After deletion, the tab displays “Memory deleted”; close it through the host tab controls. The list retains its scroll position, and details bind to the selected memory and its ownership. If reading fails, use Retry in the same detail tab.
Settings opens without an Agent or Workspace. The knowledge backend section reports the Provider's actual status, storage and knowledge capabilities; Builtin is the available implementation and is host-managed. Memory processing belongs to the Power and shows its dedicated Memory Session model, or follows the execution Agent's default model. Maintenance policies belong to Memory Power. Main Settings has no Agent or Workspace consolidation-scope selector. Automatic background consolidation currently does not support writing User memory. By default, only explicit memories are saved; ordinary chat does not trigger automatic inference. Downcity manages User and Agent Profiles independently of the knowledge backend and injects them into context.
Main Processing records lists user-targeted Jobs in descending time order, including target=user requests initiated by different Agents. Jobs for an Agent's own memories appear in that Agent's Profile. Open a record to inspect details, changes and sources or retry a failed request. Retries retain the original target and sources.
Per-turn context
Initial system assembly or syncshot → load both Profiles → freeze with Instruction → process messages and optional tools.
User Profile applies across local Agents and Sessions; Agent Profile applies to one Agent. Identity and Instruction share one Agent system message, immediately followed by a separate Agent Profile message. User Profile is an independent system message before Session information. Both Profiles are frozen with Instruction and never enter user content. New Sessions and syncshot read the complete current Profile. Existing Sessions retain their frozen system and receive bounded turn-local reference updates when core versions change. These updates invalidate the earlier snapshot for that scope. If the current content exceeds the budget, omitted content must be read again or loaded through a full snapshot refresh. Historical preferences do not define the current task or override current requests and permissions.
Saving
{"target":"user","mode":"profile","content":"Before the main answer, remind me to speak English and briefly correct my expressions."}remember.target accepts user, agent and current_workspace. mode accepts profile or knowledge, defaulting to knowledge. Profile supports User/Agent; Workspace supports knowledge only. User writes need no login or identity callback. The Agent decides when to call tools and confirms saving only after success.
Storage and maintenance
user/user.json holds base information, user/PROFILE.md holds global agreements, and agents/<agent_id>/PROFILE.md holds Agent-specific agreements. Published scope manifests manage knowledge; search/read/list access only the current effective set. User knowledge is stored once and shared across local Agents. Profile uses separate files, scope locks and pending-operation recovery. It is outside the knowledge manifest and does not share an atomic transaction with knowledge commits.
The runtime does not automatically migrate or fall back to existing wiki files. Use the SDK-level create_memory_import_changeset helper to explicitly construct an import change set, then commit through the Provider. Confirm sources, scope and backups before importing.
Both Profile scopes use deterministic read, append and exact-edit operations. Writes carry a base version and trusted sources; replaying a request does not append it twice, and version conflicts require a fresh read. Edits require unique matches, non-overlap and preserved source markers, with a backup before content changes. To consolidate a Profile, explicitly call memory.optimize with target=user or target=agent. The Memory Coordinator submits an optimization Job to a dedicated Memory Session. Length checks help assess whether consolidation is useful and do not trigger it automatically. The Profile file service does not call models or run optimization timers.
digest, revise and optimize run asynchronously and return a Job ID. Requests made in a Session subscribe that calling Session and Turn to the eventual result, including success, no change or failure. For digest, the receiving Session is the caller, which may differ from the source Session. Feedback is injected only while the original Turn can receive it. If that Turn has ended, the result remains available in processing records; no new Turn starts automatically. Completion feedback is persisted and handled idempotently: delivery_status=delivered means injected, while delivery_status=saved means retained without injection and ends delivery. Delivery failures are retried with backoff without changing the memory commit status. Management-page requests have no chat recipient. Use processing records to check the result when needed, and avoid repeated polling or repeating a saving confirmation already delivered for that Job.
Use memory.jobs for paginated records in the current Agent and Workspace, memory.job_status for a specific request, and memory.retry to retry a failed record. Lists and status contain no source text. To inspect changes and evidence, call memory.job_detail with {"job_id":"<job_id>"}. The detail endpoint checks the current Job's Agent/Workspace scope and returns {job, changes} with the authorized source excerpts persisted for that request. Lists and status contain no source text. The processing records view shows fixed before/after content, the version read for the change and original source excerpts. Profile changes show the exact edited regions. These snapshots describe that operation, not the latest content; records without captured snapshots return an empty changes list.
Only succeeded confirms a commit; skipped means no changes were needed. Pending or failed changes shown in details do not establish that memory took effect. Within the same request scope, optimizing the same Profile version reuses a stable source identity, and digesting the same captured sources under the same extraction policy reuses the processing request. Unrelated changes to stored knowledge do not create another digest request.
There is no per-turn chat copying or automatic per-turn capture. Forgetting knowledge removes it from the current effective set and suppresses identical later submissions using exact fingerprints of normalized content; it does not guarantee suppression of semantic rephrasings. Deleting a Profile stops use of its current content. Backups, original Sessions and source-content copies in Jobs remain; these operations do not erase every historical copy. Switching service accounts does not switch local memories. Channel authorization remains the host's responsibility.
Background consolidation
Automatic background consolidation currently does not support writing User memory. User memory updates require explicit saving or maintenance operations; ordinary chat does not trigger automatic inference. Agent/Workspace background consolidation is disabled by default and configured per scope through trusted host APIs. Main Settings has no scope switches. Trusted inputs are explicitly submitted corrections, Task accept facts and revise facts with explicit feedback. Execution success and a Turn ending do not establish acceptance. Private Session history is not imported automatically. Task facts publish atomically with acceptance state and retain fixed source snapshots in an archive before Task deletion; deleting a Task does not erase every source copy.
Maintenance checks run every five minutes. Empty queues make no model calls. Each batch fixes one Agent and target with at most 4 facts, 16 sources and 32,000 characters. Each scope reserves at most 2 automatic computations per UTC day, including retries, at least 10 minutes apart. Explicit requests take priority at Job boundaries. Disabling stops new automatic computation; work already started may complete within its bounds.
Automatic results write only Agent/Workspace knowledge. Task sources remain private to the original Agent unless sharing is explicitly authorized. Profiles and User knowledge are not modified automatically. Inspect private Agent knowledge batches, errors, changes, sources and failed-job retries in that Agent's Processing records. Query Workspace batches through host APIs. Background batch retries retain the original scope's switch, cooldown, daily quota and attempt limits. Only succeeded reconciled with a commit receipt or an explicit skipped result marks input processed. Failures and quota deferrals retain input. Background work has no chat recipient, so a commit does not establish summary delivery.