Skip to main content
Memory is what a skill remembers as the conversation unfolds: the selected card, the reason for a replacement, whether the user is authenticated. Tools write to it, the framework checks it, and instructions branch on it.

​
Everything must be declared

A memory entry has to exist in a schema before anything can write to it. A tool that writes an undeclared key fails rasa train with undeclared_memory_write.
skills/card_replace/memory.yml
The top-level key is schema:, not memory:.
  • public values are readable by every other skill.
  • private values stay internal to this skill.
Once declared, a tool writes with a bare entry name; the active skill decides the namespace:

​
Who is allowed to write

Three different actors write memory, and they’re governed separately:
  • Tools write whatever the skill declares, via context.memory.set().
  • The LLM may only write entries flagged llm_settable: true, or entries owned by a collect: step. It does so through the built-in set_fields tool.
  • Static set: buttons write a declared field on tap as an engine write (llm_settable is not required). See Static buttons.
That flag matters. Mark the customer’s decisions settable, such as the replacement reason or the shipping choice. Leave engine-derived values such as eligibility results, lock state, and computed flags unflagged, so the model can neither invent them nor “correct” them later. The LLM never writes project memory. Those fields are filled by a tool, a memory validation tool, session-start metadata on fields marked seed: true, or a set:session.project.<entry>=… button tap, then locked for the rest of the session. See the memory.yml reference.

​
Sharing between skills

Values shared across skills go in a project-level memory.yml at the agent root. It is a flat map of entry name to attributes:
memory.yml
These live in the project. namespace. This is how a skill depends on authentication without depending on the authentication skill:
Bind that name in agent.yml with satisfied_when: session.project.authenticated. The only contract between the two skills is the key. Put session-wide facts in project memory; keep collectable labels and working state on the skill. The engine refuses a second write to a set project field. Skill public and private are working state for the current run. They stay after complete or cancel so other skills can still read leftover public, and they reset when that same skill starts again. Put facts that must last the whole conversation in project memory.

​
Branching on memory

A categorical value can drive scoped instructions, so the LLM only ever sees the relevant branch:
Conditions always use the three-segment namespaced form, session.<skill_id>.<entry> or session.project.<entry>. See Conditions. To put a live value into instruction prose itself, use @memory.… — see skill.md.

​
Tracker events

When Mantle persists a write, the tracker records memory_set (with the key and value) or memory_cleared (key only). See Tracker events.

​
Reference

For every field attribute, the full type list, visibility rules, and naming, see the memory.yml reference.