Memory and history

"Memory" covers several different things in Hubzoid: the Hub's shared knowledge, each person's private notes, the history of one conversation and the state a workflow keeps between runs. Each is stored in its own place, written by different people or processes, and shared with a different group.

Why it mattersCopy Anchor Link

Keeping these apart is what lets a whole team share one agent safely. A rule in the Hub's knowledge reaches everyone. A note Priya asks the agent to keep about how to format answers reaches only Priya. What Lee typed in one chat never appears in someone else's.

A quick exampleCopy Anchor Link

In the web app, Priya Raman writes:

Remember that I prefer answers as a table.

The agent calls save_memory and replies that it saved the note, that only Priya sees it and that Priya can change it in Settings → Memory. Every new chat Priya starts with this agent now begins with that note. Lee Okafor, using the same agent, sees no difference.

To change what the whole team's agent knows, Priya edits a file in knowledge/ instead, or, where in-app editing is on, asks the agent to remember it for the team.

How it worksCopy Anchor Link

Authored knowledgeCopy Anchor Link

Knowledge is the Hub's reference material: definitions, policies, thresholds and how your systems fit together. It lives in knowledge/ as Markdown, is reviewed like code, and changes when someone edits it. The system prompt lists each document's name and description, and the agent reads a document in full with read_knowledge(name) when it needs it.

read_knowledge and list_knowledge read the folder from disk on every call, so an edit is used by the next call without a restart. See the Hub.

Your notesCopy Anchor Link

Each person can keep one short note per agent: how they like answers, what they call things, what they work on. It is for that person only and never part of the Hub's files.

Team memory with rememberCopy Anchor Link

With it on, remember turns a correction made in chat into a proposed change to the Hub's knowledge:

Conversation historyCopy Anchor Link

The agent does not remember earlier turns by itself. Each turn hands it the conversation so far. Where that history comes from depends on the surface:

History is separate per surface and per conversation. A question asked in Slack is not visible in the web app, and one WhatsApp chat never sees another.

Workflow stateCopy Anchor Link

Scheduled work needs to remember what it has already done. That memory belongs to the workflow and to the account a run acts as, not to a conversation. See who a run acts as.

Code workflows use hub.state, a dictionary-like store in the operational database (hz_workflow_kv). Keys are scoped to the Hub, the workflow and the run's account, so two workflows never collide and the same workflow run for someone else starts empty. hub.shared_state is shared by every account that runs the workflow, so keep personal data out of it. Values are JSON, and each assignment is committed at once.

for item in low_stock:
    key = f"alerted:{item['sku']}:{item['date']}"
    if hub.state.get(key):
        continue  # already handled in an earlier run
    send_alert(item)
    hub.state[key] = True

Markdown tasks run each round in a fresh context, with no chat history. Continuity comes from a state file the task keeps for the run's account at <hub>/.hubzoid/schedule/<task>@<person>/state.json. The task's preamble tells the agent to read it first and update it after every unit of work. Each run also writes a step-by-step log to the runs/ folder beside it. See markdown tasks.

The workflow engine separately checkpoints each completed step of a run, which is what lets an interrupted run resume without repeating finished steps. That is execution state, managed by the engine, not something your code reads.

RelatedCopy Anchor Link