“Why does the AI only work when someone types?”
Every run needs a person at a keyboard and a chat left open. When they log off, the work stops.
unattended runs: It runs overnight. You read the result.
Unattended runs are ConvOps workflows that start on a schedule, without anyone typing. Every run is on the record. People keep the approvals and the stop button.
schedules · one pod per run · tokens and cost per run · gates still hold
000306091215182101:0002:0003:0004:30
22:30sun · UTCnight window
schedulesUTC
- 01:00Content draftevery day 01:00in 2h 30m
- 02:00Bug sweepweekdays 02:00not today
- 03:00Dependency bumpevery day 03:00in 4h 30m
- 04:30Weekly SEO auditmondays 04:30not today
next: Content draft in 2h 30m
runs0
live0
tokens0
spend$0.00
done0/0
taskexecutorstatustokenscosttime
spend by model
sonnet $0.00 opus $0.00 haiku $0.00
in short
How do you run AI coding agents unattended?
Give the workflow a schedule. Each run starts without anyone typing, works in its own pod, pushes to a task branch and stops at any approval gate for a person.
ConvOps is the operations layer for AI agents: an MCP server that holds your team's process as workflows, with approval gates, a shared memory and an audit trail. It runs no AI models.
key facts · october 2026
- Four things can start a run without typing: a schedule, a run dispatching a follow-up task, an automatic resume after a time limit, and your own app through the SDK.
- A run that reaches its time limit (four hours by default) resumes automatically on the same volume, and the record links both runs.
- Work is pushed to a task branch for review. A failed run pushes to a rescue branch, so nothing it did is lost.
- Approval gates hold whether a person or a schedule started the run.
best for
- Overnight or weekly agent work you want to read in the morning.
- Teams that need a cost and a record for every unattended run.
not for
- Shipping with nobody accountable. If the workflow has a gate, the run waits for a person.
updated
the problem
The work stops when you log off.
AI that only runs while someone types is a tool, not a team. And what runs unwatched is rarely on any record.
“What ran last night?”
A script fired on someone's machine. Whether it finished, failed or never started, nobody can say.
“What did it cost?”
Tokens disappear into one monthly bill. No run, no model and no task carries its own number.
one night
From 01:00 to your morning coffee.
One bug sweep, start to finish. Nobody typed a word until the review.
01the schedule
01:00. The schedule fires.
The bug sweep has a rule: every weekday at 01:00 UTC. Nobody is awake. The schedule creates the task and starts the run.
000306091215182101:00
22:30sun · UTCnight window
schedulesUTC
- 01:00Bug sweepweekdays 01:00not today
next: Bug sweep in 2h 30m
recurrence rule · example
FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR;BYHOUR=102the run
The run gets its own pod.
One pod for this run: the agent, its tools beside it, a volume for the task and a secret for this run only. It works the workflow step by step.
namespaceconvops-runs
podrun-8c1epending
main
agentclaude codestep done
sidecar
mcptool sidecartask volumekept across stepskept
run secretthis run only
run-8c1esucceededstep donerun recorded
- non-root
- no SA token
- caps dropped
- restricted
03the time limit
It hits the time limit.
The sweep is long. At the executor's time limit the run stops cleanly. Nothing is thrown away: the volume holds every file it touched.
runBug sweep 2026-10-02scheduled
queuedpod startingworkingresumedpushing
pushed
time limit · per executor · default 4h
The run stops cleanly at the limit. The task volume, and every file on it, stays.
04auto-resume
It resumes where it stopped.
A new run starts on the same volume and carries on. The record links it to the run it continued, so the night reads as one story.
05the run
It pushes the task branch.
The fixes go to a branch named for the task, ready for review. Had the run failed, the work would sit on a rescue branch instead.
main
Task branchPushed for review on convops/task/8c1e.
06you approve
08:00. You read it and decide.
Two runs, the tokens, the cost per model, the duration. The workflow waits at the review gate. You read the branch and approve.
runs0
live0
tokens0
spend$0.00
done0/0
taskexecutorstatustokenscosttime
spend by model
opus $0.00 sonnet $0.00
Bug sweep 2026-10-02
step 5 of 6 · review
convops/task/8c1e
- runs
- 2 · resumed once
- changes
- 7 files · tests pass
- cost
- $5.18 · opus
Approve Request changes
000306091215182101:00
22:30sun · UTCnight window
schedulesUTC
- 01:00Bug sweepweekdays 01:00not today
next: Bug sweep in 2h 30m
recurrence rule · example
FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR;BYHOUR=1what starts a run
Four ways work starts on its own.
None of them needs a person at a keyboard. All of them land on the same record.
A schedule
A recurrence rule on the task, such as every weekday at 01:00 UTC. You can also fire it by hand.
rule-based
A run's follow-up
A run can dispatch the next task it finds, within a per-run limit, so one night's work can lead to the next.
bounded
A resume
A run that reaches its time limit starts again on the same volume and carries on from where it stopped.
same volume
Your app
Your own product creates scheduled work through the SDK, when your customers or your data say so.
through the SDK
schedules
Rules you can read out loud.
Every weekday at 01:00. Mondays at 05:00. Each schedule says when it fires, in UTC, and you can fire it by hand.
000306091215182101:0002:0003:3005:00
22:30sun · UTCnight window
schedulesUTC
- 01:00Content draftevery day 01:00in 2h 30m
- 02:00Bug sweepweekdays 02:00not today
- 03:30Dependency auditevery day 03:30in 5h 00m
- 05:00Weekly SEO auditmondays 05:00not today
next: Content draft in 2h 30m
history and cost
Every run, on the record.
Tokens, cost per model, turns, duration and how it ended. For every run, whoever or whatever started it.
runs0
live0
tokens0
spend$0.00
done0/0
taskexecutorstatustokenscosttime
spend by model
sonnet $0.00 opus $0.00 kimi $0.00 haiku $0.00
- tokens
- total and per model
- cost
- reported or computed, and says which
- turns · duration
- for every run
- error class
- model, infrastructure, time limit, stopped
how runs end
Four endings. Nothing lost.
Finished, stopped by a person, resumed after the time limit, or failed with the work kept. Each one is recorded.
runNightly content draftscheduled
queuedpod startingworkingfinishing
pushed
runMigrate pricing tablescheduled
queuedpod startingworkingfinishing
stopped
runBug sweepscheduled
queuedpod startingworkingresumedfinishing
pushed
runDependency bumpscheduled
queuedpod startingworkingfinishing
rescue branch
where the work lands
main
Task branchPushed for review on its own task branch.
the gate
You read it in the morning.
A schedule starts the work. It does not approve it. Gates hold for unattended runs, and any run can be stopped.
schedule01:00 UTC
workown pod
pushtask branch
reviewapproval
merge
Bug sweep 2026-10-02
step 5 of 6 · review
convops/task/8c1e
- runs
- 2 · resumed once
- changes
- 7 files · tests pass
- cost
- $5.18 · opus
Approve Request changes
example · the workflow does not move on until a person decides
runMigrate pricing tablescheduled
queuedpod startingworkingfinishing
stopped
the trust ladder
Start with approvals on every step. As trust grows, let the work run on its own.
How autonomy growsthe difference
A laptop left open vs a record.
- A script on a timer, on one machine someone has to keep awake.
- The run shares a laptop with everything else on it.
- A long job dies at the limit and the work is gone.
- Output lands wherever the script wrote it.
- Nobody knows what it cost until the invoice.
- It ships straight through. Nobody decided.
A schedule is a recurrence rule
An RFC 5545 rule on a scheduled task. Each fire creates a child task that inherits the title, project and executor, then runs it. Times are UTC.
payload
{
"tool": "schedule_create",
"arguments": {
"title": "Bug sweep {date}",
"vertical": "development",
"project": "checkout",
"rrule": "FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR;BYHOUR=1;BYMINUTE=0",
"executor": "claude-opus",
"description": "Pick open bugs, fix, test, push the task branch."
}
}Every run is a record
Each run keeps its trigger, outcome, error class and stats: tokens in total and per model, turns, duration and cost, with where the cost came from.
payload
{
"run_id": "run_4f2a",
"task": "Bug sweep 2026-10-02",
"executor_name": "claude-opus",
"agent": "claude-code",
"trigger": "resume",
"resume_of": "run_9b71",
"status": "succeeded",
"outcome": "succeeded",
"stats": {
"tokens": { "total": 71000, "by_model": { "opus": 64200, "haiku": 6800 } },
"turns": 38,
"duration_ms": 1330000,
"cost_usd": 0.82,
"cost_source": "computed"
}
}The run before it
The first run of the night ended at the time limit. Its error class says so, and the resume above points back to it.
payload
{
"run_id": "run_9b71",
"trigger": "schedule",
"status": "failed",
"outcome": "time_limit",
"stats": {
"tokens": { "total": 341000, "by_model": { "opus": 341000 } },
"turns": 214,
"duration_ms": 14400000,
"cost_usd": 4.36,
"cost_source": "reported"
}
}Time limit and follow-ups
The time limit is set per executor, four hours by default. A run may dispatch follow-up tasks, within a per-run limit, and any run can be stopped.
payload
{
"name": "claude-opus",
"backend": "isolated",
"isolated": {
"agent": "claude-code",
"model": "opus",
"time_limit_s": 14400
}
}questions
Unattended run questions, answered.
What can start a run without anyone typing?
Four things. A schedule with a recurrence rule, such as every weekday at 01:00 UTC. A run dispatching a follow-up task, within a per-run limit. An automatic resume after a time limit. And your own app, creating scheduled work through the SDK. You can also trigger any schedule by hand.
What happens when a run hits its time limit?
Every executor has a time limit, four hours by default. When a run reaches it, the run stops and resumes automatically on the same volume, so the files it was working on are still there. The record shows both runs and links the resume to the one it continued.
Where does the work end up?
The run pushes its commits to a task branch for review, or fast-forwards the target branch when the history is clean. If a run fails, its work is pushed to a rescue branch, so nothing it did is lost.
Can an unattended run ship without a person?
Only if your workflow lets it. Approvals in the workflow hold whether a person or a schedule started the run. The run waits at the gate until someone with the right role approves. Start with approvals on every step and remove them as trust grows.
How do we know what a run cost?
Every run is recorded with its tokens, a per-model split, cost, turns, duration and, when it fails, an error class. Cost is either reported by the agent or computed from tokens, and the record says which.
Can we stop a run that is going wrong?
Yes. Any running run can be stopped from the runs view or through the API. The record keeps it as stopped, with what it used up to that point.
Do runs need our laptops or our servers?
No laptop. Runs execute in isolated pods, one per run, on our cloud or on your own Kubernetes cluster. Enterprise customers can self-host with a Helm chart, so nothing has to leave the cluster.