GitHub

amt · one Rust binary · CLI + MCP server

Give every repo a memory your agents can share.

Ametrite is a local-first issue tracker and wikilinked knowledge base for AI agent workflows. Think Linear + Obsidian in one SQLite file. No cloud, no accounts, no embeddings.

All install options
  • macOS · Linux · Windows
  • MIT licensed
  • 5 Rust dependencies
~/code/your-project

Two agents can never claim the same issue. Leases are atomic.

Why Ametrite

Coding agents forget everything between sessions.

Two agents working the same repo have no shared state: no backlog, no “who’s doing what”, no record of decisions already made. Ametrite gives every repo a shared workspace both humans and agents can read and write.

✕

Without it

  • Each session re-discovers the codebase from scratch
  • Two agents silently pick the same task and collide
  • Decisions live in dead chat logs nobody re-reads
  • “Why is it built this way?” has no answer on disk
✓

With Ametrite

  • A backlog that survives every context window
  • amt claim leases work atomically. No double-claims, ever
  • Decisions recorded as D-1 one backlink hop from the code they explain
  • The “why” is searchable: FTS5 + tags + a bidirectional link graph

Features

Six facets, one stone.

Everything lives in .ametrite/ametrite.db: SQLite in WAL mode, written only by the Rust engine. Git-ignored and branch-invariant: switch branches, same board.

Race-free claims

amt claim atomically leases the highest-priority open issue to one agent (BEGIN IMMEDIATE). Crashed agent? The lease expires and the issue becomes claimable again.

amt claim --agent worker-1

Knowledge that links

Issue and note bodies are markdown with [[wikilinks]] and #tags, indexed into a bidirectional link graph with backlinks. Dangling links resolve when the target appears.

amt backlinks AMT-1

Decisions are first-class

amt decide records an ADR-style decision against the issue it resolves: searchable, linkable, supersedable. The “why” is one backlink hop from the “what”.

amt decide --issue AMT-1 --title "…"

Search without embeddings

SQLite FTS5 (BM25) + tags + link graph + structured filters. No vector DB, no API keys, no drift. Your knowledge base is greppable and exact.

amt search token --type note

Everything is scriptable

Every command takes --json; amt events --follow streams activity as NDJSON. Wire it into CI, cron, or a fleet of while-loops.

amt --json claim | jq .id

One board, every workspace

The optional Bun web UI is a single kanban across every registered workspace, live-updating via SSE whenever any process writes: CLI, MCP agent, or another tab.

bun run web # :1776

The optional web UI

Watch the fleet work. Live.

bun run web serves one kanban across every registered workspace. It live-updates over SSE whenever any process writes, and it never touches the database directly: reads are SQLite, mutations shell out to amt.

localhost:1776 · board
Ametrite web UI: a kanban board with Backlog, Todo, In Progress, In Review, Done and Canceled columns. Both cards in progress carry lock chips for worker-1 and worker-2, showing live agent claims.

Real screenshots, not mockups: a demo workspace with two agents holding live claims, one recorded decision, and a note linked from the issue that cites it.

localhost:1776 · AMT-1
Issue detail for AMT-1, Fix login token refresh: urgent priority, claimed by worker-1, an activity timeline, decision D-1 recorded against it, and backlinks to that decision and the Session Tokens note.
Every claim, comment and decision an agent writes shows up here within a tick.

Built for agent fleets

Point your agents at it. They already know what to do.

amt mcp is a stdio MCP server exposing 23 tools: issues, claims, notes, decisions, dependencies, search, context bundles, stats, events, git commits. Or skip MCP entirely: every command speaks --json.

Add it to Claude Code

# register the MCP server
$ claude mcp add ametrite -- amt mcp

# the repo also ships a skill that teaches agents
# the claim loop, decision recording, and wikilink etiquette
$ ls .claude/skills/ametrite/

Or run a pure CLI loop

while id=$(amt --json claim --agent worker-1 | jq -r '.id // empty'); \
      [ -n "$id" ]; do
  amt context "$id"   # issue + decisions + backlinked docs
  # … do the work …
  amt release "$id" --agent worker-1 --status in_review \
      -m "done, see [[Session Tokens]]"
done
15 min claim lease: re-claim to renew, expires if the agent crashes
23 MCP tools over stdio: no ports, no auth, no daemon
1 file SQLite WAL: the whole workspace, git-ignored & branch-invariant

Choose honestly

Where it wins. And where it doesn’t.

Every tool below is excellent at the job it was built for. None of them were built for the job Ametrite does: letting a fleet of concurrent agents share one repo’s backlog, knowledge, and decisions without stepping on each other. That one job is the whole product.

Obsidian

your second brain

Choose Obsidian for

  • A personal, lifelong knowledge base
  • Mobile apps, sync, and a thousand plugins
  • Thinking in canvas and graph view
  • Writing for humans, by humans

Choose Ametrite for

  • A per-repo working memory agents write to
  • Atomic task claims: two agents, zero collisions
  • Issues, notes, and decisions in one link graph
  • A CLI + MCP surface agents can actually drive

Not either/or: amt export writes the workspace as an Obsidian-compatible vault, and amt import reads it back. Keep your brain; link the work.

Linear · GitHub Issues

where your team coordinates

Choose Linear or GitHub Issues for

  • Humans planning with humans: roadmaps, cycles, triage
  • Notifications, mobile, cross-team visibility
  • An ecosystem of integrations
  • Issues the whole org should see

Choose Ametrite for

  • Agent churn that would be noise in a human tracker
  • No accounts, no tokens, no rate limits to burn mid-loop
  • Millisecond local reads, so the loop never waits on a network
  • Workspaces that die with the experiment instead of polluting the backlog

These compose: humans coordinate in Linear, agents grind in amt, and the results arrive as pull requests.

A TODO.md in the repo

the default

Choose a TODO.md for

  • One agent, short sessions
  • Zero setup, zero tooling
  • Human-reviewable diffs in the PR

Choose Ametrite for

  • Two agents at once, where a flat file hands them both the same task
  • Ranked FTS5 search instead of Ctrl-F
  • Statuses, priorities, leases, dependencies, an event stream
  • History that survives the branch getting squashed

Markdown is genuinely fine until concurrency. That is the line, and it is a hard one.

Vector memory layers

mem0, Zep, RAG memory

Choose vector memory for

  • Fuzzy semantic recall: “find things that feel like this”
  • Memories that span every project and conversation
  • Recall that survives paraphrasing and synonyms
  • Mature hosted options, and self-hosting if you want it

Choose Ametrite for

  • Deterministic, auditable recall: BM25 + tags + an explicit link graph
  • No embedding step, so nothing to re-index or drift out of date
  • A knowledge base you can grep, diff, and back up as one file
  • Task state, not just memory: claims, statuses, and dependencies

amt never guesses. You trade semantic fuzz for exactness. Pair it with a RAG layer if you need both.

Install

One binary. Sixty seconds.

Prebuilt for macOS (Intel + Apple Silicon), Linux x86_64, and Windows. amt upgrade updates in place, delegating to whichever of these installed it. 

brew install Davidb3l/tap/amt

# Recent brew versions refuse third-party taps until trusted;
# if brew asks, run `brew trust Davidb3l/tap` and re-run.
curl --proto '=https' --tlsv1.2 -LsSf \
  https://github.com/Davidb3l/Ametrite/releases/latest/download/amt-installer.sh | sh
irm https://github.com/Davidb3l/Ametrite/releases/latest/download/amt-installer.ps1 | iex
cargo install --git https://github.com/Davidb3l/Ametrite amt --locked

Then, in any repo

$ amt init --name my-project --prefix AMT   # creates .ametrite/ (git-ignores itself)
$ amt issue create --title "Fix login token refresh" --priority urgent --label bug
$ amt note create --title "Session Tokens" -b "Rotation affects [[AMT-1]]. #auth"
$ amt search token