Serge Shima / Work and projects
autograph
Schema-as-code memory for AI agents in Obsidian: typed cards, entity dedup, link repair, update-in-place, and Ebbinghaus decay. Plain Markdown you own — a Claude Code skill.
From the project documentation
autograph
**Schema-as-code memory for AI agents that write to an Obsidian vault.**
One `schema.json` keeps the vault typed, linked, deduplicated, and decaying — automatically.
[](https://skills.sh/smixs/autograph)
[](https://code.claude.com/docs/en/plugins)
[](./skills/autograph/tests)
[](./LICENSE)
English · Русский
---
**autograph** is a memory engine for Obsidian vaults that AI agents write to. You define the taxonomy once in `schema.json` — card types, folders, allowed statuses, how fast each kind of knowledge decays. From there the engine places new cards, repairs wiki-links, merges duplicate entities, forgets what you stopped touching, and scores the vault's health. It's plain Markdown you own, not a hosted database — the same files stay a human-readable second brain. The scripts are Python with PyYAML for validated metadata, 299 tests.
The problem it solves: an always-on agent drops notes into your vault every day — voice transcripts, meetings, contacts, ideas. A month later you have 800 files, broken links, three cards for the same person, and no one remembers if `status: ongoing` means `status: active`. autograph is the layer that keeps that in order without you babysitting it.
Install
One command installs autograph into whichever agent you run — it picks the right directory automatically:
This uses skills.sh, the open Agent Skills registry. Works with Claude Code, Codex, Cursor, OpenClaw, Hermes, and 70+ others.
**Claude Code as a plugin** (read-only, always current):
Or from your shell: `claude plugin marketplace add smixs/autograph && claude plugin install autograph@autograph`.
Quickstart
Full 10-phase bootstrap (discover → schema → enforce → dedup → link → MOC → verify) lives in `bootstrap-workflow.md`.
What makes it different
- **Your files, your format.** Memory is Markdown in your own vault — no API, no vendor database, no lock-in. Open it in Obsidian, grep it, back it up with git.
- **Updates in place, doesn't duplicate.** New fact contradicts an old one (job changed, project renamed)? autograph rewrites the current value and moves the old one to an append-only `## History` line — it doesn't leave you two conflicting cards. Same entity under two filenames gets merged by identity, not just by exact name match.
- **Forgets on purpose.** An Ebbinghaus decay model demotes cards you stopped touching, so the working set stays small and the important cards stay warm.
- **Schema-as-code, zero hardcoded domains.** Every type, folder, status, and decay rate reads from `schema.json`. The same file drives every agent writing to the vault.
**What it doesn't do:** it won't invent structure you didn't describe, and it doesn't run an embeddings server — search is BM25 + link-graph reranking over the raw Markdown (hybrid dense search is opt-in).
Built for the scale where idea files break
Andrej Karpathy's llm-wiki nailed the framing: an LLM should *compile* knowledge into living Markdown pages, not re-derive it from a vector store on every query. autograph is built on the same three layers — raw sources, LLM-written pages, a schema of conventions — with one difference that decides everything as the vault grows: **the conventions are code, not prose.**
The gist draws its own line: index-first navigation "works surprisingly well at moderate scale (~100 sources, ~hundreds of pages)." Past that line, prose conventions drift between sessions, the same entity accretes under two names, contradictions pile up flagged-but-unresolved, and stale pages never leave. autograph is the engine for the other side of that line:
- **There, `lint` is a prompt you remember to run. Here it's cycles the system runs** — enforce, dedup, decay, health score — backed by 299 tests that hold the schema even on the model's off day.
- **Contradictions get resolved, not just noted.** "New data contradicts an old claim" becomes update-in-place supersede with provenance: the current value is rewritten, the old value moves to an append-only `## History` line.
- **The same entity under two filenames merges by identity** — email, handle, phone — not by hoping the model cross-references it.
- **Nothing accumulates forever.** Ebbinghaus decay demotes what you stopped touching, so the working set stays legible at ten thousand notes, not just a few hundred.
Karpathy answered *who* maintains the wiki — the LLM. autograph answers whether that maintenance is *correct*.
autograph vs hosted agent memory
| autograph | mem0 / Letta | basic-memory |
---|---|---|---|
Storage | Markdown in your Obsidian vault | Hosted DB / vector store | Local Markdown (MCP) |
Ownership | Files you own, git-friendly | Vendor service | Local files |
Typed schema + decay | Yes (schema-as-code, Ebbinghaus) | Partial | No |
Dedup + link repair + health score | Yes | No | No |
Runtime | Any agent (skills.sh) | SDK / API | MCP clients |
External deps | PyYAML (resolved by uv) | Cloud account | MCP server |
Use cases
Scenario | Commands | Why |
---|---|---|
**Audit someone's vault** | `discover.py` → `graph.py health` → `enforce.py --check` | Inspect links and metadata before preparing a scoped repair |
**Bootstrap an empty or chaotic vault** | `/autograph:research ` | Q&A + explorer-agent swarm → schema draft → your approval |
**Record a card that stays linked** | Workflow 3 in `SKILL.md`: dedup-first → type → `## Related` (hub + 2 siblings) → `touch` | The skill won't finish until the card is linked — orphans are dead knowledge |
**A fact changed** | dedup-first lookup → SUPERSEDE: rewrite the value, old one → `## History` | One card per subject, with an audit trail, instead of a duplicate |
**Import from a CRM / export** | `engine.py init` → `enforce.py --apply` → `enrich.py tags --apply` | HubSpot / Notion / Apple Notes exports become native cards |
**Resurface forgotten notes** | `engine.py creative 5 ` + cron | The oldest cards drift back into `warm` for review |
How decay works
Ebbinghaus-style memory, all knobs in `schema.decay`.
1. Access count (spacing effect)
Each `touch` increments `access_count`. More retrievals slow forgetting:
A card touched 5 times decays ~2.6× slower than one touched once.
About the author
Serge Shima is co-founder and CTO of Majento in Tashkent and founder of Aimasters. He builds AI products and open-source tools for agents.