> ## Documentation Index > Fetch the complete documentation index at: https://docs.cogniagent.ai/llms.txt > Use this file to discover all available pages before exploring further. # Core concepts > The mental model behind Cowork — workspaces, workers, tasks, skills, capabilities, and sandboxes, defined simply. Cowork has a small number of building blocks that combine to give you a roster of AI employees. Once you know what each one means and how they fit together, the rest of Cowork is easy to reason about. ## The hierarchy at a glance Everything in Cowork sits inside a **workspace**. A workspace holds **workers** — your reusable AI employees — and each worker runs **tasks**, the private units of work you hand it. A task can also skip the worker entirely and run at the workspace level, like opening a blank chat. ```mermaid theme={null} flowchart TB WS["Workspace"] --> W1["Worker — e.g. SDR"] WS --> W2["Worker — e.g. Recruiter"] WS --> WT["Workspace task
(no worker)"] W1 --> T1["Task"] W1 --> T2["Task"] W2 --> T3["Task"] ``` * **Workspace → Workers.** A worker is defined once and shared by the whole workspace. * **Worker → Tasks.** A worker can run many tasks, each a separate, private run. * **Workspace → Task directly.** The top-level "New task" button skips workers entirely — useful for one-off work that doesn't need a dedicated employee. A grouping layer above workers ("Projects") is on the roadmap but not part of the v1 hierarchy. For now, the workspace is the only shared container. ## The vocabulary The top-level container for your team. Every worker and every workspace-wide asset (skills, capabilities, shared files) is visible to **all** members of the workspace — there's no admin-only tier and no per-user permission system in v1. Anyone in the workspace can see, create, and edit any worker. The one thing that's never workspace-wide is a **task** — see [Privacy: tasks are always private](#privacy-tasks-are-always-private) below. A reusable AI employee, built from four parts — instructions, skills, assets, and capabilities — plus a status (see [Worker status: active vs. disabled](#worker-status-active-vs-disabled) below). See the full anatomy in [Workers](/cowork/workers/overview). A single, private run or conversation — one unit of work. A task is either: * **Worker-bound** — created from "New task" under a specific worker. It copies that worker's files and runs with that worker's instructions, skills, and capabilities. * **Worker-less (a "workspace task")** — created from the top-level "New task" button, like opening a blank chat. It has no worker-level instructions or skills, but it still gets tools (connecting to a capability, web search, and so on). Either way, a task belongs to exactly one person. Full lifecycle and UI details live in [Tasks](/cowork/tasks/overview). A packaged `SKILL.md` capability that a worker loads **on demand** rather than keeping in context all the time — this is what lets a worker carry many abilities without bloating every conversation. Skills are workspace-shared, so once one worker (or you) adds a skill, it's available to attach elsewhere too. See [Skills](/cowork/workers/skills) for how progressive loading works. An integration — email, a CRM, a spreadsheet, and so on — exposed to a worker as callable tools. Capabilities are attached through the same **Connection Manager** used elsewhere in CogniAgent, so a connection you've already set up for a workflow can power a worker too. See [Capabilities & connections](/cowork/workers/capabilities). The isolated cloud environment (built on e2b) where a task actually runs code and edits files. It **pauses when idle** to save cost and **resumes automatically** on your next message — nothing is lost in between, because the files themselves live in S3, which is always the source of truth. Execution details live in [Execution, sandbox & files](/cowork/tasks/execution). The chat-first screen you actually work in for a task: a conversation on one side and a files/preview panel on the other. This is where you talk to a worker, watch it act, and review what it produced. ## Where things live: asset scoping Files in Cowork live at one of three v1 scopes: **shared workspace files** (visible to every worker), **worker files** (owned by one worker, across all its tasks), and **task files** (private to one task's owner). A project-level scope sits above workers on the roadmap but isn't part of v1. See [Execution, sandbox & files](/cowork/tasks/execution) for the full scoping rules. ## Privacy: tasks are always private A task is a conversation between one person and a worker — and it stays that way. No one else in the workspace, not even other members who can see and edit the same worker, can view another user's tasks. This applies equally to worker-bound tasks and to worker-less tasks. What **is** shared, the instant it changes, is the worker itself and its workspace-scoped skills, instructions, and capabilities — every member sees the latest version immediately. The dividing line is simple: **workers are shared, tasks are private.** ## Worker status: active vs. disabled A worker is **active** (anyone can start a new task under it) or **disabled** (no new tasks, but tasks already running keep going). See [Workers](/cowork/workers/overview) for the full lifecycle, including when a worker is deleted outright versus disabled. ## Next steps See the full anatomy of a worker and how to create and manage one. Worker-bound vs. worker-less tasks, lifecycle, and the cowork UI. How SKILL.md packages let a worker load new abilities on demand. Attach integrations as callable tools through the Connection Manager.