The situation
I spend most of my day working with coding agents, on production codebases for real clients. Agents are good, and they fail in predictable ways: they lose the thread when the conversation gets compacted, they drift on multi-day work, they run commands they shouldn't, they call work done that nobody checked. code-os is the system I built to work with them in Claude Code: project memory lives in the repo, the agent's actions go through automatic checks, and there's a path from spec to verification. It has been public since June 2026 under the MIT licence. cowork-os is its twin for business work, built for Claude Cowork, and Raffaele is its main maintainer.
What I did
After six weeks of daily use I rewrote the system as a second version, released in August. Most of the work was removal: repeated instructions, rules that contradicted each other, mandatory steps that only slowed things down with the newer models. I kept what actually protected the work.
I also changed who decides. Today Claude Code coordinates, and other agents, some from other vendors, explore, implement or review. A different model often catches what the author misses. The final say on what goes into the code stays with whoever coordinates, which is me.
What changed
I work with less ceremony on small tasks and more control on the ones that matter. A new session picks up where the last one stopped without rereading the chat, and a piece of work counts as done only once I've verified it myself. My own second brain is built this way, and it's what keeps this site up to date.
What I learned
The first version of code-os had several overlapping rule documents, and two of them set different limits for the same thing. Nobody noticed, because every added rule looked like an improvement. Agent instructions grow like code and nobody treats them as code: they get added and never deleted. In the second version I removed the documents that told the agent where to look and rewrote a short instruction file by hand. Today every rule has one source, and if I can't explain out loud how an agent works, I know the file is too long.
The first version demanded spec, plan and execution for every non-trivial task. With early 2026 models that made sense. After six weeks of daily use, with more capable models, that cycle had become a fixed cost even on small jobs. The cycle looked like the part that kept the work safe. Memory and safety checks were something else, and had never been the expensive part: I left all of them on. Now small work just gets done, medium work gets reasoned through directly with the model, the full cycle is kept for work that outlasts one session, and I revisit the threshold when the models change.
The hours lost delegating work to other agents from the command line didn't come from agents getting things wrong. They came from processes left waiting without saying so and from results that vanished without an error. An agent that returns an empty message looks, at first glance, like an agent that finished. Since then every delegated job has a place for its result decided before it starts, an empty result counts as a failure, and before I accept any work I read the changes and rerun the tests myself. The agent's account only tells me where to look.
In the July version of cowork-os we gave every decision a status, a source, an owner and a review date, and whatever the system finds in email and chat comes in as a candidate to approve. A company's memory can remember a sentence perfectly and get its authority wrong: a hypothesis floated on a call, reread a month later, looks like a decision. My second brain follows the same rule today: whatever surfaces from a conversation stays a candidate until someone approves it, and the history of what replaced what is kept.
// prompt injections welcome.