Memory and skills
What kanman and your team know beyond the code, and the procedures kanman follows: every entry names its sources, shows how current it is and who changed it.
Every team knows things the code does not say: why a decision was made, which conventions hold, who to ask about billing, what went wrong last time. kanman keeps this knowledge with the team, together with the procedures it follows for recurring work. You see every entry, where it comes from and whether it is still true, and you can change it.
Where to find it
Open the team and click the Team tab (/<workspace>/teams/<team>/team/memory). The tab opens on Memory and skills, the first page of its list. The page has three cards, Memory, Skills and Repos, and below them Import from a repository.
Memory
Memory holds what kanman and the team know beyond the code: decisions, conventions, who to ask and lessons learned. kanman reads it whenever it works on the team, so a decision made in one story is known in the next.
kanman writes down what it learns as it works. You can add what it should know with Add entry: a short name, what the entry is for, and the text (Markdown). Keep it short and true, and link what the code says instead of copying it.
Skills
Skills are procedures kanman follows, for example fixing a red pipeline or rolling out a dependency bump. When kanman does the same kind of work twice, it turns what it did into a skill, so the next time it follows the steps instead of searching for them again. Add your own with Add skill.
Ready-made skills come from kanman’s library, and a team can share its skills with the other teams: see Skills library and sharing.
Load by path
Some knowledge only matters for part of the code: the error format of the API, the rules for database migrations. Give such an entry or skill one or more paths under Load by path, for example src/api/**, *.sql or db/. Then kanman uses it only when it works on matching files of a repository, and other work stays free of it. Entries without a path are always available.
The paths show as chips on the entry (Loads for src/api/**). Change them with Edit: type a path and press Enter or Add path; the ✕ on a chip removes it. A path is written relative to the repository: ** stands for any folders, * for any part of a name, and a path without a slash, such as *.sql, matches that file name in every folder. kanman can set paths on the entries it writes too. Repository pages always belong to their repository and have no paths.
Repos
Repos holds one page per repository of the team: what the repository is, how it builds and tests, and its quirks. kanman writes a repository’s page after it has worked in it and keeps it true when it changes the repository. When you ask kanman about the code, it starts from these pages and then searches the code itself.
Each page shows:
- the repository and what it is for,
- As of a commit, linked to that commit on your code host: the version of the code the page was checked against,
- who verified it and when,
- the files it describes, as source chips.
Open a page to read it; Edit, Still true and Delete work as for every entry. A page links to the files it describes instead of copying code. When one of those files changes on the main branch, the page is marked To re-check and kanman checks it the next time it works on that repository. Repositories without a page yet are listed below the pages.
Sources
Every entry names its sources, shown as chips that link to them:
| Source | Example |
|---|---|
| File in a repository | A path in one of the team’s repositories, at a commit |
| Story | A story key, such as INT-12 |
| Merge request | A merge or pull request of one of the team’s repositories |
| Person | Who said it |
| CI run | A pipeline run, with its date |
When you add or edit an entry, Add source adds one more; the ✕ on a chip removes it.
How current an entry is
A badge on every entry says whether kanman can rely on it:
| Badge | Meaning |
|---|---|
| Current | Its sources have not changed since it was last checked. |
| To re-check | A source changed since it was checked, and the entry says why: the file changed on the main branch, or the story or merge request was edited. |
| Stale | Nobody checked it for two weeks. kanman no longer uses it until someone confirms or rewrites it. |
Nothing stale is shown as current. When you know an entry still holds, click Still true and it is current again.
Who changes what
Each entry shows who changed it last and when: kanman or a person. Owners, admins and members can add, open, edit, mark Still true or delete entries; viewers can read them.
A person’s text stands. kanman changes an entry a person wrote only once one of its sources has changed. Delete removes an entry, and kanman no longer uses it. Every change, by kanman or a person, appears in the team’s activity log.
Import from a repository
Many repositories already contain skills and instructions for coding agents. Import from a repository brings them in:
- Pick one of the team’s repositories, or all of them.
- Click Ask kanman to import.
kanman reads the repository’s skills and instructions (.claude/skills, AGENTS.md, CLAUDE.md) in its next turn and keeps what the code cannot say, each entry with the file as its source. The entries appear on the page as kanman writes them. Because the file is the source, an entry is marked To re-check when the file changes on the main branch.
Limits
| What | Up to |
|---|---|
| One memory entry | 4,000 characters |
| One skill | 16,000 characters |
| Paths of one entry or skill | 10 |
| A team’s memory and skills together | 80,000 characters or 200 entries |
| One repository page | 8,000 characters |
| Repository pages of a team | 300 (they do not count toward the memory and skills limit) |
Credentials in an entry are removed automatically before it is saved.
The former conventions
Memory and skills replace the conventions kanman used to learn and the Conventions card on the team’s Knowledge page. Conventions and approaches kanman learned earlier were imported into Memory and skills, marked To re-check, so you can confirm or rewrite them. Old links to conventions open this page. The Knowledge page now holds the team’s sources and connectors, see Team context and connectors.
What is not stored
Memory and skills hold short notes and procedures, with links to their sources, not copies of your code. They belong to the team and are deleted with it. See Retention and deletion.
Related
Last updated: January 1, 0001
Open kanman