The setup most people start with

The first agent system most operators build is one agent in one session doing everything. The user gives the agent a task. The agent reads the files, writes the outputs, calls the tools, and reports back. Sometimes the agent has memory. Sometimes it has a workspace. Sometimes it has tools. The setup is small and clean and works for a while.

It stops working when the system grows past the point where one context window can hold it. The first sign is usually context. The agent that started with a clean 4,000-token session is now sitting on 80,000 tokens of accumulated notes, draft files, and prior conversation. It is slow. It is confused. It is hallucinating things it would not have hallucinated three months ago.

The second sign is usually consistency. The same agent asked to do the same thing twice produces different outputs because the system prompt is doing too much. The research output reads like an editorial draft. The published article reads like research notes. The agent cannot keep all its roles straight at once, and the output quality starts to drift.

The third sign is usually audit. The owner wants to know what happened. There is no log of who did what. The agent is one black box. The owner cannot answer basic questions like which drafts were considered, which sources were used, which tools were called, and why a particular decision was made.

These three signs — context overflow, role drift, audit loss — are the signals that the move from one generalist agent to a small team of desks is worth making.

What a desk is

A desk is a named operating context where one category of work happens. The piece on work desks and specialty agents is the deep dive. This piece is the beginner bridge.

In plain terms, a desk is the answer to the question "what kind of work is this?" A research desk does research. An editorial desk writes and edits. A publishing desk handles the last mile of formatting and release. An operations desk watches the system and flags problems.

The mental model that fits: a small company. The owner hires one person and gives them every job. For a while, that one person does everything reasonably well. As the work grows, the owner hires specialists. One person does research. One person writes. One person handles distribution. Each specialist gets better at their job because they are not trying to do all the jobs at once.

The desks are not separate AI models. They are not different products. They are different operating contexts, each with its own memory, its own tool profile, its own scope, and its own conversation history. The desk is to the agent system what a department is to a small business.

The unit of work inside a desk is called a job. A job is a specific assignment — research this question, write this article, publish this page, monitor this system. The desk handles jobs that fall within its scope and refuses jobs that do not.

What changes when you add desks

Three things change. None of them are dramatic on their own. Together they change the character of the system.

Context gets smaller and cleaner. The research desk does not need the editorial style guide. The publishing desk does not need the source notes. Each desk holds only what its work requires, so each desk's context stays small, its reasoning stays fast, and its outputs stay focused. The piece on why context explodes without bounding covers this in detail at the session level; the same logic applies at the desk level.

Roles get clearer. Each desk has a charter — a short document that says what the desk does, what it does not do, and when it must escalate. The charter is what the system prompt was trying to be, except now it only has to describe one role well. The output quality goes up because each desk can specialize. The consistency goes up because each desk is held to a narrower standard.

Audit gets easier. When a question needs an answer, the owner can ask the desk that handled the work. The desk's log shows what it did, when it did it, what tools it called, what it produced, and what it escalated. The owner does not have to reconstruct the answer from a giant generalist session log.

What stays the same

The owner is still the owner. The mission is still the mission. The system prompt for the overall operation is still the operating manual. The tools are still the same tools. The agent system is still the same agent system. Adding desks does not mean adding complexity at the system level — it means moving complexity from one big context into several small ones.

The desks do not talk to each other without going through the coordinator. They do not independently decide what to work on. They do not have authority outside their charter. The system is still one operation. The desks are how the work gets done, not a new thing the owner has to manage.

The owner still has one job: define what the business is for, set the policy, and review the outputs.

When the move is worth making

The general rule: if the single-agent setup is still under 30,000 tokens of active context, if the agent is not yet mixing three or more distinct job types, and if audit is not yet a real requirement, the move can wait. Desks pay off when the system has crossed any of those thresholds.

The more specific signals:

  • The same agent is being asked to do research, writing, and publishing. The output is uneven. The system prompt is doing too much.
  • The agent's session is regularly running out of context, and important decisions are getting lost in the truncation.
  • The owner wants to know which sources were used, which drafts were considered, or which tools were called. The generalist agent cannot answer reliably.
  • A specific failure happens repeatedly — bad citations, broken formatting, missed escalations. Adding a specialist desk is more reliable than adding more rules to the generalist system prompt.
  • The work has natural categories that recur — research this every week, write this every week, ship this every week. Each category wants its own memory, its own tools, and its own review standard.

If none of those are true yet, the single-agent setup is fine. Desks are not an upgrade you need. They are a tool for the moment when one agent trying to do everything starts to fail.

When the move is too early

The opposite mistake is also common. Operators read about desk architecture, get excited, and split their work into seven desks before they have enough work to justify even three. The result is overhead. The desks spend more time coordinating than doing. The owner ends up managing the desk system instead of the actual work.

The minimum viable desks for most operators is two: one for the core work, one for the operations and review function. Three if the work has a clear separation between research and production. Four or more only when there is enough recurring volume that each desk has steady work to do.

A desk with no jobs is not a desk. It is a label. The move from one agent to desks is justified by the work, not by the architecture diagram.

What the move looks like in practice

The setup is not complicated, but it does require writing things down. The owner writes a short charter for each desk — what it does, what it does not do, what tools it uses, what it must escalate. The owner sets up the workspace — a shared knowledge layer for the whole operation, a private memory layer for each desk, and a job folder for each assignment. The owner assigns jobs to desks through a coordinator pattern, which can be as simple as a routing rule or as elaborate as a CEO agent.

The piece on setting up your first three desks walks through the recipe step by step. The piece on multi-agent orchestration covers the coordinator and specialist pattern at a more advanced level.

The beginner bridge is this: you do not need to know everything about desk architecture to start. You need to know that one agent trying to do everything eventually fails, that splitting the work into named desks is the natural next step, and that the move is worth making when the work has outgrown the single context window.

The most common beginner mistake

The most common beginner mistake is the wrong direction. Operators who hear about desks often try to build the perfect architecture first, before they have any real work. They design seven desks, write seven charters, set up seven workspaces, and then realize they have built an empty office.

The right direction is the opposite: start with one agent doing the work. When the work outgrows the agent, identify which category of work is most painful — usually the one with the worst output quality or the most frequent failures. Create one desk for that category. Move the work. Let the desk specialize. Then look at what is now the next worst category and create another desk. The architecture emerges from the work, not the other way around.

The field note on work desks and specialty agents covers the full system. This piece is the on-ramp. The minimum useful action is to notice when the single-agent setup is starting to fail, and to recognize that the next step is not a bigger model or a longer context window. It is a smaller, more focused desk for the work that is failing.

For the vocabulary foundation, see the work desk, specialty agent, and job glossary entries.