Bijalog — a decision log for working with AI

Public overview, v3 — 2026-09-10. Licensed MIT, same as the code.

The problem

AI is extraordinarily capable and completely forgetful.

Every conversation starts empty. The reasoning behind a design change, the experiment that failed, the convention you agreed three months ago — none of it survives unless you type it again. Most people solve this by repeating themselves. Some paste in ever-longer summaries. Both are the same tax, charged daily.

Bijalog takes the other route: write each real decision down once, as a line of plain text you own.

Do you actually need this?

Maybe not. If you have one project and a few months, your AI's built-in project feature plus a text file is enough — ask it to summarise at the end, keep what's right, paste it in next time. That is, roughly, level one of this system, and many people never need more.

Bijalog earns its keep past a threshold: when the history outlives the tool, the session, or your patience for re-explaining. Three signs you've crossed it. You're working with more than one AI and each has a different memory of the project. You've been going long enough that the summaries have started quietly dropping things. Or you've been surprised by a decision you'd already made and forgotten.

What the summary approach gives you is the AI's opinion of what mattered, written at the end, from whatever it still holds. What Bijalog gives you is your decision, written at the moment, with the reason attached — and a record of what you refused. Below the threshold that difference is a luxury. Above it, it's the whole point.

What it is

A decision log. One line per decision, in a file on your own machine.

2026-08-27 14:06 | 01M12H1F80… | ACTIVE | topic:opening | Start the film on her hands, not the aerial shot — scale isn't the story, she is.

Five fields: when, a permanent ID, its status, tags, and the decision itself in plain language. That is the entire format. Any AI can read it. So can you, in twenty years, without the software that made it.

Five principles hold it together:

• Local-first. It lives on your hardware. No database, no account, no vendor.

• Plain text. Readable by humans, parsable by machines, versionable, future-proof.

• Append-only. Nothing is edited or deleted. A change of mind is a new line that supersedes the old one, and the old one stays visible.

• Human-approved. The AI proposes. You decide. Nothing becomes canon without you.

• AI-agnostic. Any model, this year or next. The format outlives the tools.

How it differs from the alternatives

Built-in chat memory is automatic and effortless, but it's written by the model rather than by you, it lives on the provider's servers in their format, and it can't be diffed, cited or moved. You end up renting your project history from whichever company made the model.

Agent memory layers — Mem0, Zep, Letta and their peers — are infrastructure for developers building AI products, and they're good at it. But they store what the agent experienced, extracting facts automatically, so nothing was ever approved by anyone. Their own analysts name the gap: vector memory is good at recall, but it doesn't give you review, audit, or rollback.

Note apps you genuinely own, and they're excellent — but a note is not a decision. Nothing marks what's current, what was superseded, or what was approved. An AI reading your notes finds prose to interpret rather than rulings to follow.

Version control records how files changed, not what you decided or why. Complementary, not competing — use both.

Decision records are the honest ancestor: software teams have kept one document per decision, with context and status, for over a decade. Bijalog is that practice compressed to a single line, generalised past software, and pointed at an AI as the primary reader.

The short version: most alternatives are memory for a machine, assembled automatically, held by a vendor. Bijalog is a record by a person, approved deliberately, held by you — and readable by whichever machine you choose next.

And where it's the wrong tool. Building a product that personalises for thousands of users? You want a memory API, not a text file. Searching a large body of source material by meaning? That's a vector database. Want memory that requires no habit at all? Use the built-in kind and accept its terms. Bijalog assumes a person who wants to decide what gets remembered, and will spend five minutes a day doing it.

History and current state

A log that never deletes is a history, and histories contradict themselves — an early line naming one approach, a later line replacing it. Both are true as history. Neither alone answers "so what do we do?"

That answer is computed, not stored: the newest live decision on each topic, minus anything a later line superseded. One command returns it. A daily run does the same across every project.

This is the same trick accounting has used for centuries. A ledger records every transaction; your balance is derived from them, never stored. Or, if you make films: the log is every take you ever shot, and the current state is the cut.

It also answers the obvious worry — won't this get huge? The history grows forever, but what an AI actually reads is the current state, which stays roughly the same size whether you've been going one year or ten.

The gate

The AI drafts a decision and the reason inside it. You approve by leaving it alone.

Which means something worth knowing: when you say nothing, the reason on the record is the AI's reason. Usually fine. Two moments deserve a sentence from you.

When you agree for a different reason than the one written. "Yes — but not because it's faster. Because it's reversible." That clause is worth more than the decision itself. It's the part that ages into judgement.

When you say no. An approval leaves a line behind. A refusal, deleted, leaves nothing — and an unrecorded rejection is an open invitation to propose the same thing again next quarter. So a "no" said out loud becomes a rejected line, with its reason, rather than a silent gap. The AI asks once, guessing so you can just confirm, and never blocks you. Even "no, reason not given" beats a hole in the record.

What the AI must never do is make itself the gatekeeper. Demanding justification before it writes would invert the whole arrangement, and would only breed reasons typed to get past it.

One place for shared rules

Each project has its own log. Projects stay independent — one can be archived, shared or handed on without dragging the others with it.

Standing rules that apply everywhere live in a separate System log: not what did we decide here, but how do we decide, anywhere.

When a shared rule applies to a project, the project cites it rather than copying it. Thirty-five copies of a policy are thirty-five things that quietly drift apart. Thirty-five citations of one line cannot. And because a rule is never edited — only superseded — a citation resolves forward to whatever the rule has become, so correcting it once corrects it everywhere.

What five years of this looks like

A decision log pays for itself within weeks. What makes it worth keeping is what it becomes.

Every line written this year is context nobody has to explain next year. Sessions stop opening with introductions and start opening mid-conversation. The AI shifts from asking what you want to checking new work against what you have already ruled.

And the sum of what you choose is your sensibility. No single line holds it. But the accumulated pattern of what you kept and what you refused — with the reasons attached — is the closest thing to a taste that can be written down. Quiet endings. Hands, not aerials. Room tone over score. Nobody writes that rule anywhere; an AI reading five years of your choices can infer it. That is the bet this system is making, and the sample only grows.

Two honest limits. It holds your judgement, not your reach — it records the taste you have shown, never the choice you haven't made yet. And it can't calcify you, because a taste that changes says so in a new line, with the old ruling still visible underneath.

What it doesn't do

It records decisions, not outcomes. No line says and that turned out badly. So the log holds your judgement but not proof of whether your judgement was good — there's no feedback loop telling you which kind of reasoning has actually worked. A decision log without outcome review is a log of intentions. Adding outcomes is a line you can write whenever you want; the format already carries it. But it isn't automatic, and pretending otherwise would be a lie.

It doesn't organise your files. It records what you decided about them.

It won't make you write things down. That part is yours. Five minutes at the end of a working day: what did I actually decide, and why?

Bijalog and chat history

Both remember. They remember different things, for different owners, under different rules.

Chat history keeps everything said — the questions, the wrong turns, the corrections — on someone else's servers, in their format, curated automatically by the model, readable only by their tools. Long sessions get compacted; detail is dropped by design.

Bijalog keeps only what was decided, one line each, in plain text you own, curated explicitly by you, readable by anything.

A day's transcript runs to hundreds of thousands of words, most of it scaffolding. When the session ends, what survives is the model's opinion of what mattered. Bijalog inverts that: you write down what mattered at the moment you decided it, and let everything else evaporate.

They're complements, not rivals. Chat is where decisions get made; the log is where they live. The workshop and the deed.

Who this is for

Novelists — durable facts about your world that any AI can read, with old decisions superseded rather than erased, so the story's evolution stays visible.

Researchers — commitments and rejected hypotheses logged with timestamps, source data kept separately: a record that survives review.

Regulated work — a human-gated, timestamped trail of what was decided and by whom, where a self-editing memory would be a liability.

Film and games — production decisions in plain text that outlast the crew, the software, and the model you happened to be using that year.

Anyone teaching a team — log decisions, not conversations. One source of truth, five minutes a day.

Getting started

Level one: a text file. Make it by hand. Paste it into any AI conversation and the model starts knowing your project's history. At the end, ask it to draft the day's decisions; keep the ones you approve. Nothing to install, and the full contract — plain text, append-only, you decide — is already in force. Many people never need more than this.

Level two: the scripts. A few Python files and one double-click. AI sessions stop touching your log directly: they hand over a file of proposed lines, and the run merges what you kept — deleting a line is how you say no — assigns permanent IDs, and checks the whole library for damage.

Why that becomes necessary: past a certain size, no human eye can confirm that nothing was lost or quietly rewritten. A hand-merge drops a line. An AI asked to paste back a long file truncates it without noticing. The question stops being do I trust the log? and becomes can the log prove itself? — which is a job for a machine.

Worth knowing: version control catches corruption, but it will happily record a rewrite. These checks are different — no line got shorter, no ID appears twice, every version is the previous one plus approved lines. One proves the file is what was saved; the other proves what was saved was legal.

Level three: a local broker. An optional conductor running on your own hardware that reads the log, runs your tools as plain-text jobs, stops when a human decision is needed, and reports each morning. Held to one test: if it were deleted tomorrow, every tool would still run by hand and the log would lose nothing. Your memory never becomes hostage to the automation.

The short version

Your work with AI produces decisions. Right now, most of them evaporate.

Write them down — one line, plain text, on your own machine, with the reason attached. In a month it saves you repetition. In a year it saves you archaeology. In five years it's a record of how you think, readable by any AI you choose to work with, owned by nobody but you.

FAQ

1. What is Bijalog?

A decision log for working with AI. Each real decision is one line of plain text — when, a permanent ID, its status, tags, and the decision in plain language — in a file on your own machine. Any AI can read it. So can you, in twenty years, without the software that made it.

2. Isn't it easier to just ask my AI to summarise the project for the next AI?

Often, yes — and if that works for you, do it. For one project over a few months, your AI's built-in project feature plus a text file is enough.

The summary approach has three quiet failures that only show up later. It's the AI's opinion of what mattered, written at the end, from whatever it still holds — and long project chats get compacted, so it's a summary of a summary. It almost never records what you refused and why, which is how rejected ideas come back. And it's flat: no timestamps, no sense of what replaced what.

Bijalog records your decision, at the moment you made it, with the reason attached, and never deletes. Below a certain threshold that's a luxury. Above it, it's the point.

3. When do I actually need it?

Three signs you've crossed the threshold: you're working with more than one AI and each has a different memory of the project; you've been going long enough that summaries have started dropping things; or you've been surprised by a decision you'd already made and forgotten.

If none of those apply, you don't need it yet.

4. What are the principles?

Local-first — it lives on your hardware. Plain text — readable by humans and machines, future-proof. Append-only — nothing is edited or deleted; a change of mind is a new line that supersedes the old one. Human-approved — the AI proposes, you decide. AI-agnostic — any model, this year or next.

5. How is it different from Mem0, Zep, Letta and the other "AI memory" tools?

Those are infrastructure for developers building AI products, and they're good at it. They store what the agent experienced, extracting facts automatically — so nothing was ever approved by anyone, and by their own analysts' account they lack review, audit, and rollback. Bijalog is a record by a person, approved deliberately, held by you. Different tool for a different job. If you're building a product that personalises for thousands of users, use one of them, not this.

6. How is it different from notes, or from Git?

A note is not a decision: nothing marks what's current, what was superseded, or what was approved. Git records how files changed, not what you decided or why — use both. The honest ancestor is the architecture decision record that software teams have kept for a decade; Bijalog is that, compressed to one line and pointed at an AI as the primary reader.

7. If nothing is ever deleted, how does anyone know what's currently true?

It's computed, not stored: the newest live decision on each topic, minus anything a later line superseded. One command returns it. That's also why the log doesn't get unwieldy — the history grows forever, but what an AI actually reads is the current state, which stays roughly the same size whether you've been going one year or ten.

8. What do I have to say when I approve or refuse something?

The AI drafts a line and its reason; you approve by leaving it alone. So when you say nothing, the reason on the record is the AI's. Two moments deserve a sentence from you: when you agree for a different reason than the one written, and when you say no — because a deleted refusal leaves no trace, and an unrecorded rejection is an invitation to propose the same thing again. A "no" said out loud becomes a rejected line with its reason. The AI asks once, guessing so you can just confirm, and never blocks you.

9. Does it tell me whether my decisions were good?

No. It records decisions, not outcomes — nothing says and that turned out badly. Since September it does know what was done: an instruction is closed by the line that enacts it, and the daily run lists what is still open. But done is not good. It holds your judgement, not proof of it. You can add an outcome line whenever you want; the format carries it. It isn't automatic.

10. What's the format?

2026-08-27 14:06 | 01M12H1F80… | ACTIVE | topic:opening | Start the film on her hands, not the aerial shot — scale isn't the story, she is.

Statuses are ACTIVE, PROPOSED, REJECTED, ARCHIVED. "Superseded" is never written — it's worked out from which lines replace which.

11. What about shared rules across projects?

Each project has its own log. Standing rules that apply everywhere live in a separate System log, and projects cite them by ID rather than copying the text — thirty-five copies drift; thirty-five citations can't. Because a rule is only ever superseded, never edited, a citation resolves forward to whatever the rule has become.

12. How do I start?

Level one: a text file you make by hand and paste into any AI conversation. Nothing to install. Many people never need more.

Level two: a few Python scripts and one double-click. AI sessions hand over proposed lines; the run merges what you kept — deleting a line is how you say no — and checks the library for damage. Needed once the log is too big for a human eye to verify nothing was lost.

Level three: an optional local broker that runs your tools from the log and stops at human decisions. Held to one test: delete it tomorrow and the log loses nothing.

13. Who is it for?

People whose project history matters more than five minutes a day: novelists, researchers, regulated work, film and games, anyone teaching a team to log decisions instead of conversations. And not for: weekend projects, product-scale personalisation, or anyone who wants memory without a habit.

14. What does it cost, and who owns what?

Free and open source under the MIT licence — code and documentation alike. Your files are yours; there is no account and no server.