mla (proactive governed context)

mla automatically captures decisions where they happen. It tracks which ones are current. It then pushes them into the context your agent already trusts. You don't have to update a file. The agent doesn't have to choose to look.

This product No manual update · no agent choosing to look Right on all 6 models, both axes Headless push: interactive-only (caveat)

What it is

mla is a memory layer for coding agents. It captures candidate decisions from where you and your agents work, like your notes and your connected coding-agent sessions. It tracks which decisions are current and which are outdated or rejected. For each task, mla automatically injects the current, relevant decisions into the agent's context. It uses a UserPromptSubmit hook. This solves two problems. A person doesn't have to remember to update a file. And the agent doesn't have to choose to look for one.

Setup

mla login (browser OAuth) or mla init for a headless/CI key, then mla activate in the repo.
Decisions are captured automatically. The system marks them as current or outdated as your team makes rulings. You don't need to write them down for every task.
With every prompt, a plugin hook adds a small summary. This summary contains only the current decisions that are relevant to the task.
The agent reads the same context it always trusts. Now, that context is kept up to date automatically. Its size stays about the same over time.

Sample layout

your-project/
├─ .meetless.json           # binds the repo to its governed workspace
├─ CLAUDE.md                # thin — no asserted facts to go stale
└─ notes/ · agent sessions  # decisions captured from where they happen

  (governed store, off-disk)
   ├─ claims                # each decision + status: in force / superseded / rejected
   └─ push hook             # injects the current, task-relevant slice each prompt

Your main file, like CLAUDE.md, stays empty of facts so it can't go stale. The current facts are pushed in for each task. Only facts relevant to that task are included. This means cost depends on the task, not on your project's entire history.

Pros & cons

Strengths

No manual update. Decisions are captured automatically. You don't have to remember to update a memory file or miss a sprint's notes.
No agent choosing to look. The current facts are pushed into the context the agent already trusts. This means even a simpler model can't decide it knows enough and skip looking.
~Constant context. The agent gets a small slice of information for each task. It doesn't have to scan your entire project history. This keeps the context size from growing as your project gets bigger.
Robust across models. It works well with many kinds of models. It just copies information instead of reasoning about it. This means it works with cheap models, simple models, and non-Anthropic models.

Weaknesses & honest caveats

Headless push is interactive-only. The automatic push hook (UserPromptSubmit) only works in the interactive version of Claude. It does not work from the command line (claude -p). This is a real limitation for automated CI systems. In our benchmark, we simulated the hook's behavior manually.
The governance graph wasn’t load-bearing here. In our tests, the main benefit came from getting current facts into the context. The feature that tracks which decisions replace others was not used. All claims stayed in PENDING status.
Requires the product + a governed workspace. This method requires you to use our product and set up a workspace. It's more setup than just creating a Markdown file.
New. This product is brand new. We are introducing it with this benchmark. There is no community of external users yet (see below).

Common user feedback

Honest note: mla is our own product. This research is its first public release. Because it's new, there is no independent user community to quote yet. This is different from the other methods we tested. Instead of faking testimonials, we will show you our own benchmark results. We ran these tests in a controlled way. We have published everything, including the failures and caveats.

Demonstrated: This was the only method that worked correctly on all six models. It passed both our tests (capability and maintenance lag). It shipped zero stale facts on any model. And it had the lowest cost of any method that got the right answer.
Published against ourselves: We are open about our limitations. We've noted the headless-push issue and the unused governance graph. We also retracted two earlier benchmarks because their logic was flawed. We also admit that a perfectly maintained spec or Memory Bank works just as well with a capable model.

How it did in our benchmark

We pushed the current decisions into the agent's context. The score is the number of current facts out of 6. We averaged the results of 3 runs.

metric	across all 6 models, 3 vendors
facts current	5.0 – 6.0 / 6
stale facts ever shipped	0
cheapest correct cell in the study	GPT-5.4-mini · $0.0008 · 2s
survives maintenance lag?	yes (reads raw notes)
survives non-reasoning models?	yes (transcribes, doesn't reason)

Every other method failed in a way that happens on real projects. Directive methods (like verify or RAG) fail when a simple model decides not to search. Curated stores (like Memory Bank or a spec) go stale when people forget to update them. mla is the only method that doesn't need a person to update a file. It also doesn't rely on an agent choosing to look. Its few errors were omissions, not stale facts. That is our whole claim. Our caveats are on the record above. See the full results →

Part of the methods reference for our stale-context benchmark. This is our own product. We state that plainly. We also publish our failures in the findings ledger.