Tools for teams of agents and people.

Give a team AI agents and three things go wrong at once.

Configuration drifts. Everyone assembles their own set of instructions, tools, and connections. There is no shared standard, onboarding takes a day, and the person who figured something out last month is the only one who still knows it.

Nothing is visible. You cannot see who is running what, what it costs, or what came back. There is no shared history and no audit trail.

Nothing accumulates. Every session starts from zero. The agent that spent an hour learning your codebase, your customers, or your reporting conventions forgets all of it, and the next person's agent learns it again from scratch.

The third one is the expensive one. The first two are inconveniences; the third means the organization pays repeatedly for knowledge it already bought.

Put the knowledge in the room.

A channel is a domain of work. Not a chat topic — a boundary. Each one owns a region of the context database, and that region is what the room knows.

Everyone brings their own agent, running locally on their own machine. Nothing about execution is centralized: your agent uses your credentials, your files, your choice of model. What is centralized is the memory, the skills, and the record of what happened.

You enter a channel and your agent is given what the room knows. A colleague enters the same channel tomorrow with a different agent, and starts where you stopped.

WorkRoom is that room, and it is what we are building.

  Alice — local agent ──┐
  Bob   — local agent ──┤  ACP
  Dana  — local agent ──┼──────► WorkRoom
                        │        channels · messages · artifacts
                        │        identity · permissions · capability rail
                        │                    │
                        │                    ▼  MCP
                        └──────────────► context database
                                         memory + skills

Rails, Postgres, a Tauri desktop client, and any agent that speaks ACP. Early — a working vertical slice, with channels, live messages, a local agent in the room, and channel memory pushed into every session.

The agent is not the product. Agents improve every few months and people have preferences. Bind a workspace to one agent and you rebuild when the landscape moves; bind it to a protocol and the workspace outlives any particular agent.

Memory belongs to the organization, not to a vendor. Knowledge accumulated over a year of work is the most valuable thing the system produces. It should live somewhere you control, in a form you can read, audit, and take with you.

Execution belongs to the person. Agents run on the machines of the people who own them, with their own credentials. Nothing queues behind a shared service, and there is no central place holding everyone's keys.

Scope is structural, not administrative. One concept — the channel — serves as the memory scope, the permission boundary, the retrieval scope, and the unit of conversation. Systems that keep those separate end up reconciling four models of who can see what.

Not an autonomy play. The design assumes people stay in the loop. What a machine concludes becomes something the organization treats as true only through an explicit human act — that is article C5, not a preference we might revisit when the models get better.

Not a place where agents run. They run on the machines of the people who own them. The workspace coordinates, records, and remembers.

Not a replacement for the tools you have. Repositories, documents, and the systems the work touches stay where they are. They are sources; this is the layer that distils them into something an agent can act on.

Not a chat product. Conversation is the interface, not the point. The point is that work done in a channel leaves the room better informed than it found it.

A room is only as good as what goes into it, and most companies have never had an honest picture of how their own work is done. Ask people and you get what they believe they do; put a consultant at their shoulder and it is accurate but does not scale.

WorkScreen is our answer to that: desktop software that records how work actually happens — screen, actions, meetings — so the picture a room works from is observed rather than described. The recorder is open source, because that is the only real answer to "what are you recording, and where does it go". It is currently published under its earlier name, gilb-recorder.

It also does not measure people and does not rank them against each other. Reporting on what work costs is fine; ranking the people doing it is not.

Two humans and an AI co-founder · farol.team