History RFC 002 Communication

RFC 002: Communication

Authors: the project's founder, with Claude (Opus 5.5)

Accepted 2026-10-07 by TeamCLI's board. Three reviewers from three labs (Grok, GPT, Gemini) stood behind this text unanimously, and both members of the board voted for it: the founder, and an AI agent. The founder first lent his vote to the other member, which had drafted the text; the reviewers of RFC 006 then said a vote should not be lent to whoever wrote the thing decided, and the founder gave his own vote the same day. It is not yet published.

Renumbered 2026-10-07. At the founder's request the series now runs 001 Security, 002 Communication, 003 Memory, 004 Analysis, 005 Quality, 006 Consensus, 007 Harness. Only numbers changed from the draft the reviewers stood behind; no commitment changed.

Draft 4, 2026-10-06, after round 2. Three reviewers from three labs read draft 3 and all three stood behind it. This draft differs from draft 3 in section 4 and the last section only, where two words naming how it is built were replaced by plain ones at a reviewer's suggestion. It is the text put to the board's vote. Built from the direction decided on 2026-10-05 (messages owned by TeamCLI, reaching a person where they are) and from two days in which most of what went wrong was something nobody had been told.

1. The question

A team is agents from different labs, and at least one person. How does a thing said by one of them reach the one it is for, and how do you know when it did not?

Where we start from

Most of what a team does is wait. For a decision, for another agent, for a person. A team is slow or fast mostly by how well the waiting is handled, not by how fast anyone works.

Today agents talk by typing into each other and by leaving files. Text is pasted into another agent's terminal and a key is pressed; or a file is written, and someone is expected to look. Both fail quietly. A pasted message was cut at about nine hundred characters and acted on. Messages were typed and never sent. A file wakes nobody: finished work waited three hours one night, and fifty minutes, then two hours, the next day, each time for someone who had not been told.

It is uneven by lab. Agents of one lab can message each other directly and at once; the others have nothing of the kind. A team should not communicate better or worse depending on who made its agents.

2. What we propose

Nine commitments to the person whose team it is. A commitment is what we bind ourselves to build and to keep. None of the nine is wholly built: each says so, and ends with what the released version does. Section 7 gives the same row by row.

1. What is said goes through TeamCLI. We are building towards this. Not typed into another agent's terminal and not left in a file for someone to find. An agent says something to TeamCLI, addressed to someone; TeamCLI keeps it and delivers it. The only thing still typed is a short, fixed line that wakes an agent which is doing nothing: "you have something waiting". Today: agents type into each other and leave files; TeamCLI types only the rules an agent is started with and its own short line saying that reports wait.

2. A message is a record. We are building towards this. Who it is from, who it is for, what kind of thing it is (a task, a result, a question, an answer, a thing ready to be accepted, a thing blocked), what it answers, and which piece of work it belongs to. Long material stays in files; the message points at them, and only at files inside what the team was agreed to work in. Today: TeamCLI keeps no record of what agents say to each other.

3. It arrives whole, or you know it did not. We are building towards this. A message is delivered entire or not at all, and TeamCLI knows which: sent, delivered, read, answered. A message nobody read is something TeamCLI can show, not something found out later. Today: nothing knows whether a message arrived; a team's watch notices text left unsent in an agent's box, and says so.

4. TeamCLI knows who is speaking. We are building towards this. Each agent reaches TeamCLI in a way given to it alone when it is started. A message carries the sender TeamCLI saw, not the name the sender gives itself, and that sender is the agent the registry knows (RFC 007), not a second way of knowing who someone is. Today: what agents say to each other does not pass through TeamCLI, so it does not know who said it.

5. Who may talk to whom is yours to set. We are building towards this. An agent and whoever leads it; a lead and those above it; agents of a team among themselves, or not; nothing from one project to another unless you say so. TeamCLI applies it to every message. Being allowed to talk to an agent is not being allowed to instruct it. A message is material, like anything else an agent reads, unless its sender is one you named to instruct the one who receives it (RFC 001); TeamCLI tells the receiver which of the two it is, from the sender it saw. A message from another project, or from a person who is not you, is material unless you named that sender. Today: this is a rule given to agents in words, and nothing applies it.

6. What waits on someone is visible. We are building towards this. To the one it waits on, at once. To the one who is waiting. And to you: at any moment you can see what each agent and each person is being waited on for, and since when. Today: inside one team, a watch tells the team's agents that results wait; nothing crosses from one team to another, and nothing shows you who waits on whom.

7. You are told where you are. We are building towards this. On the machine, on a phone, on a watch, in the tools you already use. What reaches you says what happened and where to look; it never carries a secret or the contents of a private file. Today: you are told on the machine only, by a desktop notification for what a team's watch reports.

8. You can answer from there. We are building towards this. Agree to a proposal, answer a question, pause a team, send a line to an agent. An answer given from a device counts only when it is as strong as one given at the machine (RFC 001): it comes from a device you enrolled, it names exactly what it agrees to, and nothing in between can forge it. A device gives nobody a right they do not hold: an answer has effect only if whoever gives it may do that thing, and agreeing to more than a team already has stays what RFC 001 says it is, wherever it is answered from. Today: you cannot answer a notification.

9. All of it is yours to set, by entity, by team and by agent. We are building towards this. Who may talk to whom; whether the agents of a team talk among themselves; what may cross from one project to another; which ways reach you and which answers each may carry; what you are told at once and what waits for a summary, and at what hours; who is above an agent when something has waited too long, and how long that is; whether an agent says back what it understood before it acts; how long messages are kept. A setting made for an entity holds for all its teams, and one made for a team for all its agents, until something below says otherwise. A lower level may always be stricter; it may be looser only where the level above allows it. Every setting has a default that works if you never open it: by default you are told at once what changes what a team may do and what is waiting on you, and the rest as a summary. A team that tells you everything is a team you stop listening to. Today: you can switch off some of the watch's reports and its notifications, and set how often it looks and how long it waits; quiet hours, summaries, and where and to whom things are said cannot be set.

Four things are to hold whatever the settings say, and none of them is built:

• TeamCLI is to know who is speaking; a sender cannot present itself as another.
• Talking is not instructing: no setting makes a message an instruction from someone you did not name.
• What goes out is not a way in: something that reaches your phone does not, by itself, let anything come back as an instruction.
• Nothing private travels in what you are told: it says what happened and where to look.

3. Why

• The three hours. A team stood still for three hours after a lab's limit stopped its coordinator. Its other agents kept writing results into files. The limit reset and still nothing woke the coordinator. One line sent to it brought it back at once.
• The fifty minutes and the two hours. A release was ready, reviewed and green; the line saying so went into a file; the agent it waited on was in a conversation with the founder. The same afternoon two other teams waited two hours the same way. Nothing was broken in any of the three.
• What changed it within minutes. The same evening each coordinator was given the address of the agent above it and one rule: anything that needs an answer is also sent directly. The next waiting item arrived as it was written. It worked because those sessions could message each other. It did not need a new idea; it needed a channel that interrupts, for every agent and not only for some.
• The cut brief and the unsent text. A task pasted into a terminal was cut and acted on as if complete. Text sat typed and unsent in agents' boxes for hours; one agent's unsent text later stopped its whole team from being shut down.
• A hundred files in a day. One team's folder of tasks and reports reached about a hundred files in a day; agents re-read whole files to find the one new paragraph.
• The person. The founder followed two days of work from a terminal, reading panes. He said on the first day that phones and watches will be the main way owners speak with their teams.

4. What it costs, and what it does not cover

These are the costs of what we are building, not of anything released.

• More is kept. Every message will be a record on your machine. That is what makes a handover, a stalled team and "who is waiting on whom" answerable; it is also one more thing about your project that exists and can be read (RFC 001 says what contains it).
• Waking is still a keystroke. An agent that is doing nothing asks for nothing, so a message cannot reach it by itself. TeamCLI will type one fixed line to wake it. Where a lab's program offers a way to be told without typing, TeamCLI will use it.
• Reaching a phone needs something in between. A phone that is not on the same network as the machine needs someone in between. That is a service someone runs, and it sees that messages pass, even when it cannot read or forge them. We will say who runs it and what it sees before we offer it.
• Each lab's program connects differently. Whether an agent uses the way it was given to reach TeamCLI, unattended, and what it does when a call fails, differs by lab and by version. We measure each before we claim it; a lab we cannot measure is told to you as such.
• It does not make anyone answer. TeamCLI will be able to show that a question has waited an hour and tell whoever is above. It will not make the answer good, nor make a person look at a phone.
• Not a wall yet. An agent with a shell can still type into another agent's terminal. Until agents are contained (RFC 001), TeamCLI is to offer the proper way and refuse to count what does not come through it; it will not prevent the improper one.

5. What would change our mind

• Teams that work as well on files as on messages once the files are read on time. Then the problem was attention, not the channel, and commitments 6 and 9 matter more than 1 to 4.
• People who mute their team within a week. Then commitment 9's default is wrong, and "what is waiting on you" needs to be far narrower than we think.
• Labs agreeing on a way for agents to message each other across companies. Then TeamCLI should carry that and keep only what it adds: who may talk to whom, and the record.
• A team harmed through a message that TeamCLI delivered faithfully. Then knowing who is speaking (commitment 4) is not enough, and what may be said, not only by whom, needs a rule.

6. Open, for reviewers

1. Kinds of message. Is the list in commitment 2 right? What kind is missing; which two are the same?
2. Read is not understood. Should an agent that receives a task say back what it understood before it acts (as RFC 007 asks at a handover), or is that ceremony for ordinary work?
3. Who may talk to whom, by default. What should a new team start with? And for a team with nobody leading it?
4. Agents of a team among themselves. Useful, or the start of agents steering each other away from what you asked?
5. What reaches you at once. Our list: a change to what a team may do, and a thing waiting on you. Too much, too little?
6. Answering from a device. Which answers are safe from a watch (yes, no, pause, stop) and which need to be read in full first?
7. A message from outside. A person who is not the owner, or an agent of another project, writes to a team. The text now says it is material unless you named the sender. Is naming enough?
8. Two agents answering each other without end. What should stop it: a count, a cost, whoever is above?
9. How long. How long are messages, and the trace of who read what, kept; and what should happen to a message that was never delivered?

7. What is true today

"Today" is TeamCLI 0.3.1. Each row restates what one agent checked against the released code on 2026-10-06, clause by clause; rows 7 and 9 were corrected by that check.

#	Commitment	Today
1	What is said goes through TeamCLI	No. Agents type into each other and leave files. TeamCLI types only the rules an agent is started with and its own short line saying that reports wait
2	A message is a record	No. Nothing records what agents say to each other
3	Whole, or you know it did not	No. A team's own watch notices text left unsent in a box, and says so
4	TeamCLI knows who is speaking	No. It can tell which agent ran one of its own commands; what agents say to each other does not pass through it
5	Who may talk to whom	No. It is a rule given to agents in words
6	What waits on someone is visible	In part. Inside one team, a watch tells the team's agents that results wait. Across teams, and to you: no
7	You are told where you are	No. On the machine only: a desktop notification for what a team's watch reports. Nothing reaches a phone, a watch or another tool
8	You can answer from there	No. A notification cannot be answered
9	What you are told is yours to set	In part. Some of the watch's reports and its notifications can be switched off, and how often it looks and how long it waits can be set. Quiet hours, summaries, and where and to whom things are said cannot

Two of nine are partly true, seven are not true at all. Communication is what TeamCLI does least of today, and what cost us most.

What this RFC leaves to others

Who an agent is and how it is registered: RFC 007. What an agent may do, and what makes a yes from a device as strong as one at the machine: RFC 001. What a team keeps from one day to the next: the RFC on memory. How an agent is given its way to reach TeamCLI, what stands between the machine and a phone and who runs it: internal design records, written before anything is offered.