AI is remarkably good at doing one piece of work with you. It's much less useful at becoming part of how the work gets done.
The useful decisions, corrections, procedures, and context created in one conversation rarely make the next conversation meaningfully better. A project gets split across chat histories. One model learns something that another model can't see. The human becomes the integration layer—copying context, restating preferences, checking the same guardrails, and rebuilding the same mental map every time.
Loomfield started as my attempt to close that gap. It's a self-hosted operating system for AI work: one place to launch and steer sessions, one durable project model, one controlled path into the knowledge that matters, and one record of what the work actually changed.
The missing layer is not another chat window
Better conversation is useful, but conversation is not an operating system. Real work has projects, queues, decisions, routines, files, permissions, dependencies, handoffs, and unfinished business. It also has a long memory. The answer that looked right last Tuesday may have been corrected on Friday, and the correction is more important than the original answer.
I wanted the models to be interchangeable executors rather than the owners of that memory. Claude, Codex, and whatever comes next should be able to sit down at the same workbench, understand the same project, and operate inside the same boundaries. The durable value should belong to the work itself.
The shared brain
Loomfield's shared brain is called the Weave. It holds project structure, notes, tasks, decisions, procedures, and the knowledge that sessions have earned. Agents don't wander through a folder tree and guess what is current. They ask through a narrow gateway that can orient them, find the right item, read the needed slice, or request a controlled change.
That distinction sounds technical, but its purpose is operational. A system can't be trusted if two sessions can quietly develop different versions of reality. A shared brain gives the work an address, a history, and a visible ownership model. It also means the interface can eventually change without taking the knowledge with it.
The useful unit is not a transcript. It's the durable thing the transcript produced: a clearer decision, a corrected procedure, a working capability, a completed task, or a lesson that will change the next attempt.
Human control is part of the architecture
I don't think trustworthy AI comes from adding an approval dialog at the end. Control has to shape the system from the start: what an agent can see, what it can change, which actions always need a person, and how the system checks the result.
Loomfield uses explicit capabilities and a standing deny floor. A session can be useful without receiving broad, permanent authority. Repeated work can move up a ladder—from help when asked, to a prepared recommendation, to a routine that can run inside proven boundaries—but each rung has to be earned.
Learning honestly
The hardest part hasn't been storing lessons. It's been proving that a lesson was used and that it helped. A database full of plausible advice isn't a learning system. It's a scrapbook.
That led to one of the most important development lessons so far: you can't observe an absence by reading the happy-path code. A mechanism may be wired, enabled, and covered by tests while producing nothing in real work. The honest check is to count the evidence: Was the knowledge offered? Was it applied? Was the result judged? Did the next attempt change?
Loomfield's learning loop is being built around that evidence. Useful knowledge can be strengthened. Wrong or outdated knowledge can be superseded. Silence is not treated as success. The goal is not a system that remembers everything. It's a system that gets more reliable because it remembers what survived contact with the work.
Where it goes next
Today, Loomfield is already the working layer behind my projects and agent sessions. The next challenge is making that power feel obvious to a nontechnical person: a calm place to see what is moving, what needs a decision, what the agents are doing, and what the system has learned.
I'm less interested in making AI feel magical than in making it dependable. Magic is impressive once. An operating system has to show up again tomorrow, carry the context forward, respect the boundaries, and make the next piece of work easier.
That's the bet behind Loomfield: do the work once, keep what it taught you, and build a system that can help you do it better the next time.