Thinking in rhythmsHow queues, triggers and human review determine when agents can make useful progress.

I want to explain what “agents working for you 24/7” would actually require, and how to build a system that makes useful progress while you're away. If you've used an agent to research a question or revise a draft, you already know it can do useful work. The uncertainty begins when that task ends. Who decides what comes next, where does the next assignment come from, and what happens when the work needs you?

How work moves through a team

Suppose a writer, an editor and a researcher keep their essay ideas on a Linear board, with briefs and drafts in Notion. On Monday, they choose which essays to develop that week. The researcher gathers sources, the writer drafts, and the editor reviews what comes back. A short morning meeting lets them decide which work can move forward that day.

An editor's comment can become a research assignment while the writer works on another essay. The researcher saves an answer in the linked notes, ready for the writer's return. Because the board and documents retain these contributions, the team can work at different times without asking one person to remember every unfinished exchange.

Shared hours still matter. When the writer and editor disagree about the argument, a conversation lets each answer shape the next question. Once they agree, they need time apart to do the work. Sleep gives that separation a daily biological rhythm, although people differ in when they sleep and work.

The team can choose its meeting intervals. Reconsidering the week's priorities every ten minutes would interrupt the work those priorities were meant to organize. Leaving an unanswered question until next Monday could hold up an essay all week. Weekly planning and daily review give different decisions a useful interval, with a conversation between meetings when something cannot wait.

Now suppose the researcher no longer needs sleep. They can spend the night checking sources and preparing findings for morning. An assignment to “develop this idea” still leaves them waiting if the writer has not explained the idea. Removing sleep gives the researcher more time to act on what the team already knows; the extra hours do not supply the writer's missing intention.

Which work can continue without you?

An agent faces the same distinction. An agreed brief may give it enough direction to write a draft before asking for feedback. In an interview, each answer from the writer can change what it asks next. Checking a quotation also requires repeated feedback, but the source itself supplies it: the agent compares the words, corrects the mismatch and checks again.

We can separate how often the work needs feedback from whether a person must provide it. A completed draft can wait for the writer's review. An interview needs their participation throughout. Frequent feedback alone therefore tells us very little about whether the work can continue while the writer sleeps.

The matrix describes phases of work, so an essay can move between its cells. A live discussion settles the argument. Research and drafting then proceed independently, and the finished draft returns for review. The agent may make hundreds of small checks during the independent phase without needing a person at any of them.

The amount of work that can proceed alone also changes as we clarify it. “Write about autonomy” leaves many decisions open. After a discussion establishes the audience and the claim, the agent can investigate a specific example without asking what the essay is for. Human participation has made a new stretch of independent work possible.

The parts of the system

For this writing system, I'd use Linear to hold assignments and Notion to hold the material behind them. The agent would read from both, do a selected task, then save its result and update the board. A trigger would start that operation. Reviews would supply the decisions that prepare the next assignments. Each part needs a connection to the others for the work to continue across sessions.

The Linear board can distinguish work we might want from work we can start. I'd define statuses for Backlog, Ready, In progress, Needs input, Review and Done. An essay idea belongs in Backlog until we know what to ask for. A task enters Ready when its question and context are clear enough to act on. Review holds work that has returned and needs my attention.

A board with fifty essay ideas might contain only two ready assignments. “Find the original passages supporting these claims and add the links to this page” gives the agent a question it can answer and a place to leave the result. The rest of the essay can remain unsettled. Readiness applies to the next assignment, which is often much smaller than the project it belongs to.

A research assignment

Work: Check the sources for the claims marked in the linked draft.

Context: Read the essay brief and the marked passages, then follow their source links.

Result: Add the original passage and its link beside each claim. Flag any claim the source does not support.

When to pause: If the intended claim is unclear, save a specific question and mark the issue Needs input.

Next exchange: Move completed source checks to Review for the writer.

The linked Notion page holds the current brief, source material and draft. When a run ends, those records remain available to the next one. If the agent needs a decision, it can save the exact question beside the relevant passage. I can answer later, and a new run can continue from the answer instead of reconstructing the whole discussion.

Saving the draft completes only part of the handoff. The agent also needs to link the result from the issue and move it to Review, or mark it Needs input with the question that stopped it. Otherwise, useful work can exist in a document while everyone looking at the board thinks it is still underway. The shared record has to tell the next person what they can do now.

A trigger determines when the agent returns to that record. A cron job can start a queue check at a chosen time. A Linear webhook can notify a connected service when an issue changes, so that service can start a run when a task becomes Ready. In either arrangement, the trigger supplies the occasion to act; the issue and its linked brief supply the assignment.

These connections require setup. The agent needs authorized access to the board and Notion's content API, along with instructions for choosing tasks and saving results. A board containing assignments cannot start work by itself. Once the tools and trigger are connected, the next run can pick up an assignment without requiring me to open a chat and explain it again.

Where the next work comes from

The queue also lets work arrive independently of whoever is doing it. While the agent researches one essay, I can add a question about another. The new assignment remains on the board until there is capacity to take it. Without that shared queue, I would have to interrupt the current session or remember to start another one later.

Work creates further work for specific reasons. A draft exposes a claim with no supporting source, so its review produces a research task. The research finds a contradiction, so the essay needs a discussion. After the writer resolves the contradiction, a revision becomes possible. The queue grows through these exchanges as the team learns what the essay needs.

Some exchanges add tasks; others unblock tasks that already exist. An answer to yesterday's interview question may let the agent continue the same draft. Moving that assignment from Needs input to Ready records the change. The number of issues stays the same, but the amount of work the agent can do without me has increased.

The agent can help maintain this supply. I might ask it to flag unsupported claims in active drafts and create research tasks for them, or check selected sources for material relevant to those essays. These instructions give new tasks an editorial purpose. Asking for endless new ideas merely to keep the machine occupied would create a growing list for me to sort through.

One activation can handle several assignments. After saving a result, the agent checks Ready again and takes the next task. The run can continue for hours if useful work remains, then stop when the ready queue empties or a limit is reached. It does not need a fresh scheduled trigger between every task. A later trigger lets it return to a queue that may have changed. The scheduler or event receiver has to remain available even when no agent run is active.

Changing the tempo

The recurring queue check has a tempo we can adjust. Checking once a day leaves newly ready work waiting longer than checking once an hour. The metronome controls when the agent looks for work; it does not determine how long each assignment takes or when the writer will review it.

Suppose a brief becomes Ready on Monday at 9:05 a.m., and the agent is available to take it. A daily check at nine will not see it until Tuesday morning. An hourly check sees it at ten on Monday. A trigger attached to the change of status can start the work immediately. Each faster setting reduces the delay before the same assignment begins.

If the draft takes one hour and I review at nine each morning, that delay affects the whole essay. The daily check starts on Tuesday at nine and finishes at ten, too late for Tuesday's review. I read it on Wednesday. The hourly check finishes on Monday at eleven, so I can read it on Tuesday. A more frequent check has saved a day.

Starting immediately at 9:05 on Monday finishes the draft at 10:05, another fifty-five minutes earlier. I still read it on Tuesday at nine. Both of those schedules have reached the same review, so accelerating the start again changes how long the draft waits on my desk. Further gains now require an earlier review, which would change my schedule as well as the agent's.

The board makes the next delay visible. If tasks sit in Ready, I can inspect how long they wait for pickup and how long the agent spends on each assignment. If Review keeps growing, the agent is completing work faster than I am reviewing it. More drafting capacity would then add to the pile that needs my attention.

Batching and limits on work in progress change that arrangement. Suppose I can review two drafts each morning. Producing ten before the first review risks repeating the same misunderstanding across all ten. Producing two, applying the feedback and then preparing the next two lets the correction affect later work. A smaller batch can mean less finished material at first and less rewriting afterward.

The information outside the system has a tempo too. If a source publishes roughly once a week, checking every minute mostly returns the same page. Frequent checks can detect the next update sooner, but those saved minutes matter only if someone can use them. Repeatedly checking a draft while I sleep cannot produce the opinion I have yet to form.

Some changes do justify an extra run. A source correction arriving before publication may need attention before the regular review. In work that depends on a brief price movement, waiting an hour could lose the opportunity entirely. A system can keep its ordinary daily rhythm and still respond to selected events as they happen.

What the meeting produces

A meeting can produce information that no amount of independent drafting would supply. If I say a draft explains a technique when I wanted it to explain an idea, that comment identifies a problem without fully resolving it. A conversation can establish what I expect the reader to understand and which example would make that understanding possible.

Each answer changes the next useful question. Once we agree on the intended argument, the agent can point to a paragraph that no longer belongs or ask for the missing premise. Generating ten more versions before that exchange would give me more prose built around the same unresolved choice.

The conversation needs to leave a revised brief in Notion and concrete work on the board. “Find an example of this dependency” can then become a research assignment. “Revise the opening around the agreed question” can become another. The next run inherits the decisions through these records, allowing the work to continue after the conversation ends.

A live meeting is useful when the questions depend on one another. Clear comments on a finished draft can wait for the next run, because the agent can act on them without asking another question first. Synchronization can take either form. Its purpose is to exchange the information the next phase needs, at a time when someone can use it.

A writing day with agents

With this arrangement, I would return each morning to drafts, findings and a short list of questions. My review would make some revisions ready and identify which essays need a conversation. During the day, new ideas could enter the backlog while the agent handled prepared assignments. Whatever remained ready at night could continue without requiring me to stay at the desk.

An idle agent would then have a reason I could inspect. It might have completed the prepared work, or the remaining essays might need my decisions. A task sitting in Ready because its trigger failed would be a different condition, with a different fix. The dark screen alone tells me none of this; the queue and its history tell me what happened. For each assignment, I can record four times: when it became ready, started, finished and was used. Those times separate the wait to start, the work itself, and the wait for someone to use the result.

When work stops moving

Where to look	What to check
Ready → Started	Did the trigger arrive? Did the agent select the task, and was it available to begin?
Started → Finished	Is the work still progressing, or does it need an answer? Save any missing question and name who can answer it.
Finished → Used	Can the next person find and use the result? Check the handoff, review time and batch size.
Nothing becomes Ready	Does the backlog contain clear assignments? Which discussion, source or decision would make the next task possible?
Checks return unchanged material	How often does the source change, and would earlier detection affect the next decision?

For a first version, I'd connect one essay's brief and task board to a scheduled run, then set a time to review its result. I would compare those four times before changing the schedule. In the Monday example, an hourly check gets the draft into Tuesday's review; starting immediately leaves it waiting there longer. Following the work through to its next use shows which interval is worth changing, including the time I need to supply a decision.