Reusable memory for AI · closed alpha
commonllama: The same AI. Twice.
Start your AI agent a week apart, and you get two different colleagues. One Monday, your agent reads your wake-up document in full. Next Monday, your agent skims it and misses key instructions. That unpredictability follows you everywhere the agent does: your classroom, compliance-sensitive tasks, and any other professional and personal work with AI.
commonllama serves consistent, faster results from the same model, as often as you want.
What a memory is
Cook once, serve warm.
Cooking (inference) is the time it takes AI to process what you send it: the policy binder, a lesson plan, your established safety check. commonllama can save the processed result as a memory.
How long processing takes depends on the machine and the size of the corpus, and the charts below measure it. Cook ahead and it happens once. Every launch after can load that memory, or a different saved one, without processing again.
Then check it. Ask the questions that matter. Where the answers wander, fix the source and cook again. When it holds, keep it.
Run it again next term, or next audit. Same memory, same footing.
Cook as many as you want. A saved memory keeps cold on disk and loads back warm into RAM the moment the work calls for it.
Cook. Check. Save. Load.
How it works
One memory stays pinned. The rest swaps around it.
locked
locked
Animations licensed CC BY 4.0. Attribution: commonllama project, clrbx.org.
The numbers
The time each launch takes.
Two ways to launch: cook the corpus fresh, or load the copy you saved. The charts time both, 4k of context to 128k, on the three machines we build with.
Charts licensed CC BY 4.0. Attribution: commonllama project, clrbx.org.
Built on llama.cpp.
llama.cpp provides
- Model loading and inference
- Quantization
- KV cache primitives
commonllama adds
- Cooked-memory save, pin, and hot-swap
- Session encryption and memory zeroing
- 16-method pool facade
- 60 error codes, 14 event types
Next up? Strata.
Two ways to recall your memories.
Served on sight.
The just-in-time cache. The runtime recognizes work it has cooked before and serves the saved result on its own. The second time the standard forms, the weekly reports, or the unit your whole department teaches from come through, the processing is already done.
You set how much RAM and disk it can use. It keeps the busiest memories closest and the launch times low, with nothing to manage day to day.
Called by name.
Already in the harness today. Save a memory under a name and load exactly that one, every run. This is the recall that auditable, repeatable work leans on, and the charts above time it. Strata adds a confirmation at the moment of load, ensuring the copy matches what you checked and saved.
This is the one for the audit, the exam review, the safety check, the memory a whole class starts from. Tune it between terms. Branch a copy for a new class while the original stays as you tested it. Share it, and the next person gets exactly what you checked.
Many seats
One loaded memory answers several people in a single pass of the model. A whole class works from one machine at once.
Across the building
A memory tier that lives on your own network. Cook on the strongest machine you have and every machine in the lab serves from it.
Hardware profiles
The runtime measures the machine it wakes up on and sizes its memory to fit. The same software runs right on a single-board computer or a workstation.
Honest ETAs
Job estimates come from measured throughput on your machine. You know how long a cook will take before you start it.
How your memories are kept.
A memory is a processed copy of what you sent: the documents, the instructions, the conversation itself. So it gets the same care the originals do.
Sealed on disk.
Every saved memory, checkpoint, and adapter is encrypted with AES-256 under your key, using each platform's own crypto. A lost laptop stays private.
Cleared from RAM.
When a session closes, the runtime wipes what it held, at more than 600 places in the code, with primitives compilers cannot skip. Close the program and the work leaves with it.
Reports to you alone.
The runtime's only output is the answer you asked for. It checks the app around it against a list of known trackers we keep current, and warns you when it finds one.
Whole on one machine.
Everything the runtime needs ships with it. It runs the same in a classroom with no internet as it does anywhere else.
In short
The meal is the point.
Press enter and your recipe goes to the kitchen. The AI reads what you asked for, cooks, and hands back what it thinks you wanted. That plate is the meal.
So taste it. Too salty, adjust the recipe and send it back. When the dish is right, keep the leftovers: tonight's helping warm in RAM, the rest frozen to disk for next week.
Reheating is the faster way to serve most meals, but some quick dishes are faster made fresh (see the charts above). Speed aside, a dish cooked fresh comes out a little different every time, while with leftovers you know exactly what to expect.