How do I install the Forgetful Entities skill?

Run npx skillmds@latest add scottrbk/forgetful-entities in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

Is Forgetful Entities safe to use?

This skill has not completed SkillMD's automated safety review yet. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Forgetful Entities?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Forgetful Entities free to use?

Yes. Installing skills from SkillMD is free. This skill is licensed under MIT.

Who published Forgetful Entities?

scottrbk (@scottrbk) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Forgetful Entities by scottrbk — Agent Skill

Name: Forgetful Entities
Author: scottrbk

Forgetful Entities

Model the things knowledge attaches to — people, organisations, devices, products, system components. Use when a new thing surfaces that memories will reference, when relationships between things need recording (owns, depends on, part of), or when another skill routes a pointable thing here. Litmus: an entity is a noun you could point at; knowledge about it stays a memory.

scottrbk c627f7b 3.0 KB Updated Sep 17, 2026

File contents

Modelling entities in Forgetful

Entities are the graph's nouns. Model the thing once, then let knowledge accrue to it through links — that is what makes get_entity_memories a useful reverse lookup later.

Invoking operations

Operations are named by registry name (create_entity, link_entity_to_memory, ...). Invoke via whichever surface this agent has:

MCP: execute_forgetful_tool(tool_name="create_entity", arguments={...})
CLI: forgetful call create_entity --args '{"name": "..."}' --json

Get any operation's schema at runtime: how_to_use_forgetful_tool (MCP) or forgetful tools info <operation> (CLI) — schemas are deliberately not repeated here.

Step 1 — Apply the litmus, then dedupe

Can you point at it? "Sarah Chen" is an entity; "Sarah is great at debugging async issues" is a memory linked to her. The fact stays a memory (forgetful-remember); the thing it is about becomes the entity.

Before creating, search_entities for the thing under its likely names — it matches both name and aka. Set aka at creation time for any alternative names the thing goes by, so a later dedupe search under a different name still finds it.

Done when: the thing either already exists (use it) or is confirmed new.

Step 2 — Create with a type

create_entity with a name and type: Organization, Individual, Team, Device, System, or Other (custom_type required when Other). Stored Title-case; matched case-insensitively on input. Check list_entities for the types already in use and match them — a graph where servers are sometimes typed "Device" and sometimes "System" fragments reverse lookups.

Done when: the entity exists once, typed consistently with the existing graph.

Step 3 — Link knowledge and projects as they accrue

link_entity_to_memory whenever a memory is about the entity — done at capture time, this is one line; done later, it is an archaeology project.
link_entity_to_project when the entity belongs to a project's world.

Done when: knowledge about the thing is reachable from the thing (get_entity_memories).

Step 4 — Record relationships between entities

create_entity_relationship with a direction and a type. Keep the vocabulary small and consistent — owns, depends_on, part_of, uses, created_by cover most structure. Check get_entity_relationships on either entity first and reuse the types already in the graph before coining new ones. Direction carries meaning: A depends_on B is a statement about A.

Done when: the relationships that answer real questions (impact, structure, responsibility) are recorded, and none duplicate an existing edge.

---name: forgetful-entitiesdescription: Model the things knowledge attaches to — people, organisations, devices, products, system components. Use when a new thing surfaces that memories will reference, when relationships between things need recording (owns, depends on, part of), or when another skill routes a pointable thing here. Litmus: an entity is a noun you could point at; knowledge about it stays a memory.license: MIT---# Modelling entities in ForgetfulEntities are the graph's nouns. Model the thing once, then let knowledge accrue to itthrough links — that is what makes `get_entity_memories` a useful reverse lookup later.## Invoking operationsOperations are named by registry name (`create_entity`, `link_entity_to_memory`, ...).Invoke via whichever surface this agent has:- **MCP**: `execute_forgetful_tool(tool_name="create_entity", arguments={...})`- **CLI**: `forgetful call create_entity --args '{"name": "..."}' --json`Get any operation's schema at runtime: `how_to_use_forgetful_tool` (MCP) or`forgetful tools info <operation>` (CLI) — schemas are deliberately not repeated here.## Step 1 — Apply the litmus, then dedupeCan you point at it? "Sarah Chen" is an entity; "Sarah is great at debugging async issues"is a memory linked to her. The fact stays a memory (`forgetful-remember`); the thing it isabout becomes the entity.Before creating, `search_entities` for the thing under its likely names — it matches both`name` and `aka`. Set `aka` at creation time for any alternative names the thing goes by, soa later dedupe search under a different name still finds it.Done when: the thing either already exists (use it) or is confirmed new.## Step 2 — Create with a type`create_entity` with a name and type: Organization, Individual, Team, Device, System, orOther (`custom_type` required when Other). Stored Title-case; matched case-insensitively oninput. Check `list_entities` for the types already in use and match them — a graph whereservers are sometimes typed "Device" and sometimes "System" fragments reverse lookups.Done when: the entity exists once, typed consistently with the existing graph.## Step 3 — Link knowledge and projects as they accrue- `link_entity_to_memory` whenever a memory is *about* the entity — done at capture time, this is one line; done later, it is an archaeology project.- `link_entity_to_project` when the entity belongs to a project's world.Done when: knowledge about the thing is reachable from the thing (`get_entity_memories`).## Step 4 — Record relationships between entities`create_entity_relationship` with a direction and a type. Keep the vocabulary small andconsistent — `owns`, `depends_on`, `part_of`, `uses`, `created_by` cover most structure.Check `get_entity_relationships` on either entity first and reuse the types already in thegraph before coining new ones. Direction carries meaning: A `depends_on` B is a statementabout A.Done when: the relationships that answer real questions (impact, structure, responsibility)are recorded, and none duplicate an existing edge.

Frequently asked questions