Join the list →

For engineering teams building with AI

The real product of a software team is shared understanding.

AI writes the code in seconds. The reasoning behind it evaporates just as fast — and you're left shipping software no one can quite explain. Why “Myrrh”?In the phoenix myth, the bird builds its nest and funeral pyre from myrrh, and the new phoenix rises from an egg of myrrh carried out of the ashes. Myrrh was the embalmer’s resin — the substance of preservation through death and rebirth.Myrrh is what survives the fire — the understanding that persists, so the rebuilt code rises as itself, not as a stranger. The code is the phoenix; this is what it rises from.pronounced “mur” · m·y·r·r·h captures the why as you work, keeps it, and holds the next change to it.

Join the waitlist Early access · one email when it's real · leave anytime

The problem

Code is becoming a cache.

When regenerating code is cheap, the code stops being the asset and starts behaving like a cache of understanding — useful while fresh, disposable when stale. The understanding it was a cache of used to form in the heads of the people who wrote it, line by line.

Now the machine writes the lines, and that understanding never forms. The decision, the tradeoff, the reason you didn't reach for a queue — gone the moment the session closes. The diff lands. The why doesn't.

The shift

AI demands more discipline, not less.

The teams that come out ahead won't be the ones that generated the most code. They'll be the ones who kept the most understanding while doing it — who can still delete a system and rebuild it, because they know what it was supposed to do and why. That's a discipline. Disciplines deserve tools.

What you get

An honest record beats a confident fiction.

Myrrh distills your AI sessions into decision records anchored to what actually shipped. It fills in what it can prove from the code — and marks what it can't.

The gap is the point. It's the part only you can close — in your own words.

ADR-0042 accepted
Charge endpoint: synchronous with idempotency, not a queue
DECISION
Process charges synchronously behind an idempotency key. Throughput is low enough that a queue adds operational weight without buying anything.
COMMITMENTS
p99 of POST /charge < 200ms — holding · observed 142ms / 24h
retries are idempotent — unobservable · no signal yet
CONTEXT
rationale not in session — author to fill

Generated from the diff. Gaps left honest, never invented.

The loop

It holds the next session to what you decided.

Capturing the why is only half of it. The next time you — or the AI — touch that code, Myrrh brings the decision back into the room: the commitments it has to keep, the boundaries it can't cross, the questions still left open. The understanding you captured once becomes the discipline applied every time after.

So a record isn't a museum of what you decided. It's a live constraint on what gets written next — the only way the reasoning ever keeps pace with code that writes itself in seconds.

Why it's different

Captured, not chored

The why, automatically

Myrrh reads your AI coding sessions and distills the reasoning into decision records. No separate documentation task, no one nagging you to write it down after the fact.

In your repo

Living records, beside the code

Plain markdown, committed next to the code it explains. Readable by anyone, in any editor, with nothing installed. Nothing to lock into, nothing to log into.

Anchored to the diff

Faithful, never fabricated

Every record is anchored to what shipped — the diff is the source of truth, not the chat. Where the reasoning was never captured, it leaves an honest gap for you to fill. It will never invent a rationale you didn't have.

Yours by default

Awareness, not surveillance

Your raw sessions stay on your machine. Only the distilled, reviewed knowledge is ever shared — so a team can stay aware of each other's work without anyone being watched.

The rules it holds itself to

  • Numbers from code, words from the model
  • Plain markdown in git
  • Your sessions never leave your machine
  • An unfilled gap, never an invented reason
  • You can delete it all and lose nothing

Where it goes

Starts with you. Becomes how a team thinks.

It earns its place the first day you use it alone — because your own future self, three months on and having forgotten why you built it this way, is the first teammate you're writing for. Get that right and the same records serve everyone else for free.

From there it's how understanding moves through a team: a change routed to the people who depend on it, so engineers stay current without a meeting; a manager who can watch understanding form and spread — awareness, never a surveillance feed; a new hire who onboards from living records instead of tribal memory.

Already have a codebase? Myrrh draws the why out of you and marks honestly what no one remembers. It never invents a past the code can't prove.

One engineer is where you start. A team that thinks together is where it goes.