About Claiv
Two problems came first. Studio is what they were pointing at.
Claiv Memory and Claiv Parser were built to fix specific, unglamorous failures in AI systems — forgetting, and output that will not hold its shape. Both still run. Together they described a product neither of them was.
First · Claiv Memory
A system that forgets cannot be trusted with anything continuous.
Every conversation started from nothing. Context windows got longer, which moved the ceiling without changing the problem: an assistant that cannot remember what it was told last Tuesday cannot be given work that spans Tuesday and Thursday. Stuffing the whole history into a prompt is not memory — it is a bigger forgetting.
Claiv Memory is a persistent memory API: ingest what happened, recall what is relevant now, forget on request because someone will eventually ask you to. Version 6.3 runs in production at api.claiv.io.
Measured, not asserted
LOCOMO, all ten dialogues
- Overall J-score
- 75.0%
- Open domain
- 79.7%
- Temporal
- 74.2%
- Single hop
- 68.8%
- Multi hop
- 55.2%
LOCOMO is a long-conversation memory benchmark: the model is asked questions whose answers are scattered across months of dialogue. Multi-hop is the weakest column at 55.2%, and it is the honest one to watch — chaining two remembered facts is harder than retrieving either.
Remembering turned out to be the easy half. The hard half was proving afterwards what had been remembered, what had been used, and on whose authority.
What building it taught us
Second · Claiv Parser
Models are good at deciding and bad at formatting.
Every system that asks a model for JSON eventually writes half a parser to cope with what comes back: fenced blocks, chatty preambles, Python True, truncation — and search models that return prose with citations and no JSON at all. Regenerating an expensive call because the formatting was wrong is absurd.
0 · Direct
Parse and validate. If the model returned clean JSON, nothing else runs.
1 · Repair
Fences, preambles, single quotes, Python literals, trailing commas, truncation.
2 · Coerce
Schema-guided: “£29/mo” becomes 29, keys match across camelCase and snake_case.
3 · Markdown
Headings become keys, tables become arrays of objects, URLs become sources.
Tiers run cheapest first and stop at the first schema-valid result, so cost is proportional to how broken the input actually was. Tiers 0 to 4 are pure functions: the same input and schema produce byte-identical output every time, offline, with no model call. That is what makes an output testable rather than merely plausible.
The rule that matters most is the one about absence. Anything not present in the source is null and listed in unresolved. A parser that quietly invents a plausible value is worse than one that fails, because the output looks correct. Every field also reports how it was resolved — exact, repaired, coerced, from markdown — so you can decide what to trust rather than trusting all of it equally.
On its bundled corpus of 19 real-world failure modes: 18 of 18 solvable cases resolved, one honest failure (unstructured prose, correctly not fabricated), zero model calls, 10ms total. Stated plainly, as the README does: that corpus was written alongside the library, so it demonstrates coverage of known failure modes rather than performance on unseen data.
Then · CLAIV Studio
Both were components. Neither was the thing.
Memory solved continuity. Parser solved structure. Put them beside each other and the missing piece is obvious: something has to decide what the work is, who is allowed to do it, and how anyone would know afterwards that it was done properly.
That is CLAIV Studio. You describe an outcome; it designs an organisation of specialists around it, with their knowledge, their connections and their limits set out before any of it exists. You approve the design. It builds the specialists and proves them against realistic cases. Then it runs, and every decision, authority and verified effect is on the record.
- Memory is why it can hold a thread.Work that spans weeks needs something that remembers what happened in week one.
- Parser is why its outputs can be checked.A decision you can validate against a schema is a decision you can audit.
- Governance is what neither had.Authority per specialist, approval bound to the exact action, effects verified against the system rather than assumed.
- It runs on your computer.Local-first, and able to run models locally.
Where they stand
Memory and Parser are both still live.
Claiv Memory
The V6 API runs in production. It is available on request rather than by self-service sign-up — tell us what you are building and we will set up a project and issue a key.
Claiv Parser
Published on npm as @claiv/parser, MIT licensed and zero-dependency. It works offline and needs no model unless you configure one yourself.
Early access
CLAIV Studio is where this went
Early access is open by request. Tell us what you would use it for.
- Full access to CLAIV Studio while it is in early access.
- You drive it. CLAIV designs the organisation, proves it and asks you to approve it — no consultants, no onboarding calls.
- Early access means rough edges, and what early users hit first is what gets fixed first.
Three short steps
Who you are, what you would use it for, and whether your machine can run it. It creates your account at the same time, so there is nothing to do when you are approved.
Get early accessAlready requested? Check your download page.