> ## Documentation Index
> Fetch the complete documentation index at: https://docs.plannotator.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# What an AI Agent Night Shift Looks Like for Teams
> A practical team workflow for turning approved plans into code, product artifacts, tests, screenshots, and a morning review packet while AI agents work overnight.
An AI agent night shift is an asynchronous team workflow. During the day, the team agrees on a bounded goal, the context that should guide it, and the limits on what agents may do. Overnight, agents work across dependent stages. In the morning, the team reviews the returned code and artifacts before deciding what to revise, approve, or run next.
*Last reviewed July 18, 2026. Maintained by the Plannotator project.*
My first successful night shift ran for more than twelve hours. It was a `/goal` run using GPT-5.6 Sol with Ultra, and it crossed work that would usually involve design, development, product, image generation, and go-to-market. I woke up to useful, on-brand assets and new motivation for the team. That day, teammates helped shape and greenlight a larger second goal.
The useful loop is:
**Set the goal together → approve the context → run the night shift → review real outputs → learn and align → set the next goal**
## The Night Shift started as a developer workflow
[Jamon Holmgren's Night Shift](https://jamon.dev/night-shift) describes a focused solo pattern: write and approve detailed specifications during the day, let agents implement them while you are away, then review the commits and documentation in the morning.
A team night shift keeps that boundary and expands the work around it. Product, design, engineering, customer-facing teammates, security, operations, and go-to-market may all contribute to the goal or its constraints. The morning handoff must support their different review responsibilities.
The pattern does not depend on darkness. It can run during a weekend, a meeting block, or across time zones. What matters is the boundary between two periods of human attention.
## Why long-running AI agents make this practical
The first run combined three Codex concepts:
* **GPT-5.6 Sol** was the model used for complex, open-ended work.
* **Ultra** was the execution setting, including delegation of suitable work to subagents.
* **`/goal`** gave the run one persistent objective and completion target.
Anthropic describes a similar direction for [Claude Fable 5](https://www.anthropic.com/claude/fable), including long-running asynchronous work, planning across stages, selective delegation, and reviewable deliverables.
These capabilities are useful when the work forms a [long-horizon task](/learn/ai-development/what-are-long-horizon-tasks-for-ai-agents): one coherent objective whose later stages depend on decisions, experiments, or changes made earlier. Runtime alone does not make a task long-horizon. The agent must preserve state, verify progress, recover from failed approaches, and continue toward one definition of done.
## One person approved the first run. The team set the second goal.
The first night shift did not begin with a new company process. One person set a bounded goal and authorized the run. The resulting software, images, product work, and launch material gave teammates something concrete to inspect.
That changed the next conversation. The team could react to real output instead of debating an abstract possibility. Teammates contributed more context and ambition, then helped define the next night's goal.
Useful output can create momentum, but excitement is not a shipping verdict. The team still needs to decide whether the work is correct, coherent, and worth carrying forward.
## Prepare the run together
Requests enter a team with unresolved questions. A customer may describe a problem without knowing the right product behavior. A design direction may conflict with an operating constraint. An implementation may be possible in several ways, each with different costs and risks.
During the day, the team handles the decisions that require shared judgment:
* understand the customer or internal request;
* inspect the product, codebase, and current behavior;
* compare product, design, and technical approaches;
* choose the brand and customer story when they are part of the goal;
* define scope, constraints, and unacceptable outcomes;
* identify observable acceptance criteria;
* name the people who must review the result.
Agents can investigate the repository, answer questions, create prototypes, and compare options during this phase. The team resolves consequential disagreements before the overnight run begins.
Record the approved handoff in a form that people and agents can inspect:
| The team approves | The handoff records |
| ------------------ | ---------------------------------------------------------------- |
| Exact scope | The approved plan or context version |
| Constraints | Systems, files, data, and environments the agent may touch |
| Definition of done | Required behavior and validation |
| Evidence | Tests, screenshots, traces, videos, HTML, or documents to return |
| Stop conditions | Decisions and failures that must come back to a person |
| Review ownership | Named morning reviewers and the expected decision |
An individual developer may handle a small, reversible task faster in a normal agent conversation. Shared preparation earns its cost when the work crosses people, systems, or business decisions.
## Execute one goal across several functions
A cross-functional night shift should produce a connected body of work, not a folder of unrelated agent output.
Research informs product choices. Product choices shape the implementation. Working software produces screenshots, traces, documentation, launch material, and review evidence. Each stage uses what the earlier stage learned.
A practical run can:
1. confirm a clean, passing baseline;
2. load the approved context and relevant project documentation;
3. work in an isolated branch, worktree, or sandbox;
4. create a test and validation plan;
5. implement and inspect the work in bounded stages;
6. produce the required code, design, product, documentation, and launch artifacts;
7. run focused and end-to-end validation;
8. update the living documentation affected by the change;
9. stop and return a question when the answer would exceed the approved context.
Use parallel agents for genuinely separable work. Tightly coupled decisions are often easier to preserve when one agent advances the main sequence and delegates selected research, testing, or asset work.
This workflow can also support forward-deployed engineering: a product and engineering team working closely with a customer from discovery and technical scoping through a reviewable implementation, demonstration, and documentation set.
## What belongs in the morning review packet?
The morning review packet should let teammates understand and verify the work without reconstructing the private agent session.
Include:
* the authorizing goal and exact approved context version;
* the exact revision or set of revisions;
* a map of what changed and why;
* test, typecheck, lint, build, and CI results as applicable;
* screenshots of important interface states;
* product or demo video when motion matters;
* Playwright video or traces when browser behavior needs inspection;
* generated images, documents, HTML, or Markdown explainers with their intended use;
* failed approaches, deviations, unresolved questions, and risks;
* proposed updates to maintained product and technical documentation.
[Playwright traces](https://playwright.dev/docs/trace-viewer-intro) can preserve actions, page state, console output, network activity, errors, source, and DOM snapshots. They are useful because reviewers can inspect the behavior behind a polished demo. Tests, revisions, screenshots, and other [code review artifacts](/learn/code-review/what-are-code-review-artifacts) support the summary's claims.
The summary is an index. It does not certify the work.
## Review the result and set the next goal
Different teammates inspect different parts of the morning packet:
* engineering reviews the exact code and validation;
* product checks whether the agreed outcome was built;
* design reviews the behavior and experience, not only screenshots;
* customer-facing teammates confirm that the result answers the real request;
* owners resolve open questions and approve, revise, or stop the work.
Record what the team learned alongside its verdict. Use those findings to revise the current work or set the next goal. Repeated runs without review create a backlog of disconnected output.
If an agent pushes more revisions after review begins, use a [revision diff](/learn/code-review/what-is-a-revision-diff) to see the cumulative change since the last completed review.
## Start with one bounded night
The first team experiment should have:
* one approved feature, product slice, or customer workflow;
* one isolated execution environment;
* one required morning review packet;
* one named review group;
* no autonomous production deployment.
Judge the run by the quality and speed of the morning decision. The team should be able to understand the result, inspect the evidence, and decide what happens next. Tokens, commits, changed lines, and runtime do not measure that outcome.
A night shift is a poor candidate when the requirements remain disputed, the agent has destructive production access, tests and documentation cannot guide unattended work, or the task requires the agent to invent business policy. The agent should stop when it reaches an unapproved decision boundary.
## Where Plannotator fits
Open-source Plannotator gives you local review points before and after a long-running agent task. Use [plan review](/open-source/workflows/plan-review) to annotate the proposed work and return feedback before implementation. Use [code review](/open-source/workflows/local-changes) to inspect the returned local changes, or open a [pull request or merge request](/open-source/workflows/pull-requests) when the agent pushed one.
Plannotator does not schedule the agent or enforce a team authorization process. It opens the current plan, document, or diff for review and sends your decision or comments back to the active agent session.
## Frequently asked questions
### Does an AI agent night shift have to run overnight?
No. It is asynchronous execution between two periods of focused human work. A weekend, a meeting block, or work across time zones can use the same boundary.
### Can teams use Codex, Claude Code, Cursor, or another agent?
Yes. The workflow needs durable context, isolated execution, controlled permissions, inspectable evidence, and human review. It does not depend on one vendor.
### Should the agent merge or deploy when it finishes?
Not by default. A first team night shift should return reviewable work. Merge and deployment authority are separate decisions with a larger blast radius.
### What should happen when the agent needs a new decision?
It should stop that part of the work, preserve what it learned, and return a specific question. It should not invent product policy or expand its own scope.
### Is the Night Shift only for code?
No. The useful output may include code, product copy, design exploration, research, reports, documentation, screenshots, browser traces, and demo videos. Each artifact should support the approved goal and a real morning decision.
Learn what makes a task long-horizon and how to prepare the objective, checkpoints, memory, validation, and review boundary.