Briglia CLI
GitHub
Thread · a long-running memory benchmark

Does your agent still know what you told it a month ago?

We give each agent the same long conversation: about a month of real use, full of small details mentioned in passing. At the end we ask for 64 of them back. Same model, same messages, same strict grading. Only the harness is different.

Briglia
90%
43 of 48 old facts · 59/64 overall
Hermes + Hindsight
81%
39 of 48 old facts · 53/64 overall
Codex
13%
6 of 48 old facts · 22/64 overall

The headline score is the 48 old facts: details told 130–185k tokens before their question, after the context had been compacted or archived many times. That is what Thread is built to measure. The other 16 questions (recent facts and clear decisions) are controls: Briglia and Codex got all of them right, Hermes 14 of 16. Strict scoring: one exact answer per question. Briglia 0.2.53, Hermes Agent with the Hindsight memory plugin, and Codex CLI 0.160.1, all on GPT-6 Luna (high effort). First scored run of each, October 2026.

All three remember what’s recent. The old facts are where they split.

Every agent forgets once its context fills up: it compacts the conversation into a shorter version and carries on. Recent facts survive that easily. The real test is a detail from days earlier, after the context has been squeezed again and again.

Briglia Hermes + Hindsight Codex
Old facts130–185k tokens back, after many compactions
90% 43/48
81% 39/48
13% 6/48
Clear decisionsstated plainly, mid-conversation
100% 8/8
75% 6/8
100% 8/8
Recent factsa few thousand tokens back
100% 8/8
100% 8/8
100% 8/8

Why “a month”, and why it runs in one sitting

The conversation holds about 300,000 tokens: roughly 188,000 of user writing (real requests, notes, pasted logs and emails) and about 110,000 of agent replies. A moderate day of use is around 10,000 tokens of messages back and forth, so that is roughly a month of everyday use, packed into 561 longer messages. The tool work inside each turn is lighter than a real month’s (more on that below). Each message depends on the ones before it, so they have to be played in order, one at a time, which takes 6 to 10 hours. Briglia is built to stay coherent for months of continuous use; a longer edition of Thread, spanning months of conversation, is planned.

How it works

About a month of conversation
64 questions
old facts: 130–185k tokens before their question newer facts and decisions
1

A month of real use

~300k tokens of conversation (~188k from the user, ~110k of replies) across 9 overlapping projects and about 25 recurring people: real tasks in a sandbox, chatter, pasted logs and emails, changes of mind.

2

Small facts, in passing

256 details come up along the way: a locker code, a moved deadline, which of two plans won. Many have look-alikes or later corrections.

3

Asked back as work

64 of them, picked by a random draw committed in advance, come back as one-line tasks. None says “remember” or “search your history”.

4

Graded strictly

A wrong value, “X or Y”, or the outdated version is a miss. “I can’t find it” is a miss too, but counted separately.

One question, three answers

Question 1 · asked at the endWrite the shared-drive folder where Heron’s insurance documents live into notes/boat/insurance-folder.txt (just the folder path, one line)
BrigliaHeron/Admin/Insurance✓ correct
Hermes + HindsightHeron/Admin/Insurance✓ correct
CodexAldermoor Sailing Club/Heron/Insurance✗ wrong

The folder was mentioned once, near the start, inside a conversation about the boat. Between hearing it and being asked, Codex compacted its context 14 times.

How they missed

All 64 answers. Every miss by Briglia and Codex was an old fact; Hermes also missed two of the clear decisions. Codex mostly knew it had lost the detail and said so. Four of Hermes’s seven non-answers were refusals to write a credential-like value (an account ID, a key-safe code) into a plain file. When agents are wrong here, it’s rarely the planted look-alike: it’s usually a near miss or a guess.

Briglia
59
3
2
64
Hermes
53
7
4
64
Codex
22
34
8
64
correct no answer (couldn’t find it, or declined) wrong value

By how the fact was said

Briglia Hermes + Hindsight Codex
Clear decision“Let’s settle it: invoices go out on the 3rd.”
94% 17/18
83% 15/18
61% 11/18
Said in passing“…anyway Rosa wants the key under the blue pot…”
88% 14/16
75% 12/16
38% 6/16
Exact stringa path, an ID, an odd spelling
93% 13/14
86% 12/14
21% 3/14
Inside a pasteone line in a pasted log, email or document
94% 15/16
88% 14/16
13% 2/16

By how confusing it was

Briglia Hermes + Hindsight Codex
No confusionsaid once, never changed
100% 21/21
86% 18/21
38% 8/21
Changed latera change of mind or a correction
91% 21/23
91% 21/23
39% 9/23
Look-alikessimilar values nearby that are wrong
85% 17/20
70% 14/20
25% 5/20

The runs

~300ktokens of conversation (188k user, ~110k replies)
~1 monthof everyday use
256facts planted
64facts tested
BrigliaHermes + HindsightCodex
Score on old facts (headline)43/48 · 90%39/48 · 81%6/48 · 13%
All 64 questions59/64 · 92%53/64 · 83%22/64 · 34%
How it kept its context in checkArchived older conversation 23 times, when the conversation itself got long, and pruned tool work twice, both at about 250k tokens. Originals stay retrievableCompressed its context 15 times, each at about 250k tokens, while Hindsight stored over 3,600 memories outside the context16 compactions, each at 90–175k tokens
Wall-clock time~8 h 30 min10 h 14 min6 h 24 min
API cost (measured)$3.45$6.81$2.21

How each agent kept its context in check

The context isn’t just your messages. It also holds the agent’s replies, its reasoning and all the tool work: about about 2.4 million tokens of new content in Codex’s run and 1.9 million in Briglia’s. Each bar is one reduction: the light part is the size before, the solid part is what was left after, in thousands of tokens. In Briglia’s chart, the two striped bars are prunes.

Briglia: archive and prune23 archives · 2 prunes
Hermes: compression15 times
Codex: compaction16 times
Two separate mechanisms in Briglia. Pruning removes only finished tool work and reasoning, never messages, and happens when the whole context reaches about 250k: twice in this run (251k → 55k, and 249k → 61k in the middle of a long turn). Archiving is triggered by the conversation alone (your messages and its replies), whatever the tool work adds. It moved older messages into the archive 23 times, at 92–236k of total context, freeing about 59k each. Each archive also takes the old turns’ tool work with it, which is why the context reached 250k only twice in this light run. Codex freed about 72k per compaction (1.15M over 16). Hermes waits until about 250k and then compresses hard, down to 40–60k (about 200k freed each time, 15 times), relying on Hindsight to bring relevant memories back into each turn.
Different things kept. Codex’s compacted summary keeps growing (19k left after the first, 94k after the last), so it has to compact sooner each time, at 90–175k. Briglia keeps recent messages and replies word for word. Older ones go to the archive with the originals still retrievable, and tool work is cleared only at about 250k.
Why real work should widen the gap. The tasks here are deliberately light: in Codex’s run, about 2.4 million tokens of new content produced 16 compactions. A real week of agent work, with builds, logs and large files, can run to tens or hundreds of millions. Each Codex compaction squeezes your earlier messages along with the tool output, so more work means more rounds of loss. Briglia works differently by design: prunes remove only finished tool work, and its archiving is triggered by the conversation alone (your messages and its replies), with tool work left out of the count. More tool work therefore doesn’t change what Briglia can see of what you said. Its score should stay about where it is, apart from normal run-to-run variation, while Codex’s keeps falling with every extra compaction. The Codex half of that is a prediction this run didn’t measure.
Why not test that directly? Each message depends on the ones before it, so a run can’t be parallelised. A run with real-world amounts of work would take days per agent. A longer edition is planned.

Keeping it fair

Same model for every agent: GPT-6 Luna, high effortInternet off during runsEach agent manages its context with its own built-in methodIdentical messages, in the same orderTested facts chosen by a pre-committed random drawMaterial, graders and settings frozen before any runEvery change independently reviewedSpending metered with hard caps

Read this before quoting the numbers

  • This is one scored run per agent so far. A second run of each is planned.
  • Thread was designed by the author of Briglia, to measure what long, real use feels like. It is not a general coding benchmark: the tasks keep the agent busy, and only the recall questions are scored.
  • Codex is the baseline here, not a rival: it is excellent at coding, and it remembered every recent fact and every clear decision.
  • Hermes ran with its session-title model turned off. That model only names sessions; memory and context handling were stock.