responsibilities.dev

Agent architecture

Give AI agents responsibilities, not just tasks.

A task ends when it is done. A responsibility holds: the agent watches over something for days rather than for one prompt, notices when it changes and keeps track of what it has found. People stay accountable for what happens next.

Observe deterministically. Judge probabilistically. Remember persistently.

01

Tasks end. Responsibilities don’t.

Most agents are given tasks: a request comes in, work happens, an answer goes out, and the agent forgets. That is the right shape for “fix this bug” or “summarise this thread”. It is the wrong shape for “make sure nothing gets stuck”, which is never finished and never fits in a single run.

A task

Starts
When someone asks.
Ends
When the answer is delivered.
Looks at
Whatever is in the prompt.
Remembers
Nothing, unless told again.
Example
“Find the issues that are stuck.”

A responsibility

Starts
When it is defined.
Ends
Only when it is withdrawn.
Looks at
The same signals, on every run.
Remembers
Every case it opened, and why.
Example
“Make sure work doesn’t stay in progress for too long.”

02

Three principles

An agent with a responsibility runs again and again, mostly while nobody is watching. So each part of the work goes to whatever does it most reliably, and each part can be checked on its own.

  1. Observe deterministically.

    What gets looked at is decided by plain, stored queries, not by a model. The same data yields the same observations, and the observations behind a case are kept as evidence that can be inspected later.

  2. Judge probabilistically.

    Deciding whether a situation deserves attention, and saying why, is work for a language model. It proposes; it does not have the last word. Code checks each proposal: that its subject is eligible, that it is well-formed and that it cites evidence that was actually recorded.

  3. Remember persistently.

    Conclusions become cases: durable records that open, collect evidence and resolve when the situation does. Memory lives in stored state, not in a context window, so it carries over from one run to the next.

03

Signals, case instructions, cases

A responsibility is defined by what to observe and what deserves attention. What it produces is cases, for people to act on.

  1. Observe

    Signals

    Stored queries against a system you already use. They run on a schedule, and each run yields observations: which subjects matched, and when.

  2. Judge

    Case instructions

    Plain-language instructions, plus optional hard rules such as a minimum number of observation days. A model reads them together with the evidence and drafts case proposals.

  3. Remember

    Persistent cases

    Proposals that pass a deterministic check become cases. A case names the situation that needs attention and cites its evidence. It stays open, collecting new evidence, until a rule the responsibility defines resolves it.

04

Example: “Work in progress for days”

Work that sits In Progress and quietly stops moving is easy to overlook. Here is the responsibility for it in full, with Jira as the system being watched.

The responsibility, defined
Responsibility
Work in progress for days
Intent
Make sure work doesn’t stay In Progress for too long.
Signal
Issues in an In Progress status
statusCategory = "In Progress"
Hard rule
A case can open only after an issue has matched on N observation days, a threshold the team sets.
Case instructions

Title the case after the work item, in plain language. In the description, say which work item it is and for how many days it has been observed, using only the evidence given. In the explanation, say which signals matched on which days, and cite that evidence. Don’t guess why the work is stuck.

Case
At most one open case per issue. It resolves when a later run no longer finds the issue In Progress.

How a run works

  1. Once a day, the stored query runs. Each issue it finds is recorded as an observation for that day.
  2. When an issue has matched on enough days and has no open case, a language model drafts a case proposal from the instructions and the recorded evidence.
  3. Code checks the proposal: it must be about an eligible issue and cite only evidence that was actually recorded. Only then does the case open; the model never sets a case’s status.
  4. The team sees which work has stayed In Progress, for how many observed days and on what evidence, and decides what to do. When a later run no longer finds the issue, the case resolves and keeps its history.

05

Two more responsibilities

The same split carries over to other work that never finishes. The first draws its signal from Jira, the second from a support system.

Jira

Blocked dependencies

“Make sure blocked work doesn’t wait unnoticed.”

Signal
Issues flagged as blocked, and issues with an “is blocked by” link to an issue that is still unresolved. Each day’s matches are recorded, so the evidence shows how long every block has held.
Case instructions
“Say whether the blocker belongs to another team, what else is waiting on it and whether it is worth escalating. Cite the days and links observed. Don’t guess why it is blocked.”
Case
One per blocked issue, with its blockers and the days they were seen. It stays open while the block holds and resolves when a later run no longer finds the block.

Support system

Recurring customer complaints

“Make sure a problem many customers report is seen as one problem.”

Signal
New support tickets that match a stored filter, such as a product area or tag, recorded by day. The query decides which tickets are looked at, not which ones belong together.
Case instructions
“Group tickets that describe the same problem, and say whether a group points to something systemic, such as a defect or a confusing change. Cite every ticket you group.”
Case
One per problem, not per ticket. New tickets that fit are added as evidence, so the case shows when the problem began and how it grew. It resolves once no new ticket has fitted for a set number of days.

06

Agents are responsible. People are accountable.

A responsibility makes an agent responsible for keeping watch: noticing, judging and remembering, run after run. Accountability for the outcome stays with people. They decide what the agent watches, and they decide what happens next.

The agent

  • Runs the signals on a schedule and records what they find.
  • Proposes cases, each citing its evidence. Code, not the model, decides which ones open.
  • Keeps every case, open or resolved, with the history that led to it.

People

  • Define the intent, the signals and the case instructions. An agent can draft a responsibility, but it takes effect only once a person approves it.
  • Decide what to do about each case. Reassigning work, escalating a blocker or fixing a defect is their call, not the agent’s.
  • Can check any case: re-run its query, compare the judgment with its evidence and follow its history.