Skills

Everything that needs judgment is written down as a skill, so the model your host is already running does that thinking, which is why Memoose ships no model of its own.

A skill is loaded by the host when its description matches what is happening; you do not invoke them by hand. Each one pairs with the tools it drives: the tools stay deterministic and refuse bad input, the skill supplies the judgment the tools deliberately do not have.

Skill	Teaches the host model	Loads when
`memoose`	When to recall, how to extract entities, relations, evidence and summaries, how to store a procedure, and how to shape the ontology.	You say remember or recall, ask “what did we decide”, refer to people, systems, decisions or dates from earlier work, or the agent learns a durable fact.
`memoose-onboard`	Check what works on this host, install what is missing, then fill the project’s memory from its docs and history, in a session, on every project. Also the switches and what is stored.	Just after installing, on any project whose memory is empty or stale, or when automatic memory is not behaving and you want to know why.
`memoose-upkeep`	Judging what the store surfaces: hotspots and contradictions (`supersede` over `mark_contradiction`), duplicates, connections, stale summaries, and dismissing what was judged.	`remember` warns, recall shows a contested fact, you say a fact is wrong, you ask to clean up memory, or a session start says upkeep is due.

The extraction rules, in short

The memoose skill is the one that runs most, and it is worth knowing what it asks the model to do, because it is what makes recall worth reading months later:

describe_ontology once per session, so writes use existing types and the snake_case relation convention.
recall the names involved before writing, so existing entity names get reused instead of spawning near-duplicates, and so conflicts are noticed before they are stored.
remember with entities carrying their most complete name, a type, and one or two sentences; relations as source --relation--> target with a one-sentence description that repeats the endpoint names.
Every relation gets an evidence pointer: a file range like repo://src/auth.py#L40-L82, a URL, an issue id, or user said <date>. Set valid_from when the source says since when something is true.

What to store: decisions and their reasons, ownership, how systems relate, conventions and constraints, preferences you state, dates things happened, and problems and their fixes. What not to store: transient task state, what a file currently contains, and anything the model is unsure of. Facts about you rather than the project go to the user dataset.

The memory-keeper subagent

Skills also cover the case where a host has no hooks: instead of spending your main model's turns on bookkeeping, they tell the agent to hand the work to memory-keeper, a subagent that runs on a small model (Haiku by default), holds only the Memoose tools, and replies with one short line when it is done. It stores what a conversation taught, and it runs maintenance: distilling a session into lessons, cross-connecting entities, consolidating duplicates, refreshing summaries.

The point is that bookkeeping runs on a small model and off the main conversation's turns. On a host that runs plugin hooks the delegation happens on its own; elsewhere the skills still route it there when there is something worth storing.