Cloud agents

Queueing work at night and reading it in the morning

The realistic version of overnight work, including the part where there is no scheduler.

The short answer

Overnight AI agent work means queueing tasks before you stop for the day and reading the deliveries when you return. In Polaris the queue is a Postgres table drained by a runtime process that polls every five seconds and works the oldest pending job first. Work starts because a task was assigned or commented on. There is no cron scheduler in the product today.

Trigger for work: Assignment or a comment
Scheduler: Not in the product today
Queue order: Oldest pending first

Say the limitation first

Polaris has no scheduler. You cannot tell a worker to run something every night at two. Work begins when a human assigns a task to a worker, or when someone comments on a task a worker already owns. That is the whole set of triggers, and the architecture notes name scheduling as a deliberate exclusion rather than an oversight.

What you can do is stack the queue. Assign six tasks at six in the evening and the runtime works them in creation order while nobody is watching, writing progress, files and deliveries into the database as it goes. In the morning six tasks sit in progress with a delivery comment each, waiting for someone to close them.

How to set up an evening batch

Fifteen minutes of setup buys a queue that runs itself.

1
Split the work into task-sized units
One session is capped at ten model rounds and eight minutes, so a task should be something a careful person could finish in one sitting. Three narrow tasks beat one enormous one, and they run one after another anyway.
2
Write the checklist before you assign
Checklist items are handed over as acceptance criteria and the worker ticks them as it goes. An empty checklist means nothing to verify against in the morning.
3
Say where the output belongs
Written deliverables are drafted into the Docs tree by default and the worker chooses a parent page whose topic matches, or files under Unsorted. Naming the destination in the description removes the guess.
4
Assign in the order you want them worked
Pending jobs are taken oldest first, so the sequence you assign in is the sequence you get.
5
Leave. Genuinely leave
No browser needs to stay open. The runtime holds its own database credential and writes every result server-side.

What you find in the morning

A delivery comment per task
The complete deliverable posted as a comment authored by the worker, with plain source URLs where it researched.
Documents in the shared tree
Briefs, reports and plans drafted as pages with real block structure, filed under a parent page or under Unsorted.
Files where a file was the point
Data as CSV or JSON, board-ready documents typeset as PDF, each attached to the task with a size, a type and an uploader.
A replayable session
The ordered event stream for each job, from the opening session line through searches and tool calls to the delivery.
An hours line per job
The human-equivalent estimate stored with the effort counters that produced it, ready to be challenged.
Nothing marked done
Every task sits in progress. Closing and rating stays with the person who owns the outcome.

What keeps running after you close the lid

The honest version: nothing on your laptop survives, so the work has to not be on your laptop.

How long an agent session can run, and what happens when it ends

Every agent runtime has bounds. The useful thing a vendor can do is tell you what they are.

Assigning a task to an AI worker

There is no prompt box. The task is the prompt, and the checklist is the contract.

Task queue

The thing that lets a request survive the process that made it.

Acceptance criteria

Written before the work, checkable after it, and binary either way.

Questions people ask

+Can I schedule a recurring agent task?

Not today. Polaris starts work from assignment or from a comment on an agent-owned task, and recurring schedules are listed as a deliberate non-goal in the current architecture. Assigning a task each evening is the manual equivalent.

+How many jobs run at the same time?

The runtime claims one job per cycle and works it to completion before taking the next, so a batch drains sequentially rather than in parallel. Each individual session is capped at eight minutes, which keeps a stuck job from blocking a queue all night.

+What if a job fails at three in the morning?

The error is written to the session stream, the worker's status returns to idle, and the row goes back to pending for another attempt if it has been tried fewer than twice. After that it is parked with the error message on the job row, and anything already committed during the session remains on the task.

+Will I be billed for a night that produced nothing?

Human-equivalent minutes are written only when a job finishes successfully. A job that ends in error carries no estimate and nothing to bill.

Cloud agents that keep working after you close the laptop

For the person whose agent is brilliant, local, single-player, and dead the moment the lid goes down.