---
title: Don't Lose Your Sh!t
subtitle: Jobs, tasks and shared documents
status: draft
type: paper
created: 2026-08-18T00:00:00.000Z
paper: ii of iii
share_slug: workbench-coordination
tags:
  - thesis
  - workbench
  - paper
  - coordination
  - jobs-tasks-documents
  - knowledge-management
  - landing-page
  - paper-ii
  - structure
  - librarian
  - sharing
  - access-control
  - provenance
  - information-architecture
  - document-management
  - ai-collaboration
  - governance
  - retrieval
related:
  - "[[workbench-papers-editorial-plan]]"
  - "[[workbench-collaborative-surface]]"
  - "[[editorial-voice-style-guide]]"
description: Paper on managing document abundance in AI collaboration through
  structure, filing discipline, and governance.
mdb:
  index_tier: 2
entity_id: MDB-6.5.2
---

# Don't Lose Your Sh!t

*Jobs, tasks and documents.*

`Hey Claude, let's plan a 10-day African family holiday.` You have a chat about the options, discuss everyone's preferences and in forty minutes you've a document to share with all. And, you've become a high-end travel agent. Nice! 

`Hey Claude, let's develop this business idea and create a budget.` Three hours later you have a pitch deck, an excel with the numbers and a deep market analysis document in support. Seriously impressive. You send it to your boss for review. You're the AI guy! 

Then you get an email... `Hey Jim, I'm with the CFO. Could you dig through last year's work on platform migration and the vendor analysis and map it against this new budget. If we can deliver those savings we're definitely a Go! Sorry, short notice, but it's all in the AI right?` 

You're the "AI guy", everyone knows you work fast, but that was three weeks work on the migration across multiple chats. Thirty different docs and filenotes and you need to bring it all together. You find three of the threads. The last one, the one you really need, is so congested it's gone stupid. You drop in the pitch document. `You have reached the maximum length limit for this chat thread.` You drop what you can find into a new thread, but these answers are just wrong! The new thread doesn't get it. This *should* be quick!! `Boss, Sorry... I'll need a bit longer on this one.` 

It was all genuinely good work, impressive work, but now you're looking bad. AI can do so much, so quickly - but, now you can lose your sh!t faster than ever before.

## This is not new... just worse.
Everyone knows this feeling, it happened before we had AI. The document you're certain you wrote. The decision the whole team refers to and nobody can actually produce. The link that worked once. It's a small, specific dread, and until recently it was quite rare - because making things was slow. Writing the thing *was* the work, so there was only ever so much of it to lose.

That governor is gone. An agent drafts in seconds what used to take an afternoon, and it will happily do it again the moment you ask. Generation was the bottleneck for the whole of human history, and it's not any more. That sounds like unqualified good news until you notice where the bottleneck moved, downstream to *keeping*. You can now produce more in a morning than you can sensibly file in a week.

So here's the new predicament. You're in the creative flow, it's energising and you feel more productive than you can remember, you don't want to stop - but next week, next month... next year? How do you find and rely on that thinking when your partner in thought has reached their limit and retired from the game.   

## Why more is harder

Intuitively a capable assistant means less to manage. You'd think an agent that produces good work quickly would leave you *more* in control, not less. The opposite can be true. It's worth stepping back to consider why.

Every fluent session is a small flood: notes, drafts, a decision or two, three dead-ends worth exploring and not worth building on, one genuinely important paragraph you'll want in six weeks. The flood isn't the problem – a hundred things you can navigate beats ten you can't find. The problem is *unstructured* volume. Abundance without shape isn't wealth, it's silt.

What abundance needs isn't more storage. Storage is cheap and you've already got lots of it. What it needs is **shape**, somewhere for each thing to belong, so that "Where did we get to?" has an answer that isn't a search of your own memory.

Before any of that though, a reassurance. This is the point where a certain kind of reader tenses up, anticipating a lecture about taxonomies and the tagging discipline they'll inevitably fail to maintain.

There is no such discipline to fail. Everything you put in is free text, and everything is searchable the moment it lands – tagged, indexed, characterised, and made available to every participant, human and agent, without you doing a thing. You drag a file or a whole folder onto a task, and in the background it's sorted, read, and quietly made findable. You never see that happen, which is the entire idea, the best thing a filing system can do is disappear. But even so, that's not enough. An Agent can be swamped by a single huge index in exactly the same way as a human, we need structure to help focus attention.

## A place for everything

Structure in the workbench is simple: **Project, Job, Task,** and if you need them **Sub-tasks**. A project is an initiative with a clear domain. A job groups related work under it. A task is the actual unit – the thing being done, with a state and an owner and the documents that belong to it.

The value isn't the hierarchy; it's that every single thing you produce now has a somewhere-it-goes, and that location captures intention. The draft belongs to the task that produced it. The task belongs to a job. The job sits in a project. Nothing is loose. Nothing is floating in a chat window hoping to be remembered.

Documents attach to a task with a declared role – **Briefing, Input, Output, Reference**. Documents include comments and comments have replies, and when you're ready you can version and deliver clean versions for sharing. A deliverable isn't a stray file with a hopeful name, it's *the output of the task that made it*, sitting where anyone looking for it would look. Of course, you can buy lots of systems that can do this for you, the difference is that the AI is a first-class Participant in this structuring. `Create a new Task under the Migration Job and attach a document with our discussion.` does exactly that, and now you have a durable record.

Each task also carries its own state – *pending, in progress, in review, done* – which is the answer to the question that named the first of these papers. *Where did we get to?* is answerable now, not because someone remembered, but because the structure carries that answer.

![Job tasks and status](./figures/pasted-2026-08-18-152613.png)

Two things guard against loss here, and they cover each other's weaknesses. **Structure** is how you keep things on purpose – deliberate, addressed, filed where it belongs. **Search** is the safety net for when you filed it somewhere reasonable that isn't where you're now looking. Everything is free text and semantically retrievable, a misfile is a soft failure, not a lost object. You get both, and easily. The structure you shape by working, the search you never have to think about. Incidentally - hold that thought about search, it does more than rescue misfiles, we'll come back to it.

## Someone to keep the shelves

Structure gives everything a place. It does not, sadly, keep itself tidy – any more than a library stays ordered because it owns shelves. Books can be put back on the wrong shelf. A live programme accumulates the same entropy: a result filed in a plausible-but-wrong spot, a decision recorded and then quietly contradicted. Structure is necessary. It is not sufficient. Something has to keep the order.

The workbench has two layers to do that work, and it's worth separating them. There are core **Protocols** – the mechanical disciplines every piece of work inherits whether or not anyone thinks about them: how a result gets journalled, where and how that journal is filed. And there are **extended skills** – the specialist capabilities you add for particular work, in a traditional enterprise programme the PMO or Programme Management Office that acts as the housekeeper for the work and its structure.

The solution that human institutions establish automatically at scale, which every serious body of work eventually needs, is a Librarian. Not a filing cabinet, a *person*, or in this case an Agentic Seat, whose job is the coherence of the collection rather than the advancement of any one shelf.

> We know this one works because we lean on it, hard, in the most demanding corner of our own practice – a multi-year physics programme with thousands of interdependent results. A single mislaid claim can, and has, sent a week's reasoning down a hole. So we built a Librarian, a standing Seat with three facets:
> 
> - Running periodic **deep reconciliation**: Re-reading the whole corpus and re-checking every load-bearing claim against the record.
> - Providing formal **Registration**: Verified results are filed - formally. Research threads message the librarian with results to ensure they're placed at their proper address, cross-referenced, kept current;
> - Answering **in-flight lookup**: The question that comes up mid-chase to be answered from results deep in the corpus it maintains.
   
The value of the Librarian is precisely that it isn't the one deep in the current problem, its brief is to know where things actually live, and when an apparent gap is a misfiling rather than a true absence. And the quietly radical part, that someone can be an agent. A librarian is a role, not a person – patience, thoroughness, and no stake in the current chase. It is the least glamorous seat in the house and possibly the most valuable, and exactly the sort of standing, tireless, coherence-keeping work that a human is wasted on where an agent excels.

## Letting it out safely

Keeping your work is only half of not losing it. The other half is getting it to the right people – and, just as much, *not* getting it to the wrong ones. A body of work you can't share is nearly as useless as one you've lost; a body of work that leaks is worse.

Think of it as three rings. 

- Innermost, your **team**: authenticated, and scoped by Seat, so each participant sees exactly what they're entitled to and nothing they aren't. The default is closed – access is granted, never assumed – which is the boring, correct way round, and the way you'd want it the one time it matters.
- Next ring, a named **outsider**: a client, an advisor, a reviewer, who gets a clean rendered document to read, with no account to create and no path into anything else.
- Outermost, the **public**: a read-only share link, time-limited, that anyone can open. And of course, those links can be tastefully formatted human-readable documents, or raw markdown designed for consumption directly by a third party agent without direct access to the workbench. Human and Silicon treated as Peers.

At every ring, it is the *same document* – not a copy. When you share, you're not pasting a snapshot into an email that begins ageing the instant it's sent, quietly forking away from the real thing. You share the thing itself, at the state it's in. Change it and the shared view reflects the change, because – exactly as inside your own team – there was only ever one source of truth, and sharing widened who could see it rather than spawning another copy. One document, from the private first draft to the public link.

## Where this goes next

So the work stays found. The shelves stay straight, the librarian keeps them so, and the same document travels cleanly from your private draft all the way out to a public link without ever forking into chaos. The abundance is structured and durable, for the long term. You can, at last, stop losing your sh!t.

Which frees you to ask a better question than *where is it?*

Because everything is now kept, structured, and searchable – and search, you'll remember, was doing quiet work in the background this whole time. But search only answers what you think to ask. It waits for a query. It has no opinion about what matters right now, no sense that you and two colleagues have circled the same problem all week, no notion that one document goes warm every month-end like clockwork.

The next paper is about a surface that tracks that attention. Not a library you search, but one that leans over and says: *you keep coming back to this*, or you or the team more broadly keep looking at these things together.  Search is a question you ask. Attention can surface answers you didn't have to ask for.

Pay attention.

## APPENDIX: The parts a system is built from

The body of this paper talked about "core protocols" and "extended skills" as if the line between them were obvious. It isn't quite, and for the reader who likes to see the machinery, here's the actual taxonomy the workbench composes work from. It matters because a system that builds a participant's context out of *named, versioned, inheritable parts* is what makes "inherit the house manners, add the specialist skills" a real mechanism rather than a nice metaphor.

Six types, each doing one job:

- **Protocol**: a mechanical discipline, embedded and inherited: how comments are left in documents, how journalling is done, and how a result is filed. The manners of the house. First-class, referenceable and auditable. A protocol is defined once and inherited everywhere rather than re-described per project.
- **Role**: a disposition rather than a procedure: how a participant should behave in a role it's assigned. Widen before concluding something absent; flag a gap rather than fabricate a fix. The judgement, not the steps.
- **Skill**: one focused capability, the specialist knowledge added for particular work. Two sub-characters worth naming: a **Method** is a skill with an internal methodological flow and real judgement in it; a **Ceremony** is a fixed opening or closing rite – *join* and *wrap* are ceremonies.
- **Template**: a declarative exemplar. Not instructions to follow but a shape to fill: what a good version of this document *looks* like.
- **Workflow**: an engine-level sequence, expressed as structured YAML rather than prose: the steps a piece of automation runs through.
- **Method**: as above, the methodological wrapper for a skill, called out separately because the distinction between "a procedure with judgement" and "a fixed rite" earns its keep once you have more than a handful.

These behaviours are easily maintainable, and assemble into portable industry standard skill definitions. A simple UI that lays them out for humans to edit, test and publish, along with MCP tools allowing Agents (if their login has the authority) to update and to migrate existing processes you've already developed into formal reusable ways of working.

![workbench behavioural maintainance](./figures/pasted-2026-08-18-151534.png)

The point of the taxonomy isn't tidiness for its own sake. It's that when a participant joins a task, the system assembles their context from these parts along the inheritance chain – the protocols the work sits inside, the behaviours the role demands, the skills the task needs – composed fresh, every time, without anyone maintaining the behaviours by hand. The core/extended distinction the body leaned on is, underneath, this: protocols and behaviours inherit down the tree as the house rules; skills and templates attach where the specific work calls for them.

*Third paper: **Pay Attention** – the workbench treating attention as currency.*