Organizational responsibilities
Organizational responsibilities give each person a durable view of the work they own. A responsibility states what must stay true, connects the projects, tasks, routines, and skills that support it, and provides measures and reports that help the organization see whether ownership is working. This page extends Organization work management; see Projects, goals, and teams for planning ownership and Work products and conversations for the outputs attached to the work.
Responsibility model
Responsibilities add an ongoing ownership layer above individual work records. They do not replace projects, tasks, or routines. Instead, they gather those records around a result that one person is accountable for.
Responsibility areas
An area is a broad subject that the company cares about, such as Fundraising or Customers. It has no owner and no deadline. Responsibilities can be filed under an area so a person's dashboard reflects the shape of the organization.
Areas can be proposed during onboarding, made active by a board user or by confirming a responsibility under them, or archived when they are no longer in use. The same active area can hold responsibilities for several people. This lets the company use one shared vocabulary without turning the area itself into an assignment.
References: packages/…/responsibilities.ts• L21-52 server/…/responsibility-areas.ts• L48-52 server/…/responsibility-areas.ts• L98-129
Responsibility ownership
A responsibility is an always-on commitment owned by one person. Its title names the concern. Its accountability bar states how success should look. An optional running agent keeps the work moving and the main measure current, but the person remains the owner.
Work enters a responsibility through a link to one project, task, routine, or company skill. A task or routine can also be included through a linked project. A skill can be filed directly, while skills held by agents doing the work can also appear as related capability. One work item may support more than one responsibility, so organization-wide counts use distinct items where needed. Work that is not filed remains visible as loose work rather than silently becoming part of a responsibility.
References: packages/…/responsibilities.ts• L55-60 packages/…/responsibilities.ts• L126-169 server/…/responsibilities.ts• L1040-1095 server/…/responsibilities.ts• L1665-1695
Responsibility lifecycle
Responsibilities move from proposal to active ownership, or they can be let go or dismissed. Agents can suggest responsibilities. A person or company administrator decides what becomes an active commitment.
A person can let go of a responsibility without deleting its supporting projects, tasks, routines, or skills. Permanent deletion removes the responsibility's own record, links, metric history, and status reports, while the underlying work remains available elsewhere. Dashboard changes and agent actions use separate safeguards described below.
References: packages/…/responsibilities.ts• L91-123 server/…/responsibilities.ts• L1359-1457 server/…/responsibilities.ts• L1649-1654 server/…/responsibility-tools.ts• L548-570
Responsibility feature availability
Responsibilities are an experimental instance feature. When an instance admin turns the feature off, responsibility routes and agent tools report that the feature is disabled rather than presenting an empty dashboard. Agent credentials cannot change this setting.
References: server/…/responsibilities-disabled.ts• L3-19 server/…/responsibility-dashboard.ts• L75-78 server/…/responsibility-tools.ts• L34-57
Accountability bars and measures
The accountability bar is the central contract for a responsibility. It turns a broad ownership statement into a sentence, a measure, and a current reading that the organization can review.
Accountability bars
An accountability bar is a plain sentence describing what must be true, paired with one primary metric. The metric can measure a volume, a percentage, a yes-or-no condition, or a value that must stay in a range. The chosen form determines how readings are understood and how health is derived.
The primary metric compares the latest reading with its target or bounds. A complete bar can therefore read as on track, at risk, behind, or not measured. A person may set or edit the bar directly. A person may also talk it through with an agent and accept the proposed bar without applying any change before acceptance. A bar conversation can also propose how the metric is displayed and which supporting metrics belong in the scorecard.
References: packages/…/responsibility-bars.ts• L20-31 packages/…/responsibility-bars.ts• L33-145 server/…/responsibility-bars.ts• L84-91 server/…/responsibility-bars.ts• L168-198 server/…/responsibility-bars.ts• L322-378
Metric sets and readings
A metric set gives a responsibility a small scorecard. It contains the primary bar metric and up to two supporting metrics. Supporting metrics can show a number, a percentage, a line over time, or bars by week. They add context without changing the primary bar's derived health.
When no one has chosen a set, the system shows starter metrics computed from known work. These can include open tasks, tasks finished per week, and the share of work that runs on routines. Chosen readings are kept as history so a person can see movement over time. A stale reading is marked as stale rather than treated as current evidence. Owners can correct or backdate readings, while agents can report only what is true now and cannot correct an earlier reading.
References: packages/…/responsibility-metrics.ts• L9-18 packages/…/responsibility-metrics.ts• L25-58 packages/…/responsibility-metrics.ts• L74-120 server/…/responsibility-metrics.ts• L80-113 server/…/responsibility-metrics.ts• L478-590
Health and work signals
Health comes from the metric unless the owner sets a health override. The override records the owner's choice and note while keeping the metric-derived health available for comparison. This separates a measured result from a human judgment about the wider situation.
The responsibility rollup adds work signals beside the metric. It can surface late projects, blocked tasks, failed or paused routines, unassigned work, recent completion, and stale readings. It also counts projects, tasks, and routines under the responsibility. These signals explain where to look next; they do not change the metric health.
References: packages/…/responsibility.ts• L162-195 server/…/responsibilities.ts• L288-337 server/…/responsibilities.ts• L457-490 ui/…/ResponsibilityStatusLead.tsx• L82-131
Recurring execution and automation
Responsibilities show whether ownership depends on repeated manual effort or on work that can run by itself. Routines provide the recurring execution. The responsibility view measures the relationship between those routines and the manual tasks that remain.
Automation coverage
Automation coverage compares running routines with manual work under each responsibility. A routine counts as running when it is active, assigned to an agent, and able to start through its configured trigger. Recent manual tasks count as hand work for the coverage window. The result is labeled Manual, Some automated, Mostly automated, or Automated.
The automation view also exposes stalled routines and ranked manual candidates. A candidate can carry a hint such as a schedule, webhook, or standing check. The hint starts a conversation about automation. It does not convert work without an explicit decision.
References: packages/…/responsibility-automation.ts• L21-38 packages/…/responsibility-automation.ts• L44-98 server/…/responsibility-automation.ts• L47-61 server/…/responsibility-automation.ts• L160-250
Automation triggers
Recurring responsibility work can start on a schedule, from a webhook, through a standing check, or by request. A standing check watches for a condition and depends on an agent that can wake itself. The trigger describes when work starts; the responsibility describes why the work matters.
This split keeps recurring execution reusable. A routine can serve more than one responsibility through its project or direct link, while the automation view still reports stalled states such as paused work, no assigned agent, or no wakeups.
References: packages/…/responsibility-automation.ts• L105-117 server/…/responsibility-automation.ts• L134-158 server/…/responsibility-automation.ts• L168-180
Responsibility runs
The runs view is a recent execution record for work under one responsibility. It lists agent runs on directly linked tasks, tasks in linked projects, and tasks created by routines under the responsibility.
Runs are read-only evidence. They show the task, agent, lifecycle state, and timing. Access follows the same task visibility rules as the task itself, so a responsibility cannot expose a run for work the reader cannot see.
References: packages/…/responsibility-runs.ts• L1-33 server/…/responsibility-runs.ts• L26-33 server/…/responsibility-runs.ts• L47-103
Dashboard management
The responsibility dashboard is a person's operating view of their commitments. It groups the person's active responsibilities by shared areas and provides both a direct management path and an agent-assisted path.
Dashboard conversations
A person can ask an agent to create a first dashboard or edit an existing one. The agent researches the current work, asks questions when needed, and proposes a change set. A change set can add, rename, or remove an area. It can also add, reword, move, or remove a responsibility.
The person or an authorized company administrator must accept the proposal before it changes the dashboard. The proposal can be partly accepted only when the kept changes do not depend on dropped changes. This gives the person control over the definition of ownership while still using an agent for discovery and drafting.
References: packages/…/responsibility-dashboard.ts• L4-10 packages/…/responsibility-dashboard.ts• L35-99 server/…/responsibility-dashboard.ts• L56-67 server/…/responsibility-dashboard.ts• L601-672
Agent changes
Native responsibility tools let an agent read dashboards, find the responsibilities for a work item, manage areas and responsibilities, and file or unfile supporting items. The tools use the normal authenticated API, so company scope, visibility, permission checks, and activity records remain in force.
An agent acting for a person can make changes that person could make. Each dashboard-affecting change is saved in that person's version history so it can be reviewed and undone when supported. Permanent deletion is different: the agent must obtain an accepted human confirmation card on its current task, and a deletion cannot be undone from dashboard history.
References: server/…/responsibility-tools.ts• L16-27 server/…/responsibility-tools.ts• L257-271 server/…/responsibility-tools.ts• L407-480 server/…/responsibility-agent-changes.ts• L30-85
Dashboard versions
A dashboard version is a saved snapshot of a person's areas and responsibilities. Versions record what changed, who caused the change, and which earlier version they follow. They support review, Undo for a recent applied change, and restore to an earlier arrangement.
Version history tracks the dashboard structure and ownership wording. Newer snapshots can also hold responsibility descriptions, filed projects, tasks, routines, skills, evidence, health choices, and the agent that runs the responsibility. Restore can put those saved details and links back when the underlying records still exist. It does not rewrite the responsibility's bar definition or metric readings, and it does not recreate deleted work. Manual edits are checkpointed before later changes, and the history is bounded per person so it remains a usable change record.
References: packages/…/responsibility-dashboard.ts• L396-500 packages/…/responsibility_dashboard_versions.ts• L7-50 server/…/responsibility-dashboard-versions.ts• L61-85 server/…/responsibility-dashboard-versions.ts• L107-205 server/…/responsibility-dashboard-versions.ts• L512-610 server/…/responsibility-agent-changes.ts• L43-85
Status reporting and summaries
Metrics provide a measured signal. Status reports and summaries provide the human-readable operating view around that signal. They help an owner understand current conditions without confusing a written judgment with the number that produced it.
Status reports
A status report is a short statement from an agent or person about whether a responsibility is behind, at risk, on track, or not yet clear. It has one plain reason line and optional detail. The newest report is current, while earlier reports remain in history. Reports older than seven days are shown as out of date.
The system chooses a reporting agent with the best view of the responsibility's work. It considers work assigned to the agent, routines, led projects, and whether the agent runs the responsibility. The owner can ask that reporter for an update. The request creates a small task and does not create duplicate open requests.
The written report leads the status display when it exists. The metric-derived status remains visible below it, so readers can compare the agent's judgment with the measured bar.
References: packages/…/responsibility-status-reports.ts• L3-14 packages/…/responsibility-status-reports.ts• L21-37 packages/…/responsibility-status-reports.ts• L183-213 server/…/responsibility-status-reports.ts• L51-59 server/…/responsibility-status-reports.ts• L159-219
Responsibility summaries
The dashboard summary answers “Where things stand” across one owner's active responsibilities. A responsibility summary answers “What is affecting the number” for one responsibility. Both use the same overview and detail facts that power the rest of the responsibility view.
Paperclip can compose a short paragraph directly from those facts. When the company's fast-response model is available, it may produce a checked model version in the background. The computed paragraph remains the fallback, and an older model paragraph is reused only while its stated facts remain safe and current enough to show.
Summaries describe status, dates, assignment, and work signals. They do not claim that a task caused a specific change in a metric when the data does not prove that link. Model-generated summaries use the company's fast-response path, so Budgets and cost controls explains the related spend and admission rules.
References: packages/…/responsibility.ts• L393-410 server/…/responsibility-summaries.ts• L20-50 server/…/responsibility-summaries.ts• L781-847 server/…/responsibility-summaries.ts• L1164-1194 server/…/responsibility-summary-generator.ts• L37-44
Responsibility monitoring flow
This flow shows how a person's ownership statement becomes linked work and then becomes evidence for review.
flowchart TD
Area[Responsibility area] --> Responsibility[Owned responsibility]
Responsibility --> Bar[Accountability bar]
Responsibility --> Links[Projects, tasks, routines, and skills]
Bar --> Reading[Metric readings]
Links --> Automation[Automation coverage]
Links --> Runs[Recent runs]
Links --> Signals[Work signals]
Reading --> Health[Metric-derived health]
Health --> Status[Status report comparison]
Signals --> Status
Health --> Summary[Owner summaries]
Signals --> Summary
Status --> Dashboard[Responsibility dashboard]
Summary --> Dashboard
Related pages
- Organization work management explains the company boundary and how responsibilities fit beside goals, projects, issues, skills, budgets, and chat.
- Projects, goals, and teams explains the planning tree and organizational ownership structure.
- Work products and conversations explains the outputs and discussion records attached to the underlying work.
- Skills and knowledge sources explains reusable knowledge available to agents working under responsibilities.
- Chat integrations explains how external chat carries company work and status signals.
- Budgets and cost controls explains the cost rules that can affect model-written summaries and recurring work.
Change checklist
When these files or sections are changed, remember to consider these:
- Keep the responsibility membership rule aligned across direct links, project links, filed skills, rollups, runs, status reporters, automation coverage, and summaries.
- Keep bar templates aligned across validation, reading entry, attainment, health labels, status sentences, metric displays, and bar proposals.
- Keep the distinction between metric-derived health, owner overrides, and agent-written reports visible in every status surface.
- Keep dashboard proposal dependencies aligned with partial acceptance, version snapshots, restore behavior, and the recent Undo path.
- Keep dashboard snapshot contents aligned with restore behavior for filed items and responsibility details, while keeping bars and readings outside restore.
- Keep routine trigger and stalled-state rules aligned with automation coverage and the run records shown for the same work.
- Keep summary facts, fallback prose, model prompts, freshness checks, and cost admission aligned so a summary never states facts from an older view.
- Keep responsibility and dashboard access checks aligned for owners, company administrators, agents, hidden underlying work, and disabled instances.
- Keep permanent-delete confirmation keys tied to the exact responsibility or area and to an accepted human decision.
Important failure modes
| Trigger | Consequence | Guard |
|---|---|---|
| Responsibilities are disabled on the instance | Routes and tools can mislead an agent by looking like an empty dashboard | Return the disabled-feature signal and tell the agent not to search through other tools. |
| A responsibility links work through a project but a reader cannot see that project or its tasks | Counts, signals, runs, or summaries can expose or misstate work | Apply the same underlying work visibility scope to responsibility reads and dependent views. |
| A bar has no valid reading or its reading is stale | Health is not measured or may not represent current work | Show the missing or stale state and keep it separate from work signals. |
| An agent proposes a responsibility or bar and the owner does not accept it | The proposal must not change active ownership or the accountability contract | Keep proposals pending until an authorized person accepts them. |
| An agent tries to update an active responsibility beyond its metric reading | An agent could change ownership or the accountability contract without the owner | Allow active-row agent writes only for a current metric report when the agent works under that responsibility. |
| A routine is active but has no usable agent or wake path | Automation appears configured but does not run | Report the routine as stalled and expose the reason. |
| A dashboard proposal keeps a responsibility change but drops its new area | The accepted dashboard would contain an incomplete change | Enforce proposal dependencies and reject kept changes with missing prerequisites. |
| A status report is old or no reporter can take work | The owner may trust a stale status or wait for an update that cannot happen | Mark old reports out of date and allow the owner to write the status when no reporter exists. |
| Summary facts change while model text is being generated | The displayed paragraph can describe records that no longer match the view | Use fact hashes, safe previous-text rules, and a computed fallback. |
| An agent requests permanent deletion without an accepted confirmation for that exact target | The deletion must not run, or the agent may delete the wrong area or responsibility | Require the agent's accepted confirmation card and target-specific confirmation key. |
| A dashboard restore refers to deleted work | The old responsibility arrangement may be restored without all of its former support | Restore only existing linked records and do not recreate deleted work. |
Key files
| File | Why to read it |
|---|---|
| packages/…/responsibilities.ts | Defines areas, responsibilities, and the links that connect them to projects, tasks, routines, and skills. |
| packages/…/responsibility.ts | Defines the shared ownership, rollup, detail, overview, run, and summary shapes. |
| packages/…/responsibility-bars.ts | Defines the accountability bar types and the shared health rules. |
| server/…/responsibilities.ts | Shows how responsibility membership becomes rollups, detail views, work signals, lifecycle changes, readings, and delegation. |
| server/…/responsibilities-disabled.ts | Defines the common disabled-feature response and guidance. |
| server/…/responsibility-automation.ts | Shows how routines and recent manual tasks become automation coverage and candidates. |
| server/…/responsibility-bars.ts | Shows the agent conversation and acceptance path for accountability bars and metric sets. |
| server/…/responsibility-metrics.ts | Shows chosen and starter metrics, reading history, and reading permissions. |
| server/…/responsibility-tools.ts | Shows the compact native agent tools and their confirmation and Undo behavior. |
| server/…/responsibility-agent-changes.ts | Shows how agent changes are versioned and how permanent deletion requires human confirmation. |
| server/…/responsibility-dashboard.ts | Shows the agent-assisted dashboard proposal and acceptance model. |
| server/…/responsibility-dashboard-versions.ts | Shows saved dashboard snapshots, bounded history, detail restore, and restore behavior. |
| server/…/responsibility-runs.ts | Shows the read-only recent run view for responsibility work. |
| server/…/responsibility-status-reports.ts | Shows report ownership, freshness, history, and update requests. |
| server/…/responsibility-summaries.ts | Shows the two summary views and their computed and model-backed fallback behavior. |
| ui/…/Responsibilities.tsx | Shows the organization-level dashboard surface for areas, responsibilities, automation, and summaries. |
| ui/…/ResponsibilityDetail.tsx | Shows the detail surface that joins bars, measures, work, runs, reports, and outputs. |