Skip to content
Skills Library
AI & agents · Automation

memory

/memory

The memory convention: a committed `.corgi/memory/` store of decisions, incidents, and recurring fixes that suggest, debug, stories, and review read before acting and append to afterwards. Use to read prior decisions, record a decision or an incident fix, or propose a recurring fix as a skill. Read before act, confirm before write, never secrets.

Repository
corgi ↗
Licence
MIT
Last repository change
26.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

The memory convention: a committed `.corgi/memory/` store of decisions, incidents, and recurring fixes that suggest, debug, stories, and review read before acting and append to afterwards. Use to read prior decisions, record a decision or an incident fix, or propose a recurring fix as a skill. Read before act, confirm before write, never secrets.

Original author description

The memory convention: a committed `.corgi/memory/` store of decisions, incidents, and recurring fixes that suggest, debug, stories, and review read before acting and append to afterwards. Use to read prior decisions, record a decision or an incident fix, or propose a recurring fix as a skill. Read before act, confirm before write, never secrets.

How it works

  1. Guardrails (non-negotiable)
  2. File format - one fact per file
  3. The index
  4. Read-before-act (suggest / debug / stories)
  5. Confirm-before-write (stories / review)
  6. Learned skills - detect, PROPOSE, never install
Original SKILL.md headings · 84 lines, 784 words
SKILL.md preview
---
name: memory
description: "The memory convention: a committed `.corgi/memory/` store of decisions, incidents, and recurring fixes that suggest, debug, stories, and review read before acting and append to afterwards. Use to read prior decisions, record a decision or an incident fix, or propose a recurring fix as a skill. Read before act, confirm before write, never secrets."
---

# Corgi workspace memory

A corgi workspace remembers things not in git or code: **why** a driver/port/template was chosen, how a past **incident** was fixed, **domain** facts, recurring **fixes**. Store is `.corgi/memory/` - committed, shared by the team via the repo, keyed to the `corgi-compose.yml` stack. This skill is the convention; `suggest`/`debug`/`stories`/`review` reference it.

## Guardrails (non-negotiable)

- **Opt-in.** No `.corgi/memory/` → reads skip silently (no memory is not an error); writes **offer** to create the store, never force it.
- **No secrets, ever.** Store is committed. Never write a credential, token, API key, password, connection string with a password, private hostname, or PII. Record *that* a secret exists and where it's configured ("import needs `STRIPE_KEY` in the api env"), never the value. `corgi memory lint` fails the store on a key-shaped string.
- **Confirm before write.** Drafting a fact is fine; writing it needs the user's OK (same spirit as the spec sign-off gate). One fact per durable outcome - not chatter.
- **Never auto-install a learned skill or template.** A recurring pattern produces a *proposal* a human approves; this skill never writes an executable skill or edits a plugin/template.

## File format - one fact per file

`.corgi/memory/<type>/<name>.md`, where `<type>` ∈ `decisions | incidents | domain | fixes` (the folder) and `<name>` is unique kebab-case == the filename stem:

```markdown
---
name: postgres-over-mysql
description: Chose Postgres for the main DB over MySQL - JSONB + partial indexes.
type: decision        # decision | incident | domain | fix
service: api          # optional corgi-compose service, or "stack"
created: 2026-06-08
links: ["[[billing-cycle-rules]]"]
pattern:              # fix-type only: the stable key recurrence is counted on
---

Short body. Why, not what. Reference related facts with [[their-name]].
```

- `description` is the one line the index shows and a reader sees first - make it carry the fact.
- `[[name]]` links form the **memory graph**; a link to a missing fact is a lint warning.
- `type` must match the folder. `fix` facts add `pattern:` (the recurrence key).

## The index

`.corgi/memory/index.md` is **generated** (`corgi memory index`) - never hand-edit it. Lists every fact's name + description by type. **Read the index first** (cheap), then open only the 1-3 fact files whose description matches your task. Don't dump the whole store into context.

## Read-before-act (suggest / debug / stories)

If `.corgi/memory/` exists, before acting:
1. `corgi memory list --json` (or read `index.md`) - scan descriptions.
2. Open only the matching facts.
3. Use them: **suggest** - don't propose what a `decision` rejected; cite a `domain` fact / past `incident` as evidence. **debug** - check `incidents/` for "seen this before?" and reuse the recorded fix. **stories** - honor `decision` constraints, reuse an `incident` fix for a regression, ground a free-text feature in `domain`.

## Confirm-before-write (stories / review)

After a notable, durable outcome, draft a fact and **show it for confirmation**:
- **stories** - a non-obvious bug root cause that could recur → `incident` (+ a `fix` with a `pattern:` if it's a code-level pattern); a cross-service contract choice → `decision`.
- **review** - a reviewer thread that settles a durable convention (Mode B, after the thread resolves) → `decision`.

On OK: `corgi memory add --type <t> --name <slug> --desc "<one line>" [--service <s>] [--pattern <key>]` scaffolds the file, then `corgi memory index` refreshes the index, then run `corgi memory lint` (must pass - catches secrets / broken links). Commit the new fact with the related change. No `.corgi/memory/` yet → offer to create it (`corgi memory add` creates the dir on first use); declined → skip, don't block.

## Learned skills - detect, PROPOSE, never install

After writing a `fix` fact, check recurrence:
1. `corgi memory list --type fix --json` → count by `pattern`.
2. A `pattern` seen **≥ 3 times** (default threshold) is a learned-skill candidate.
3. Write a **proposal** to `.corgi/memory/proposals/<date>-<pattern>.md`:

```markdown
---
name: retry-on-429
kind: skill        # skill | template
count: 3
sources: ["[[retry-on-429-billing]]", "[[retry-on-429-search]]", "[[retry-on-429-webhook]]"]
created: 2026-06-08
---

## Recurring pattern
We've added the same exponential-backoff-on-429 wrapper in 3 services (links above).

## Proposed remedy
A project skill `retry-on-429` (or a corgi template) that documents/scaffolds the
shared backoff helper so the next service reuses it instead of re-deriving it.

## Approval (human ticks to accept - nothing auto-installs)
- [ ] This pattern is real and worth standardizing
- [ ] Author it as a: ( ) project skill  ( ) corgi template
- [ ] Owner: ____   Target repo/path: ____
```

4. **Stop there.** Print the proposal path. Do **not** create a skill file, edit the plugin, or add a template - a human approves and authors it as a separate explicit task. Proposals are committed so the team sees the candidate.

Versions

RepositoryScoreLicence
This page · andriiklymiuk/corgi100MIT
rjmurillo/ai-agents100MIT
rjmurillo/ai-agents100MIT
topoteretes/cognee-integrations100Apache-2.0
topoteretes/cognee-integrations100Apache-2.0
topoteretes/cognee-integrations100Apache-2.0
thebtf/engram100MIT
stxrmik/antigravity-plus100MIT
boshu2/agentops100Apache-2.0

Database snapshot: 13.11.2026 · package version 728dd6d15479 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100setup
    Use when the user wants corgi set up end to end: \"set up corgi for me\", \"I just installed corgi, what now\", \"get corgi agent running\", \"connect my phone, Telegram, menu bar\", \"connect Jira, Linear, GitHub to corgi\", \"onboard me to corgi\". Runs every step a program…
  • 100budget
    Use when the user asks "how much budget do I have", "can I start another task", "when does the limit reset". Reads `corgi agent usage --json`, answers in numbers, suggests `corgi agent carry` when a limit is near.
  • 100causal-memory
    Causal memory for agents — install/setup the causal-memory MCP server, then record decisions/outcomes and recall them before acting. Trigger when the user asks to install or set up causal-memory/agent memory, when causal-memory MCP tools are available and the agent faces a…
  • 100causal-memory
    Causal memory for agents — install/setup the causal-memory MCP server, then record decisions/outcomes and recall them before acting. Trigger when the user asks to install or set up causal-memory/agent memory, when causal-memory MCP tools are available and the agent faces a…
  • 100role-memory
    Per-role persistent memory for agents — durable curated facts, preferences, and decisions plus an append-only episodic daily log, stored as plain markdown under `.agents/memory/<role>/`. Invoke when the user says "remember this", says "log this", or asks "what did you learn…
  • 100agent-memory-discipline
    Teaches when to recall from long-term memory before acting and when to save durable decisions, corrections and failures afterwards. Use when a memory tool or MCP memory server is connected but the agent is not using it consistently, when the user complains that the assistant…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.