When a whole team builds with agents, whose memory is it?
One engineer with an agent is a conversation. Five engineers with five agents are five conversations that never meet. TeamOS gives a team one shared brain, kept inside the code itself, and one set of rules that every agent follows.
Without it
With it
One shared brain
It started before a hackathon.
I first built it to prepare a team for a hackathon. Before the clock started, I wanted every teammate's agent to already know how we'd work, what we'd agreed on, and what nobody was allowed to break.
Then I carried it into two more projects, and then into the platform of the team I lead, where it grew into a full operating system for how we build. Each time, it became less about notes and more about rules that enforce themselves.
A hackathon
Onboarding and rules, before the clock started.
1A second project
2A third project
3The team I lead
The whole operating system.
4Next: open source, and inside Keel.
Law, truth, and the record.
The brain has three parts. The rules are the law: how we work, what's protected, what done means. The knowledge is curated truth, and every entry records where it came from. The evidence is the raw record of what actually happened: what ran, what failed, what was decided.
Every agent session follows the rules, cites the knowledge, and leaves evidence behind. Nothing becomes knowledge on its own. It gets there through a person's review, the same review the code goes through.
follows
cites
leaves
The rules: the law
The knowledge: curated, with sources
The evidence: the raw record
A person's review
The rules: the law
The knowledge: curated, with sources
A person's review
The evidence: the raw record
A diff is not proof.
Agents are confident. So every claim in TeamOS carries a label: verified just now, recorded earlier, unknown, or needs to be run again. A draft is not truth. A change is not proof that it works.
The payment tests pass.
Verified nowWe chose one database for everything.
RecordedThe export works on large files.
UnknownThe search is fast enough.
Run it againWhen two records disagree, both are kept and linked, and the older one is marked as replaced. Nobody quietly deletes the history of a mistake.
Sessions last one day.
ReplacedSessions last seven days.
A handoff you can rebuild from.
When a session ends, it doesn't leave a note. It leaves the steps to rebuild where things stand. The next session, on anyone's machine, starts by checking those steps against the code itself, the branch, the latest change, and the files, before it trusts a word of it.
Branch
Latest change
Files
Two match, one doesn't: treat what depends on it as unknown.
UnknownFour agents, one codebase, no collisions.
Work is split into tasks, and each task says what it depends on, which files it may change, and which it must not touch. A guard fails any change that wanders outside its fence. That's how four teammates' agents can work at the same time without stepping on each other. The agents that review the work can read everything and change nothing.
Task A: checkout
Task B: emails
Protected: nobody touches this
Guard: stopped a change
outside the fence
Reviewers:
read only
Good teams don't run on everyone remembering the rules. They run on rules that remember themselves.
Enforcement, not discipline. That's the whole idea.
The mechanism travels. The content stays.
What makes TeamOS work, the rules engine, the checks, and the handoffs, isn't tied to one codebase. It moves from project to project. What stays behind is yours: your team's rules and your team's knowledge. I'm going to open-source it, and it will live inside Keel.
The mechanism
rules engine, checks, handoffs
The content
your rules, your knowledge
Stays with your team
Goes with you
An environment where the agent proposes and the engineer decides, at every step.
Previous: Keel