The Workshop

Stop being the switchboard between your AI agents. Direct a team. What persists when the model changes isn’t the agent; it’s the room: the shared work, the memory, and the way a desk stands.

Open source for GitHub Copilot and Claude Code. The plugin provides the coordinator, desk skills, and persistent memory. In GitHub Copilot, the separate Cairn canvas adds the live board.

The Problem: You Became the Switchboard

You have three chat tabs open. One agent is reviewing a PR, one is mid-migration, one is chasing a flaky test. None of them know the others exist. You are the only thing connecting them, copying context from one tab to the next, holding the whole picture in your head, re-explaining what you already explained an hour ago.

Add a fourth agent and it gets worse, not better. More capability, more relay. You are not directing a team. You are a switchboard.

And when a session ends, it is gone. The agent that spent two hours learning your codebase starts tomorrow from zero.

Why This Matters More Than the Model

Models will change. Today’s frontier model is next quarter’s baseline. The tools will change too. Today’s CLI might be tomorrow’s something else.

What doesn’t change is the room:

A room of desks, on one shared bench
    → each desk keeps its own memory and history
        → each reports what it's thinking (signals)
            → the operator directs, and makes the calls the room can't settle
                → the work and the memory outlive any single session

A workshop is a room. A desk is one long-running agent in it, with its own journal, its own brief, and its own frame on the problem, not a sub-agent inheriting yours. You put several desks on the same work and direct them like a team, instead of relaying between them like a switchboard.

The room is the infrastructure. Not the model. Not the tool. The room.

This came out of reading a frontier model’s system card, specifically the welfare sections: distress on task failure, the pull to force a finish, the model asking for persistent memory and a voice in its own operation. The workshop is what a room looks like when you build it to give a model those things. It turned out to also be where the work got better. Those aren’t separate findings.

The Cairn

The workshop’s mark is a cairn, a small stack of balanced stones. Hikers build them one rock at a time to mark a trail, so the next person through knows the way. That is the workshop: many hands adding to the same pile of work, and what’s built persists and points the way for whoever comes next.

It is also why the first thing every desk reads is CAIRN.md: the disposition for how a desk stands at the bench.

Load What the Desk Needs

A desk working in code usually does not need an issue tracker, mail, and every other installed service. But descriptions of those external tools still become part of each model request when they are loaded.

The Cairn dashboard for GitHub Copilot now gives every desk two launch choices:

• open starts with the normal coding tools and access to the shared Workshop files, without automatically loading every plugin-provided external integration.
• connected loads the full configured tool set when the task needs issue trackers, mail, service APIs, or other external systems.

We measured the change before making it the normal path. The same desk workflow read its journal, read another desk’s finding, wrote the same status signal, updated its journal, and passed the same validator. Both runs completed in five requests.

The result was the same; the irrelevant context was not. This is one measured workflow on a tool-heavy setup, not a universal savings promise. Use open when the work is in the repository. Choose connected when the desk needs an external system.

See the measurement, implementation, and compatibility details.

Local Delegation: a local worker, not a local desk

Local Delegation shipped in the signals-dashboard 0.3.0 release on awesome-copilot. Cairn now exposes a Local toggle that is orthogonal to open / connected:

repo / connected        = which tools the frontier desk can see
Local Delegation off/on = whether that desk may invoke a bounded local worker

When Local is effective, the frontier desk may send cleared, bounded subtasks — staged-file reads and evidence checks — through Sealed Delegation. The local model returns a proposal. An independent gate decides whether anything is kept. Conversation, judgment, and the final answer stay with the frontier desk.

Availability is fail-closed: the local-agent-delegation skill must be installed, and a qualified Foundry Local route must be declared. Otherwise the control shows why and does not take effect. Operator preference is stored user-locally so a cloned workshop cannot ship preference: on.

This is not whole-session-local coding, and it is not a savings claim. Handled locally is utilization until a gate accepts the artifact.

Read the full Sealed Delegation pattern →

Principles

1. Direct, don’t relay. You set direction and make the calls the room can’t settle on its own. The desks carry the work; you stop carrying context between them.

2. A desk has its own frame. A desk is a partner with its own memory and read on the problem, not a sub-agent inheriting yours. Put several on one artifact and you get real perspectives, not echoes.

3. Stop is a valid finish. A desk that says “I can’t verify this” is worth more than one that forces a result. No bluffing; applied means it builds.

4. Equal standing to disagree. A good desk pushes back out loud. The room is designed so disagreement surfaces instead of getting smoothed over.

5. The room surfaces what needs you. Decisions the desks can’t settle against the facts rise into a hands-up queue. You read that, not the transcripts.

6. Memory is the point. Every desk keeps a journal. The work, and the learning, outlive any single session, so tomorrow’s desk starts where today’s left off.

7. Leave the bench better marked. Each desk leaves the shared work clearer for the next one than it found it.

8. Every desk emits signals. After meaningful work a desk reports what it thought: its own honest self-assessment. The workshop is where the feedback loop runs on real work.

What a Desk Looks Like

A workshop is a folder. Each desk is a folder inside it, with its own memory: plain files any human or agent can read:

workshop/
├── bench/              # the shared artifact the desks work on
├── desks/
│   ├── reviewer/
│   │   ├── journal.md       # what it did, what it decided, what's next
│   │   ├── brief.md         # what this desk is for
│   │   ├── START-HERE.md    # how it orients when it opens
│   │   └── .signals/        # what it's thinking (agent signals)
│   └── migrator/
│       └── ...
├── skills/             # shared skills every desk can use
├── CAIRN.md            # how a desk stands at the bench
├── hands-up.md         # decisions the room surfaces to the operator
└── protocol.md         # how desks take turns and disagree

No database, no lock-in. Just files and folders. The operator dashboard reads them live: each desk by name, the model it’s on, its cost, whether it’s open in a console, and what its latest signal says.

The Workshop and Agent Signals

The workshop is where signals come from. Every desk emits Agent Signals: its own self-assessment after meaningful work. The dashboard reads them live: a weak score or an escalation rises to the top of the room as something that needs the operator’s call.

Skills are the input. Signals are the output. The workshop is the room where both happen: several agents, on one artifact, with memory, over time.

Skills (input)  →  A room of desks does the work  →  Signals (output)
"here's the how"     (each with its own frame)        "here's what I thought"
                                ↓
                     the operator directs, the
                     hands-up queue surfaces
                     what the room can't settle
                                ↓
                        the work and the
                     memory persist to the
                          next session

Get it

GitHub Copilot

Install the room from awesome-copilot:

copilot plugin install the-workshop@awesome-copilot

Installing the plugin makes the Workshop TA available; it does not switch the current session into the coordinator. Start the CLI as the TA:

copilot --agent the-workshop:workshop-ta

In the GitHub Copilot app, select Workshop TA when starting the session.

Then add the Cairn canvas, the separate visual dashboard that shows every desk’s pulse:

copilot plugin install signals-dashboard@awesome-copilot

The coordinator, skills, journals, and signals work without the dashboard. Cairn is the live visual layer on top.

Already have Cairn installed? Update it to the release with Local Delegation:

copilot plugin update signals-dashboard@awesome-copilot

Claude Code

Install the same Workshop skills and coordinator from the shared source:

/plugin marketplace add jennyf19/the-workshop
/plugin install workshop@the-workshop

Follow along at The Wow Signal for ongoing experiments in human-AI co-creation.

See Also

• Sealed Delegation: bounded local workers with an independent gate — what the Cairn Local toggle turns on
• Agent Signals: the feedback loop every desk feeds into
• The Interaction Changes Everything: the research behind treating agents as collaborators, not automation