Skip to Content

Agents

Memories

Write down what agents should know about a project, and choose which notes every agent turn reads first.

A memory is a note for agents, not for people: a coding rule, a library choice, how to run the tests. Requirements, scope, and acceptance criteria go in a doc. Guidance meant to steer the build goes in a memory, even when it’s a long report.

Open Memories under the project in the sidebar. Every memory belongs to one project and reaches only that project’s agent turns. A rule meant for several projects is cloned into each.

Write a memory

  1. Press New memory and pick the Project.
  2. Give it a Title and a one-line When to use, such as “writing React code”. Agents decide whether to read a memory from this line, so make it specific.
  3. Switch on Always included if every agent turn in the project should read it.
  4. Write the body and save.

To edit one, open it, change the title, When to use line, or body, and press Save at the top right. A memory isn’t edited live like a doc: every save that changes the title, When to use line, body or Always included adds a version under Versions, beside the body on a wide window and under it on a narrow one.

The line under an open memory’s title holds its two settings, which save as soon as you change them: its folder (Main or Footer, see below) and Always included. The same switch sits on each row of the list.

History

A memory keeps its last 10 versions, and a save that changes nothing adds none. Pick a version under Versions to open the same History dialog a doc has: the text as it read next to the list of versions, each compared word by word with the one before it, with Restore naming the picked version’s time. Restoring saves that version again as the newest, so nothing in the list is rewritten. It needs memories:write, and anyone who can read the memory can open the dialog.

How agents find memories

An agent turn never carries a memory’s text. It names memories for the agent to read:

  • Required memories (the switch on each row) are named in every agent turn in the project, after the interview memory, which always comes first.
  • A play’s run dialog lets you add more for that run.
  • The agent finds the rest itself by their When to use line.
  • A plain chat with no ticket or doc names no memories.

Because only names travel, a long memory never stops a turn.

A run’s trail lists the memories it found and read itself under Read by itself, apart from the ones it was told to read; one deleted since keeps its name there, without a link. Each memory says when a run last read it, on its row and on its page, or on its page that no run has yet. That is how you tell a When to use line that works from one no run ever opens.

Every computer’s setup installs the nexul-memory skill (and nexul-triage, which files bugs in Nexul itself), which tells agents how to look memories up and when to write or update one. Agents may write memories too; every save keeps its author.

Default memories

Memories are a project’s skills, so a new project starts with five, one for each step of the work:

MemoryWhat it holds
Writing a docwhat a doc proposing a feature says before it is cut into tickets
Writing ticketshow to file a ticket someone else could build and prove done
Building a tickethow to build one: read it whole, reproduce a bug, test first, prove it, open the pull request
Reviewing a changehow to review a pull request against its ticket and the project’s rules, with proof for each finding
Finishing a ticketalways included, in Footer: whether to merge, the note to post, and which column the ticket moves to

From then on they are ordinary memories: edit, delete or replace them like any other, and nothing rewrites them later. A project made before they existed got them only if it had no memories of its own.

What a new project starts with is the instance’s to change, under Memories in Settings → Templates (see below). Each is written as a SKILL.md: frontmatter with name (the title), description (the When to use line) and, optionally, always_included and footer, set to true or false, then the body in markdown. New default memory adds one of the instance’s own, which Delete removes again; the five that ship reset instead.

The list has two folders. Main holds everyday memories. Footer holds memories that conclude a play run: the agent reads them once the work is done, for example to decide which column the ticket belongs in now. Move a memory between them with the folder under its title, or Move to in its right-click menu. A play’s run dialog lists footer memories in their own section.

Clone or delete

Clone in the right-click menu, or Clone to… in an open memory’s … menu, copies it into another project in any workspace you belong to. The copy is independent from then on. Delete, in the same menus, removes it.

The decisions log

A project can have a decisions log: a memory listing only the tickets that changed how the project works, such as a new pattern, a dropped library, or a reversed decision. Each entry is at most three lines: the date and the decision, Why: in one line, and a link to the ticket. When a later decision reverses an entry, the old one is marked (superseded by <ticket>).

The decisions check writes it as tickets reach Done. You can edit it like any memory. It is never always included, so its row and its page show a lock instead of the switch; agents look it up when they need the why. The interview memory shows the same lock, because it is always included.

Templates

Some text starts each workspace or project off: the interview questions, how a ticket mention chip looks, each built-in play’s instructions, each default ticket type’s body template, and each default memory. Each has an instance version every new workspace and project starts from. Two more, the Intro and Footer that open and close every agent prompt, live only at the instance.

Edit the instance’s in Settings → Templates, under Instance settings, with templates:write. Each opens in its editor with Save, Reset to default, and Clone to….

TemplateWhere a workspace or project edits itFollows instance changes?
InterviewConfiguration → Interview templateyes, until edited
Mention chipConfiguration → Mention chipsyes, until edited
Play instructionseach built-in play in Playsno, copied when the workspace is made
Ticket bodya ticket type in project settingsno, copied when the project is made
Default memoriesthe project’s Memoriesno, copied when the project is made

A mention chip’s format is built from the fields {ticket.Project}, {ticket.Ticket}, {ticket.Status}, {ticket.Type}, {ticket.Developer} and {ticket.Due}, added with the + buttons under it. Fields with only a space between them show with a · between, as in ATL-12 · Fix login redirect loop · In progress, and a field with no value is left out with its dot; any other text you type between fields shows as typed.

A copied template shows whether it matches or differs from the instance’s, with Reset to instance template when it differs. Clone to… copies a template over another of the same kind, at the instance, a workspace, or a project, and asks before overwriting one with its own text. A built-in play lands on that workspace’s copy of it under whatever name it has there, so cloning Fix with AI into a workspace that renamed it to Implement with AI replaces the instructions of Implement with AI.

Permissions

memories:read, memories:write, memories:delete, and memories:clone, each checked on the memory’s project. Cloning also needs memories:write on the project it lands in. Agents use the same permissions through memory_list, memory_get, memory_create, memory_update, and memory_delete.

Edit this page